1 <?php

     2 

     3 /**

     4  * @file

     5  * Drupal database update API.

     6  *

     7  * This file contains functions to perform database updates for a Drupal

     8  * installation. It is included and used extensively by update.php.

     9  */

    10 

    11 /**

    12  * Minimum schema version of Drupal 6 required for upgrade to Drupal 7.

    13  *

    14  * Upgrades from Drupal 6 to Drupal 7 require that Drupal 6 be running

    15  * the most recent version, or the upgrade could fail. We can't easily

    16  * check the Drupal 6 version once the update process has begun, so instead

    17  * we check the schema version of system.module in the system table.

    18  */

    19 define('REQUIRED_D6_SCHEMA_VERSION', '6055');

    20 

    21 /**

    22  * Disable any items in the {system} table that are not core compatible.

    23  */

    24 function update_fix_compatibility() {

    25   $incompatible = array();

    26   $result = db_query("SELECT name, type, status FROM {system} WHERE status = 1 AND type IN ('module','theme')");

    27   foreach ($result as $row) {

    28     if (update_check_incompatibility($row->name, $row->type)) {

    29       $incompatible[] = $row->name;

    30     }

    31   }

    32   if (!empty($incompatible)) {

    33     db_update('system')

    34       ->fields(array('status' => 0))

    35       ->condition('name', $incompatible, 'IN')

    36       ->execute();

    37   }

    38 }

    39 

    40 /**

    41  * Tests the compatibility of a module or theme.

    42  */

    43 function update_check_incompatibility($name, $type = 'module') {

    44   static $themes, $modules;

    45 

    46   // Store values of expensive functions for future use.

    47   if (empty($themes) || empty($modules)) {

    48     // We need to do a full rebuild here to make sure the database reflects any

    49     // code changes that were made in the filesystem before the update script

    50     // was initiated.

    51     $themes = system_rebuild_theme_data();

    52     $modules = system_rebuild_module_data();

    53   }

    54 

    55   if ($type == 'module' && isset($modules[$name])) {

    56     $file = $modules[$name];

    57   }

    58   elseif ($type == 'theme' && isset($themes[$name])) {

    59     $file = $themes[$name];

    60   }

    61   if (!isset($file)

    62       || !isset($file->info['core'])

    63       || $file->info['core'] != DRUPAL_CORE_COMPATIBILITY

    64       || version_compare(phpversion(), $file->info['php']) < 0) {

    65     return TRUE;

    66   }

    67   return FALSE;

    68 }

    69 

    70 /**

    71  * Performs extra steps required to bootstrap when using a Drupal 6 database.

    72  *

    73  * Users who still have a Drupal 6 database (and are in the process of

    74  * updating to Drupal 7) need extra help before a full bootstrap can be

    75  * achieved. This function does the necessary preliminary work that allows

    76  * the bootstrap to be successful.

    77  *

    78  * No access check has been performed when this function is called, so no

    79  * irreversible changes to the database are made here.

    80  */

    81 function update_prepare_d7_bootstrap() {

    82   // Allow the bootstrap to proceed even if a Drupal 6 settings.php file is

    83   // still being used.

    84   include_once DRUPAL_ROOT . '/includes/install.inc';

    85   drupal_bootstrap(DRUPAL_BOOTSTRAP_CONFIGURATION);

    86   global $databases, $db_url, $db_prefix, $update_rewrite_settings;

    87   if (empty($databases) && !empty($db_url)) {

    88     $databases = update_parse_db_url($db_url, $db_prefix);

    89     // Record the fact that the settings.php file will need to be rewritten.

    90     $update_rewrite_settings = TRUE;

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

    92     $writable = drupal_verify_install_file($settings_file, FILE_EXIST|FILE_READABLE|FILE_WRITABLE);

    93     $requirements = array(

    94       'settings file' => array(

    95         'title' => 'Settings file',

    96         'value' => $writable ? 'The settings file is writable.' : 'The settings file is not writable.',

    97         'severity' => $writable ? REQUIREMENT_OK : REQUIREMENT_ERROR,

    98         'description' => $writable ? '' : 'Drupal requires write permissions to <em>' . $settings_file . '</em> during the update process. If you are unsure how to grant file permissions, consult the <a href="http://drupal.org/server-permissions">online handbook</a>.',

    99       ),

   100     );

   101     update_extra_requirements($requirements);

   102   }

   103 

   104   // The new {blocked_ips} table is used in Drupal 7 to store a list of

   105   // banned IP addresses. If this table doesn't exist then we are still

   106   // running on a Drupal 6 database, so we suppress the unavoidable errors

   107   // that occur by creating a static list.

   108   $GLOBALS['conf']['blocked_ips'] = array();

   109 

   110   // Check that PDO is available and that the correct PDO database driver is

   111   // loaded. Bootstrapping to DRUPAL_BOOTSTRAP_DATABASE will result in a fatal

   112   // error otherwise.

   113   $message = '';

   114   $pdo_link = 'http://drupal.org/requirements/pdo';

   115   // Check that PDO is loaded.

   116   if (!extension_loaded('pdo')) {

   117     $message = '<h2>PDO is required!</h2><p>Drupal 7 requires PHP ' . DRUPAL_MINIMUM_PHP . ' or higher with the PHP Data Objects (PDO) extension enabled.</p>';

   118   }

   119   // The PDO::ATTR_DEFAULT_FETCH_MODE constant is not available in the PECL

   120   // version of PDO.

   121   elseif (!defined('PDO::ATTR_DEFAULT_FETCH_MODE')) {

   122     $message = '<h2>The wrong version of PDO is installed!</h2><p>Drupal 7 requires the PHP Data Objects (PDO) extension from PHP core to be enabled. This system has the older PECL version installed.';

   123     $pdo_link = 'http://drupal.org/requirements/pdo#pecl';

   124   }

   125   // Check that the correct driver is loaded for the database being updated.

   126   // If we have no driver information (for example, if someone tried to create

   127   // the Drupal 7 $databases array themselves but did not do it correctly),

   128   // this message will be confusing, so do not perform the check; instead, just

   129   // let the database connection fail in the code that follows.

   130   elseif (isset($databases['default']['default']['driver']) && !in_array($databases['default']['default']['driver'], PDO::getAvailableDrivers())) {

   131     $message = '<h2>A PDO database driver is required!</h2><p>You need to enable the PDO_' . strtoupper($databases['default']['default']['driver']) . ' database driver for PHP ' . DRUPAL_MINIMUM_PHP . ' or higher so that Drupal 7 can access the database.</p>';

   132   }

   133   if ($message) {

   134     print $message . '<p>See the <a href="' . $pdo_link . '">system requirements page</a> for more information.</p>';

   135     exit();

   136   }

   137 

   138   // Allow the database system to work even if the registry has not been

   139   // created yet.

   140   drupal_bootstrap(DRUPAL_BOOTSTRAP_DATABASE);

   141 

   142   // If the site has not updated to Drupal 7 yet, check to make sure that it is

   143   // running an up-to-date version of Drupal 6 before proceeding. Note this has

   144   // to happen AFTER the database bootstraps because of

   145   // drupal_get_installed_schema_version().

   146   $system_schema = drupal_get_installed_schema_version('system');

   147   if ($system_schema < 7000) {

   148     $has_required_schema = $system_schema >= REQUIRED_D6_SCHEMA_VERSION;

   149     $requirements = array(

   150       'drupal 6 version' => array(

   151         'title' => 'Drupal 6 version',

   152         'value' => $has_required_schema ? 'You are running a current version of Drupal 6.' : 'You are not running a current version of Drupal 6',

   153         'severity' => $has_required_schema ? REQUIREMENT_OK : REQUIREMENT_ERROR,

   154         'description' => $has_required_schema ? '' : 'Please update your Drupal 6 installation to the most recent version before attempting to upgrade to Drupal 7',

   155       ),

   156     );

   157 

   158     // Make sure that the database environment is properly set up.

   159     try {

   160       db_run_tasks(db_driver());

   161     }

   162     catch (DatabaseTaskException $e) {

   163       $requirements['database tasks'] = array(

   164         'title' => 'Database environment',

   165         'value' => 'There is a problem with your database environment',

   166         'severity' => REQUIREMENT_ERROR,

   167         'description' => $e->getMessage(),

   168       );

   169     }

   170 

   171     update_extra_requirements($requirements);

   172 

   173     // Allow a D6 session to work, since the upgrade has not been performed yet.

   174     $d6_session_name = update_get_d6_session_name();

   175     if (!empty($_COOKIE[$d6_session_name])) {

   176       // Set the current sid to the one found in the D6 cookie.

   177       $sid = $_COOKIE[$d6_session_name];

   178       $_COOKIE[session_name()] = $sid;

   179       session_id($sid);

   180     }

   181 

   182     // Upgrading from D6 to D7.{0,1,2,3,4,8,...} is different than upgrading

   183     // from D6 to D7.{5,6,7} which should be considered broken. To be able to

   184     // properly handle this difference in node_update_7012 we need to keep track

   185     // of whether a D6 > D7 upgrade or a D7 > D7 update is running.

   186     // Since variable_set() is not available here, the D6 status is being saved

   187     // in a local variable to be able to store it later.

   188     $update_d6 = TRUE;

   189   }

   190 

   191   // Create the registry tables.

   192   if (!db_table_exists('registry')) {

   193     $schema['registry'] = array(

   194       'fields' => array(

   195         'name'   => array('type' => 'varchar', 'length' => 255, 'not null' => TRUE, 'default' => ''),

   196         'type'   => array('type' => 'varchar', 'length' => 9, 'not null' => TRUE, 'default' => ''),

   197         'filename'   => array('type' => 'varchar', 'length' => 255, 'not null' => TRUE, 'default' => ''),

   198         'module'   => array('type' => 'varchar', 'length' => 255, 'not null' => TRUE, 'default' => ''),

   199         'weight'   => array('type' => 'int', 'not null' => TRUE, 'default' => 0),

   200       ),

   201       'primary key' => array('name', 'type'),

   202       'indexes' => array(

   203         'hook' => array('type', 'weight', 'module'),

   204       ),

   205     );

   206     db_create_table('registry', $schema['registry']);

   207   }

   208   if (!db_table_exists('registry_file')) {

   209     $schema['registry_file'] = array(

   210       'fields' => array(

   211         'filename'   => array('type' => 'varchar', 'length' => 255, 'not null' => TRUE),

   212         'hash'   => array('type' => 'varchar', 'length' => 64, 'not null' => TRUE),

   213       ),

   214       'primary key' => array('filename'),

   215     );

   216     db_create_table('registry_file', $schema['registry_file']);

   217   }

   218 

   219   // Older versions of Drupal 6 do not include the semaphore table, which is

   220   // required to bootstrap, so we add it now so that we can bootstrap and

   221   // provide a reasonable error message.

   222   if (!db_table_exists('semaphore')) {

   223     $semaphore = array(

   224       'description' => 'Table for holding semaphores, locks, flags, etc. that cannot be stored as Drupal variables since they must not be cached.',

   225       'fields' => array(

   226         'name' => array(

   227           'description' => 'Primary Key: Unique name.',

   228           'type' => 'varchar',

   229           'length' => 255,

   230           'not null' => TRUE,

   231           'default' => ''

   232         ),

   233         'value' => array(

   234           'description' => 'A value for the semaphore.',

   235           'type' => 'varchar',

   236           'length' => 255,

   237           'not null' => TRUE,

   238           'default' => ''

   239         ),

   240         'expire' => array(

   241           'description' => 'A Unix timestamp with microseconds indicating when the semaphore should expire.',

   242           'type' => 'float',

   243           'size' => 'big',

   244           'not null' => TRUE

   245         ),

   246       ),

   247       'indexes' => array(

   248         'value' => array('value'),

   249         'expire' => array('expire'),

   250       ),

   251       'primary key' => array('name'),

   252     );

   253     db_create_table('semaphore', $semaphore);

   254   }

   255 

   256   // The new cache_bootstrap bin is required to bootstrap to

   257   // DRUPAL_BOOTSTRAP_SESSION, so create it here rather than in

   258   // update_fix_d7_requirements().

   259   if (!db_table_exists('cache_bootstrap')) {

   260     $cache_bootstrap = array(

   261       'description' => 'Cache table for data required to bootstrap Drupal, may be routed to a shared memory cache.',

   262       'fields' => array(

   263         'cid' => array(

   264           'description' => 'Primary Key: Unique cache ID.',

   265           'type' => 'varchar',

   266           'length' => 255,

   267           'not null' => TRUE,

   268           'default' => '',

   269         ),

   270         'data' => array(

   271           'description' => 'A collection of data to cache.',

   272           'type' => 'blob',

   273           'not null' => FALSE,

   274           'size' => 'big',

   275         ),

   276         'expire' => array(

   277           'description' => 'A Unix timestamp indicating when the cache entry should expire, or 0 for never.',

   278           'type' => 'int',

   279           'not null' => TRUE,

   280           'default' => 0,

   281         ),

   282         'created' => array(

   283           'description' => 'A Unix timestamp indicating when the cache entry was created.',

   284           'type' => 'int',

   285           'not null' => TRUE,

   286           'default' => 0,

   287         ),

   288         'serialized' => array(

   289           'description' => 'A flag to indicate whether content is serialized (1) or not (0).',

   290           'type' => 'int',

   291           'size' => 'small',

   292           'not null' => TRUE,

   293           'default' => 0,

   294         ),

   295       ),

   296       'indexes' => array(

   297         'expire' => array('expire'),

   298       ),

   299       'primary key' => array('cid'),

   300     );

   301     db_create_table('cache_bootstrap', $cache_bootstrap);

   302   }

   303 

   304   // Set a valid timezone for 6 -> 7 upgrade process.

   305   drupal_bootstrap(DRUPAL_BOOTSTRAP_VARIABLES);

   306   $timezone_offset = variable_get('date_default_timezone', 0);

   307   if (is_numeric($timezone_offset)) {

   308     // Save the original offset.

   309     variable_set('date_temporary_timezone', $timezone_offset);

   310     // Set the timezone for this request only.

   311     $GLOBALS['conf']['date_default_timezone'] = 'UTC';

   312   }

   313 

   314   // This allows update functions to tell if an upgrade from D6 is running.

   315   if (!empty($update_d6)) {

   316     variable_set('update_d6', TRUE);

   317   }

   318 }

   319 

   320 /**

   321  * A helper function that modules can use to assist with the transformation

   322  * from numeric block deltas to string block deltas during the 6.x -> 7.x

   323  * upgrade.

   324  *

   325  * @todo This function should be removed in 8.x.

   326  *

   327  * @param $sandbox

   328  *   An array holding data for the batch process.

   329  * @param $renamed_deltas

   330  *   An associative array.  Keys are module names, values an associative array

   331  *   mapping the old block deltas to the new block deltas for the module.

   332  *   Example:

   333  *   @code

   334  *     $renamed_deltas = array(

   335  *       'mymodule' =>

   336  *         array(

   337  *           0 => 'mymodule-block-1',

   338  *           1 => 'mymodule-block-2',

   339  *         ),

   340  *     );

   341  *   @endcode

   342  * @param $moved_deltas

   343  *   An associative array. Keys are source module names, values an associative

   344  *   array mapping the (possibly renamed) block name to the new module name.

   345  *   Example:

   346  *   @code

   347  *     $moved_deltas = array(

   348  *       'user' =>

   349  *         array(

   350  *           'navigation' => 'system',

   351  *         ),

   352  *     );

   353  *   @endcode

   354  */

   355 function update_fix_d7_block_deltas(&$sandbox, $renamed_deltas, $moved_deltas) {

   356   // Loop through each block and make changes to the block tables.

   357   // Only run this the first time through the batch update.

   358   if (!isset($sandbox['progress'])) {

   359     // Determine whether to use the old or new block table names.

   360     $block_tables = db_table_exists('blocks') ? array('blocks', 'blocks_roles') : array('block', 'block_role');

   361     foreach ($block_tables as $table) {

   362       foreach ($renamed_deltas as $module => $deltas) {

   363         foreach ($deltas as $old_delta => $new_delta) {

   364           // Only do the update if the old block actually exists.

   365           $block_exists = db_query("SELECT COUNT(*) FROM {" . $table . "} WHERE module = :module AND delta = :delta", array(

   366               ':module' => $module,

   367               ':delta' => $old_delta,

   368             ))

   369             ->fetchField();

   370           if ($block_exists) {

   371             // Delete any existing blocks with the new module+delta.

   372             db_delete($table)

   373               ->condition('module', $module)

   374               ->condition('delta', $new_delta)

   375               ->execute();

   376             // Rename the old block to the new module+delta.

   377             db_update($table)

   378               ->fields(array('delta' => $new_delta))

   379               ->condition('module', $module)

   380               ->condition('delta', $old_delta)

   381               ->execute();

   382           }

   383         }

   384       }

   385       foreach ($moved_deltas as $old_module => $deltas) {

   386         foreach ($deltas as $delta => $new_module) {

   387           // Only do the update if the old block actually exists.

   388           $block_exists = db_query("SELECT COUNT(*) FROM {" . $table . "} WHERE module = :module AND delta = :delta", array(

   389               ':module' => $old_module,

   390               ':delta' => $delta,

   391             ))

   392             ->fetchField();

   393           if ($block_exists) {

   394             // Delete any existing blocks with the new module+delta.

   395             db_delete($table)

   396               ->condition('module', $new_module)

   397               ->condition('delta', $delta)

   398               ->execute();

   399             // Rename the old block to the new module+delta.

   400             db_update($table)

   401               ->fields(array('module' => $new_module))

   402               ->condition('module', $old_module)

   403               ->condition('delta', $delta)

   404               ->execute();

   405           }

   406         }

   407       }

   408     }

   409 

   410     // Initialize batch update information.

   411     $sandbox['progress'] = 0;

   412     $sandbox['last_user_processed'] = -1;

   413     $sandbox['max'] = db_query("SELECT COUNT(*) FROM {users} WHERE data LIKE :block", array(

   414         ':block' => '%' . db_like(serialize('block')) . '%',

   415       ))

   416       ->fetchField();

   417   }

   418   // Now do the batch update of the user-specific block visibility settings.

   419   $limit = 100;

   420   $result = db_select('users', 'u')

   421     ->fields('u', array('uid', 'data'))

   422     ->condition('uid', $sandbox['last_user_processed'], '>')

   423     ->condition('data', '%' . db_like(serialize('block')) . '%', 'LIKE')

   424     ->orderBy('uid', 'ASC')

   425     ->range(0, $limit)

   426     ->execute();

   427   foreach ($result as $row) {

   428     $data = unserialize($row->data);

   429     $user_needs_update = FALSE;

   430     foreach ($renamed_deltas as $module => $deltas) {

   431       foreach ($deltas as $old_delta => $new_delta) {

   432         if (isset($data['block'][$module][$old_delta])) {

   433           // Transfer the old block visibility settings to the newly-renamed

   434           // block, and mark this user for a database update.

   435           $data['block'][$module][$new_delta] = $data['block'][$module][$old_delta];

   436           unset($data['block'][$module][$old_delta]);

   437           $user_needs_update = TRUE;

   438         }

   439       }

   440     }

   441     foreach ($moved_deltas as $old_module => $deltas) {

   442       foreach ($deltas as $delta => $new_module) {

   443         if (isset($data['block'][$old_module][$delta])) {

   444           // Transfer the old block visibility settings to the moved

   445           // block, and mark this user for a database update.

   446           $data['block'][$new_module][$delta] = $data['block'][$old_module][$delta];

   447           unset($data['block'][$old_module][$delta]);

   448           $user_needs_update = TRUE;

   449         }

   450       }

   451     }

   452     // Update the current user.

   453     if ($user_needs_update) {

   454       db_update('users')

   455         ->fields(array('data' => serialize($data)))

   456         ->condition('uid', $row->uid)

   457         ->execute();

   458     }

   459     // Update our progress information for the batch update.

   460     $sandbox['progress']++;

   461     $sandbox['last_user_processed'] = $row->uid;

   462   }

   463   // Indicate our current progress to the batch update system.

   464   if ($sandbox['progress'] < $sandbox['max']) {

   465     $sandbox['#finished'] = $sandbox['progress'] / $sandbox['max'];

   466   }

   467 }

   468 

   469 /**

   470  * Perform Drupal 6.x to 7.x updates that are required for update.php

   471  * to function properly.

   472  *

   473  * This function runs when update.php is run the first time for 7.x,

   474  * even before updates are selected or performed. It is important

   475  * that if updates are not ultimately performed that no changes are

   476  * made which make it impossible to continue using the prior version.

   477  */

   478 function update_fix_d7_requirements() {

   479   global $conf;

   480 

   481   // Rewrite the settings.php file if necessary, see

   482   // update_prepare_d7_bootstrap().

   483   global $update_rewrite_settings, $db_url, $db_prefix;

   484   if (!empty($update_rewrite_settings)) {

   485     $databases = update_parse_db_url($db_url, $db_prefix);

   486     $salt = drupal_hash_base64(drupal_random_bytes(55));

   487     file_put_contents(conf_path() . '/settings.php', "\n" . '$databases = ' . var_export($databases, TRUE) . ";\n\$drupal_hash_salt = '$salt';", FILE_APPEND);

   488   }

   489   if (drupal_get_installed_schema_version('system') < 7000 && !variable_get('update_d7_requirements', FALSE)) {

   490     // Change 6.x system table field values to 7.x equivalent.

   491     // Change field values.

   492     db_change_field('system', 'schema_version', 'schema_version', array(

   493      'type' => 'int',

   494      'size' => 'small',

   495      'not null' => TRUE,

   496      'default' => -1)

   497     );

   498     db_change_field('system', 'status', 'status', array(

   499       'type' => 'int', 'not null' => TRUE, 'default' => 0));

   500     db_change_field('system', 'weight', 'weight', array(

   501       'type' => 'int', 'not null' => TRUE, 'default' => 0));

   502     db_change_field('system', 'bootstrap', 'bootstrap', array(

   503       'type' => 'int', 'not null' => TRUE, 'default' => 0));

   504     // Drop and recreate 6.x indexes.

   505     db_drop_index('system', 'bootstrap');

   506     db_add_index('system', 'bootstrap', array(

   507       'status', 'bootstrap', array('type', 12), 'weight', 'name'));

   508 

   509     db_drop_index('system' ,'modules');

   510     db_add_index('system', 'modules', array(array(

   511       'type', 12), 'status', 'weight', 'name'));

   512 

   513     db_drop_index('system', 'type_name');

   514     db_add_index('system', 'type_name', array(array('type', 12), 'name'));

   515     // Add 7.x indexes.

   516     db_add_index('system', 'system_list', array('weight', 'name'));

   517 

   518     // Add the cache_path table.

   519     if (db_table_exists('cache_path')) {

   520       db_drop_table('cache_path');

   521     }

   522     require_once('./modules/system/system.install');

   523     $schema['cache_path'] = system_schema_cache_7054();

   524     $schema['cache_path']['description'] = 'Cache table used for path alias lookups.';

   525     db_create_table('cache_path', $schema['cache_path']);

   526 

   527     // system_update_7042() renames columns, but these are needed to bootstrap.

   528     // Add empty columns for now.

   529     db_add_field('url_alias', 'source', array('type' => 'varchar', 'length' => 255, 'not null' => TRUE, 'default' => ''));

   530     db_add_field('url_alias', 'alias', array('type' => 'varchar', 'length' => 255, 'not null' => TRUE, 'default' => ''));

   531 

   532     // Add new columns to {menu_router}.

   533     db_add_field('menu_router', 'delivery_callback', array('type' => 'varchar', 'length' => 255, 'not null' => TRUE, 'default' => ''));

   534     db_add_field('menu_router', 'context', array(

   535       'description' => 'Only for local tasks (tabs) - the context of a local task to control its placement.',

   536       'type' => 'int',

   537       'not null' => TRUE,

   538       'default' => 0,

   539     ));

   540     db_drop_index('menu_router', 'tab_parent');

   541     db_add_index('menu_router', 'tab_parent', array(array('tab_parent', 64), 'weight', 'title'));

   542     db_add_field('menu_router', 'theme_callback', array('type' => 'varchar', 'length' => 255, 'not null' => TRUE, 'default' => ''));

   543     db_add_field('menu_router', 'theme_arguments', array('type' => 'varchar', 'length' => 255, 'not null' => TRUE, 'default' => ''));

   544 

   545     // Add the role_permission table.

   546     $schema['role_permission'] = array(

   547       'fields' => array(

   548         'rid' => array(

   549         'type' => 'int',

   550         'unsigned' => TRUE,

   551         'not null' => TRUE,

   552       ),

   553       'permission' => array(

   554         'type' => 'varchar',

   555         'length' => 128,

   556         'not null' => TRUE,

   557         'default' => '',

   558       ),

   559     ),

   560     'primary key' => array('rid', 'permission'),

   561     'indexes' => array(

   562       'permission' => array('permission'),

   563       ),

   564     );

   565     db_create_table('role_permission', $schema['role_permission']);

   566 

   567     // Drops and recreates semaphore value index.

   568     db_drop_index('semaphore', 'value');

   569     db_add_index('semaphore', 'value', array('value'));

   570 

   571     $schema['date_format_type'] = array(

   572       'description' => 'Stores configured date format types.',

   573       'fields' => array(

   574         'type' => array(

   575           'description' => 'The date format type, e.g. medium.',

   576           'type' => 'varchar',

   577           'length' => 64,

   578           'not null' => TRUE,

   579         ),

   580         'title' => array(

   581           'description' => 'The human readable name of the format type.',

   582           'type' => 'varchar',

   583           'length' => 255,

   584           'not null' => TRUE,

   585         ),

   586         'locked' => array(

   587           'description' => 'Whether or not this is a system provided format.',

   588           'type' => 'int',

   589           'size' => 'tiny',

   590           'default' => 0,

   591           'not null' => TRUE,

   592         ),

   593       ),

   594       'primary key' => array('type'),

   595     );

   596 

   597     $schema['date_formats'] = array(

   598       'description' => 'Stores configured date formats.',

   599       'fields' => array(

   600         'dfid' => array(

   601           'description' => 'The date format identifier.',

   602           'type' => 'serial',

   603           'not null' => TRUE,

   604           'unsigned' => TRUE,

   605         ),

   606         'format' => array(

   607           'description' => 'The date format string.',

   608           'type' => 'varchar',

   609           'length' => 100,

   610           'not null' => TRUE,

   611         ),

   612         'type' => array(

   613           'description' => 'The date format type, e.g. medium.',

   614           'type' => 'varchar',

   615           'length' => 64,

   616           'not null' => TRUE,

   617         ),

   618         'locked' => array(

   619           'description' => 'Whether or not this format can be modified.',

   620           'type' => 'int',

   621           'size' => 'tiny',

   622           'default' => 0,

   623           'not null' => TRUE,

   624         ),

   625       ),

   626       'primary key' => array('dfid'),

   627       'unique keys' => array('formats' => array('format', 'type')),

   628     );

   629 

   630     $schema['date_format_locale'] = array(

   631       'description' => 'Stores configured date formats for each locale.',

   632       'fields' => array(

   633         'format' => array(

   634           'description' => 'The date format string.',

   635           'type' => 'varchar',

   636           'length' => 100,

   637           'not null' => TRUE,

   638         ),

   639         'type' => array(

   640           'description' => 'The date format type, e.g. medium.',

   641           'type' => 'varchar',

   642           'length' => 64,

   643           'not null' => TRUE,

   644         ),

   645         'language' => array(

   646           'description' => 'A {languages}.language for this format to be used with.',

   647           'type' => 'varchar',

   648           'length' => 12,

   649           'not null' => TRUE,

   650         ),

   651       ),

   652       'primary key' => array('type', 'language'),

   653     );

   654 

   655     db_create_table('date_format_type', $schema['date_format_type']);

   656     // Sites that have the Drupal 6 Date module installed already have the

   657     // following tables.

   658     if (db_table_exists('date_formats')) {

   659       db_rename_table('date_formats', 'd6_date_formats');

   660     }

   661     db_create_table('date_formats', $schema['date_formats']);

   662     if (db_table_exists('date_format_locale')) {

   663       db_rename_table('date_format_locale', 'd6_date_format_locale');

   664     }

   665     db_create_table('date_format_locale', $schema['date_format_locale']);

   666 

   667     // Add the queue table.

   668     $schema['queue'] = array(

   669       'description' => 'Stores items in queues.',

   670       'fields' => array(

   671         'item_id' => array(

   672           'type' => 'serial',

   673           'unsigned' => TRUE,

   674           'not null' => TRUE,

   675           'description' => 'Primary Key: Unique item ID.',

   676         ),

   677         'name' => array(

   678           'type' => 'varchar',

   679           'length' => 255,

   680           'not null' => TRUE,

   681           'default' => '',

   682           'description' => 'The queue name.',

   683         ),

   684         'data' => array(

   685           'type' => 'blob',

   686           'not null' => FALSE,

   687           'size' => 'big',

   688           'serialize' => TRUE,

   689           'description' => 'The arbitrary data for the item.',

   690         ),

   691         'expire' => array(

   692           'type' => 'int',

   693           'not null' => TRUE,

   694           'default' => 0,

   695           'description' => 'Timestamp when the claim lease expires on the item.',

   696         ),

   697         'created' => array(

   698           'type' => 'int',

   699           'not null' => TRUE,

   700           'default' => 0,

   701           'description' => 'Timestamp when the item was created.',

   702         ),

   703       ),

   704       'primary key' => array('item_id'),

   705       'indexes' => array(

   706         'name_created' => array('name', 'created'),

   707         'expire' => array('expire'),

   708       ),

   709     );

   710     // Check for queue table that may remain from D5 or D6, if found

   711     //drop it.

   712     if (db_table_exists('queue')) {

   713       db_drop_table('queue');

   714     }

   715 

   716     db_create_table('queue', $schema['queue']);

   717 

   718     // Create the sequences table.

   719     $schema['sequences'] = array(

   720       'description' => 'Stores IDs.',

   721       'fields' => array(

   722         'value' => array(

   723           'description' => 'The value of the sequence.',

   724           'type' => 'serial',

   725           'unsigned' => TRUE,

   726           'not null' => TRUE,

   727         ),

   728        ),

   729       'primary key' => array('value'),

   730     );

   731     // Check for sequences table that may remain from D5 or D6, if found

   732     //drop it.

   733     if (db_table_exists('sequences')) {

   734       db_drop_table('sequences');

   735     }

   736     db_create_table('sequences', $schema['sequences']);

   737     // Initialize the table with the maximum current increment of the tables

   738     // that will rely on it for their ids.

   739     $max_aid = db_query('SELECT MAX(aid) FROM {actions_aid}')->fetchField();

   740     $max_uid = db_query('SELECT MAX(uid) FROM {users}')->fetchField();

   741     $max_batch_id = db_query('SELECT MAX(bid) FROM {batch}')->fetchField();

   742     db_insert('sequences')->fields(array('value' => max($max_aid, $max_uid, $max_batch_id)))->execute();

   743 

   744     // Add column for locale context.

   745     if (db_table_exists('locales_source')) {

   746       db_add_field('locales_source', 'context', array('type' => 'varchar', 'length' => 255, 'not null' => TRUE, 'default' => '', 'description' => 'The context this string applies to.'));

   747     }

   748 

   749     // Rename 'site_offline_message' variable to 'maintenance_mode_message'

   750     // and 'site_offline' variable to 'maintenance_mode'.

   751     // Old variable is removed in update for system.module, see

   752     // system_update_7072().

   753     if ($message = variable_get('site_offline_message', NULL)) {

   754       variable_set('maintenance_mode_message', $message);

   755     }

   756     // Old variable is removed in update for system.module, see

   757     // system_update_7069().

   758     $site_offline = variable_get('site_offline', -1);

   759     if ($site_offline != -1) {

   760       variable_set('maintenance_mode', $site_offline);

   761     }

   762 

   763     // Add ssid column and index.

   764     db_add_field('sessions', 'ssid', array('description' => "Secure session ID. The value is generated by Drupal's session handlers.", 'type' => 'varchar', 'length' => 128, 'not null' => TRUE, 'default' => ''));

   765     db_add_index('sessions', 'ssid', array('ssid'));

   766     // Drop existing primary key.

   767     db_drop_primary_key('sessions');

   768     // Add new primary key.

   769     db_add_primary_key('sessions', array('sid', 'ssid'));

   770 

   771     // Allow longer javascript file names.

   772     if (db_table_exists('languages')) {

   773       db_change_field('languages', 'javascript', 'javascript', array('type' => 'varchar', 'length' => 64, 'not null' => TRUE, 'default' => ''));

   774     }

   775 

   776     // Rename action description to label.

   777     db_change_field('actions', 'description', 'label', array('type' => 'varchar', 'length' => 255, 'not null' => TRUE, 'default' => '0'));

   778 

   779     variable_set('update_d7_requirements', TRUE);

   780   }

   781 

   782   update_fix_d7_install_profile();

   783 }

   784 

   785 /**

   786  * Register the currently installed profile in the system table.

   787  *

   788  * Installation profiles are now treated as modules by Drupal, and have an

   789  * upgrade path based on their schema version in the system table.

   790  *

   791  * The installation profile will be set to schema_version 0, as it has already

   792  * been installed. Any other hook_update_N functions provided by the

   793  * installation profile will be run by update.php.

   794  */

   795 function update_fix_d7_install_profile() {

   796   $profile = drupal_get_profile();

   797 

   798   // 'Default' profile has been renamed to 'Standard' in D7.

   799   // We change the profile here to prevent a broken record in the system table.

   800   // See system_update_7049().

   801   if ($profile == 'default') {

   802     $profile = 'standard';

   803     variable_set('install_profile', $profile);

   804   }

   805 

   806   $results = db_select('system', 's')

   807     ->fields('s', array('name', 'schema_version'))

   808     ->condition('name', $profile)

   809     ->condition('type', 'module')

   810     ->execute()

   811     ->fetchAll();

   812 

   813   if (empty($results)) {

   814     $filename = 'profiles/' . $profile . '/' . $profile . '.profile';

   815 

   816     // Read profile info file

   817     $info = drupal_parse_info_file(dirname($filename) . '/' . $profile . '.info');

   818 

   819     // Merge in defaults.

   820     $info = $info + array(

   821       'dependencies' => array(),

   822       'description' => '',

   823       'package' => 'Other',

   824       'version' => NULL,

   825       'php' => DRUPAL_MINIMUM_PHP,

   826       'files' => array(),

   827     );

   828 

   829     $values = array(

   830       'filename' => $filename,

   831       'name' => $profile,

   832       'info' => serialize($info),

   833       'schema_version' => 0,

   834       'type' => 'module',

   835       'status' => 1,

   836       'owner' => '',

   837     );

   838 

   839     // Installation profile hooks are always executed last by the module system

   840     $values['weight'] = 1000;

   841 

   842     // Initializing the system table entry for the installation profile

   843     db_insert('system')

   844       ->fields(array_keys($values))

   845       ->values($values)

   846       ->execute();

   847 

   848     // Reset the cached schema version.

   849     drupal_get_installed_schema_version($profile, TRUE);

   850 

   851     // Load the updates again to make sure the installation profile updates

   852     // are loaded.

   853     drupal_load_updates();

   854   }

   855 }

   856 

   857 /**

   858  * Parse pre-Drupal 7 database connection URLs and return D7 compatible array.

   859  *

   860  * @return

   861  *   Drupal 7 DBTNG compatible array of database connection information.

   862  */

   863 function update_parse_db_url($db_url, $db_prefix) {

   864   $databases = array();

   865   if (!is_array($db_url)) {

   866     $db_url = array('default' => $db_url);

   867   }

   868   foreach ($db_url as $database => $url) {

   869     $url = parse_url($url);

   870     $databases[$database]['default'] = array(

   871       // MySQLi uses the mysql driver.

   872       'driver' => $url['scheme'] == 'mysqli' ? 'mysql' : $url['scheme'],

   873       // Remove the leading slash to get the database name.

   874       'database' => substr(urldecode($url['path']), 1),

   875       'username' => urldecode($url['user']),

   876       'password' => isset($url['pass']) ? urldecode($url['pass']) : '',

   877       'host' => urldecode($url['host']),

   878       'port' => isset($url['port']) ? urldecode($url['port']) : '',

   879     );

   880     if (isset($db_prefix)) {

   881       $databases[$database]['default']['prefix'] = $db_prefix;

   882     }

   883   }

   884   return $databases;

   885 }

   886 

   887 /**

   888  * Constructs a session name compatible with a D6 environment.

   889  *

   890  * @return

   891  *   D6-compatible session name string.

   892  *

   893  * @see drupal_settings_initialize()

   894  */

   895 function update_get_d6_session_name() {

   896   global $base_url, $cookie_domain;

   897   $cookie_secure = ini_get('session.cookie_secure');

   898 

   899   // If a custom cookie domain is set in settings.php, that variable forms

   900   // the basis of the session name. Re-compute the D7 hashing method to find

   901   // out if $cookie_domain was used as the session name.

   902   if (($cookie_secure ? 'SSESS' : 'SESS') . substr(hash('sha256', $cookie_domain), 0, 32) == session_name()) {

   903     $session_name = $cookie_domain;

   904   }

   905   else {

   906     // Otherwise use $base_url as session name, without the protocol

   907     // to use the same session identifiers across HTTP and HTTPS.

   908     list( , $session_name) = explode('://', $base_url, 2);

   909   }

   910 

   911   if ($cookie_secure) {

   912     $session_name .= 'SSL';

   913   }

   914 

   915   return 'SESS' . md5($session_name);

   916 }

   917 

   918 /**

   919  * Implements callback_batch_operation().

   920  *

   921  * Performs one update and stores the results for display on the results page.

   922  *

   923  * If an update function completes successfully, it should return a message

   924  * as a string indicating success, for example:

   925  * @code

   926  * return t('New index added successfully.');

   927  * @endcode

   928  *

   929  * Alternatively, it may return nothing. In that case, no message

   930  * will be displayed at all.

   931  *

   932  * If it fails for whatever reason, it should throw an instance of

   933  * DrupalUpdateException with an appropriate error message, for example:

   934  * @code

   935  * throw new DrupalUpdateException(t('Description of what went wrong'));

   936  * @endcode

   937  *

   938  * If an exception is thrown, the current update and all updates that depend on

   939  * it will be aborted. The schema version will not be updated in this case, and

   940  * all the aborted updates will continue to appear on update.php as updates

   941  * that have not yet been run.

   942  *

   943  * If an update function needs to be re-run as part of a batch process, it

   944  * should accept the $sandbox array by reference as its first parameter

   945  * and set the #finished property to the percentage completed that it is, as a

   946  * fraction of 1.

   947  *

   948  * @param $module

   949  *   The module whose update will be run.

   950  * @param $number

   951  *   The update number to run.

   952  * @param $dependency_map

   953  *   An array whose keys are the names of all update functions that will be

   954  *   performed during this batch process, and whose values are arrays of other

   955  *   update functions that each one depends on.

   956  * @param $context

   957  *   The batch context array.

   958  *

   959  * @see update_resolve_dependencies()

   960  */

   961 function update_do_one($module, $number, $dependency_map, &$context) {

   962   $function = $module . '_update_' . $number;

   963 

   964   // If this update was aborted in a previous step, or has a dependency that

   965   // was aborted in a previous step, go no further.

   966   if (!empty($context['results']['#abort']) && array_intersect($context['results']['#abort'], array_merge($dependency_map, array($function)))) {

   967     return;

   968   }

   969 

   970   $ret = array();

   971   if (function_exists($function)) {

   972     try {

   973       $ret['results']['query'] = $function($context['sandbox']);

   974       $ret['results']['success'] = TRUE;

   975     }

   976     // @TODO We may want to do different error handling for different

   977     // exception types, but for now we'll just log the exception and

   978     // return the message for printing.

   979     catch (Exception $e) {

   980       watchdog_exception('update', $e);

   981 

   982       require_once DRUPAL_ROOT . '/includes/errors.inc';

   983       $variables = _drupal_decode_exception($e);

   984       // The exception message is run through check_plain() by _drupal_decode_exception().

   985       $ret['#abort'] = array('success' => FALSE, 'query' => t('%type: !message in %function (line %line of %file).', $variables));

   986     }

   987   }

   988 

   989   if (isset($context['sandbox']['#finished'])) {

   990     $context['finished'] = $context['sandbox']['#finished'];

   991     unset($context['sandbox']['#finished']);

   992   }

   993 

   994   if (!isset($context['results'][$module])) {

   995     $context['results'][$module] = array();

   996   }

   997   if (!isset($context['results'][$module][$number])) {

   998     $context['results'][$module][$number] = array();

   999   }

  1000   $context['results'][$module][$number] = array_merge($context['results'][$module][$number], $ret);

  1001 

  1002   if (!empty($ret['#abort'])) {

  1003     // Record this function in the list of updates that were aborted.

  1004     $context['results']['#abort'][] = $function;

  1005   }

  1006 

  1007   // Record the schema update if it was completed successfully.

  1008   if ($context['finished'] == 1 && empty($ret['#abort'])) {

  1009     drupal_set_installed_schema_version($module, $number);

  1010   }

  1011 

  1012   $context['message'] = 'Updating ' . check_plain($module) . ' module';

  1013 }

  1014 

  1015 /**

  1016  * @class Exception class used to throw error if a module update fails.

  1017  */

  1018 class DrupalUpdateException extends Exception { }

  1019 

  1020 /**

  1021  * Starts the database update batch process.

  1022  *

  1023  * @param $start

  1024  *   An array whose keys contain the names of modules to be updated during the

  1025  *   current batch process, and whose values contain the number of the first

  1026  *   requested update for that module. The actual updates that are run (and the

  1027  *   order they are run in) will depend on the results of passing this data

  1028  *   through the update dependency system.

  1029  * @param $redirect

  1030  *   Path to redirect to when the batch has finished processing.

  1031  * @param $url

  1032  *   URL of the batch processing page (should only be used for separate

  1033  *   scripts like update.php).

  1034  * @param $batch

  1035  *   Optional parameters to pass into the batch API.

  1036  * @param $redirect_callback

  1037  *   (optional) Specify a function to be called to redirect to the progressive

  1038  *   processing page.

  1039  *

  1040  * @see update_resolve_dependencies()

  1041  */

  1042 function update_batch($start, $redirect = NULL, $url = NULL, $batch = array(), $redirect_callback = 'drupal_goto') {

  1043   // During the update, bring the site offline so that schema changes do not

  1044   // affect visiting users.

  1045   $_SESSION['maintenance_mode'] = variable_get('maintenance_mode', FALSE);

  1046   if ($_SESSION['maintenance_mode'] == FALSE) {

  1047     variable_set('maintenance_mode', TRUE);

  1048   }

  1049 

  1050   // Resolve any update dependencies to determine the actual updates that will

  1051   // be run and the order they will be run in.

  1052   $updates = update_resolve_dependencies($start);

  1053 

  1054   // Store the dependencies for each update function in an array which the

  1055   // batch API can pass in to the batch operation each time it is called. (We

  1056   // do not store the entire update dependency array here because it is

  1057   // potentially very large.)

  1058   $dependency_map = array();

  1059   foreach ($updates as $function => $update) {

  1060     $dependency_map[$function] = !empty($update['reverse_paths']) ? array_keys($update['reverse_paths']) : array();

  1061   }

  1062 

  1063   $operations = array();

  1064   foreach ($updates as $update) {

  1065     if ($update['allowed']) {

  1066       // Set the installed version of each module so updates will start at the

  1067       // correct place. (The updates are already sorted, so we can simply base

  1068       // this on the first one we come across in the above foreach loop.)

  1069       if (isset($start[$update['module']])) {

  1070         drupal_set_installed_schema_version($update['module'], $update['number'] - 1);

  1071         unset($start[$update['module']]);

  1072       }

  1073       // Add this update function to the batch.

  1074       $function = $update['module'] . '_update_' . $update['number'];

  1075       $operations[] = array('update_do_one', array($update['module'], $update['number'], $dependency_map[$function]));

  1076     }

  1077   }

  1078   $batch['operations'] = $operations;

  1079   $batch += array(

  1080     'title' => 'Updating',

  1081     'init_message' => 'Starting updates',

  1082     'error_message' => 'An unrecoverable error has occurred. You can find the error message below. It is advised to copy it to the clipboard for reference.',

  1083     'finished' => 'update_finished',

  1084     'file' => 'includes/update.inc',

  1085   );

  1086   batch_set($batch);

  1087   batch_process($redirect, $url, $redirect_callback);

  1088 }

  1089 

  1090 /**

  1091  * Implements callback_batch_finished().

  1092  *

  1093  * Finishes the update process and stores the results for eventual display.

  1094  *

  1095  * After the updates run, all caches are flushed. The update results are

  1096  * stored into the session (for example, to be displayed on the update results

  1097  * page in update.php). Additionally, if the site was off-line, now that the

  1098  * update process is completed, the site is set back online.

  1099  *

  1100  * @param $success

  1101  *   Indicate that the batch API tasks were all completed successfully.

  1102  * @param $results

  1103  *   An array of all the results that were updated in update_do_one().

  1104  * @param $operations

  1105  *   A list of all the operations that had not been completed by the batch API.

  1106  *

  1107  * @see update_batch()

  1108  */

  1109 function update_finished($success, $results, $operations) {

  1110   // Remove the D6 upgrade flag variable so that subsequent update runs do not

  1111   // get the wrong context.

  1112   variable_del('update_d6');

  1113 

  1114   // Clear the caches in case the data has been updated.

  1115   drupal_flush_all_caches();

  1116 

  1117   $_SESSION['update_results'] = $results;

  1118   $_SESSION['update_success'] = $success;

  1119   $_SESSION['updates_remaining'] = $operations;

  1120 

  1121   // Now that the update is done, we can put the site back online if it was

  1122   // previously in maintenance mode.

  1123   if (isset($_SESSION['maintenance_mode']) && $_SESSION['maintenance_mode'] == FALSE) {

  1124     variable_set('maintenance_mode', FALSE);

  1125     unset($_SESSION['maintenance_mode']);

  1126   }

  1127 }

  1128 

  1129 /**

  1130  * Returns a list of all the pending database updates.

  1131  *

  1132  * @return

  1133  *   An associative array keyed by module name which contains all information

  1134  *   about database updates that need to be run, and any updates that are not

  1135  *   going to proceed due to missing requirements. The system module will

  1136  *   always be listed first.