[Sommaire] [Imprimer]

   1  <?php
   2  // $Id: update.php,v 1.211.2.2 2007/04/08 00:54:04 drumm Exp $
   3  
   4  /**
   5   * @file
   6   * Administrative page for handling updates from one Drupal version to another.
   7   *
   8   * Point your browser to "http://www.example.com/update.php" and follow the
   9   * instructions.
  10   *
  11   * If you are not logged in as administrator, you will need to modify the access
  12   * check statement below. Change the TRUE to a FALSE to disable the access
  13   * check. After finishing the upgrade, be sure to open this file and change the
  14   * FALSE back to a TRUE!
  15   */
  16  
  17  // Enforce access checking?
  18  $access_check = TRUE;
  19  
  20  
  21  function update_sql($sql) {
  22    $result = db_query($sql);
  23    return array('success' => $result !== FALSE, 'query' => check_plain($sql));
  24  }
  25  
  26  /**
  27   * Add a column to a database using syntax appropriate for PostgreSQL.
  28   * Save result of SQL commands in $ret array.
  29   *
  30   * Note: when you add a column with NOT NULL and you are not sure if there are
  31   * already rows in the table, you MUST also add DEFAULT. Otherwise PostgreSQL
  32   * won't work when the table is not empty, and db_add_column() will fail.
  33   * To have an empty string as the default, you must use: 'default' => "''"
  34   * in the $attributes array. If NOT NULL and DEFAULT are set the PostgreSQL
  35   * version will set values of the added column in old rows to the
  36   * DEFAULT value.
  37   *
  38   * @param $ret
  39   *   Array to which results will be added.
  40   * @param $table
  41   *   Name of the table, without {}
  42   * @param $column
  43   *   Name of the column
  44   * @param $type
  45   *   Type of column
  46   * @param $attributes
  47   *   Additional optional attributes. Recognized attributes:
  48   *     not null => TRUE|FALSE
  49   *     default  => NULL|FALSE|value (the value must be enclosed in '' marks)
  50   * @return
  51   *   nothing, but modifies $ret parameter.
  52   */
  53  function db_add_column(&$ret, $table, $column, $type, $attributes = array()) {
  54    if (array_key_exists('not null', $attributes) and $attributes['not null']) {
  55      $not_null = 'NOT NULL';
  56    }
  57    if (array_key_exists('default', $attributes)) {
  58      if (is_null($attributes['default'])) {
  59        $default_val = 'NULL';
  60        $default = 'default NULL';
  61      }
  62      elseif ($attributes['default'] === FALSE) {
  63        $default = '';
  64      }
  65      else {
  66        $default_val = "$attributes[default]";
  67        $default = "default $attributes[default]";
  68      }
  69    }
  70  
  71    $ret[] = update_sql("ALTER TABLE {". $table ."} ADD $column $type");
  72    if ($default) { $ret[] = update_sql("ALTER TABLE {". $table ."} ALTER $column SET $default"); }
  73    if ($not_null) {
  74      if ($default) { $ret[] = update_sql("UPDATE {". $table ."} SET $column = $default_val"); }
  75      $ret[] = update_sql("ALTER TABLE {". $table ."} ALTER $column SET NOT NULL");
  76    }
  77  }
  78  
  79  /**
  80   * Change a column definition using syntax appropriate for PostgreSQL.
  81   * Save result of SQL commands in $ret array.
  82   *
  83   * Remember that changing a column definition involves adding a new column
  84   * and dropping an old one. This means that any indices, primary keys and
  85   * sequences from serial-type columns are dropped and might need to be
  86   * recreated.
  87   *
  88   * @param $ret
  89   *   Array to which results will be added.
  90   * @param $table
  91   *   Name of the table, without {}
  92   * @param $column
  93   *   Name of the column to change
  94   * @param $column_new
  95   *   New name for the column (set to the same as $column if you don't want to change the name)
  96   * @param $type
  97   *   Type of column
  98   * @param $attributes
  99   *   Additional optional attributes. Recognized attributes:
 100   *     not null => TRUE|FALSE
 101   *     default  => NULL|FALSE|value (with or without '', it won't be added)
 102   * @return
 103   *   nothing, but modifies $ret parameter.
 104   */
 105  function db_change_column(&$ret, $table, $column, $column_new, $type, $attributes = array()) {
 106    if (array_key_exists('not null', $attributes) and $attributes['not null']) {
 107      $not_null = 'NOT NULL';
 108    }
 109    if (array_key_exists('default', $attributes)) {
 110      if (is_null($attributes['default'])) {
 111        $default_val = 'NULL';
 112        $default = 'default NULL';
 113      }
 114      elseif ($attributes['default'] === FALSE) {
 115        $default = '';
 116      }
 117      else {
 118        $default_val = "$attributes[default]";
 119        $default = "default $attributes[default]";
 120      }
 121    }
 122  
 123    $ret[] = update_sql("ALTER TABLE {". $table ."} RENAME $column TO ". $column ."_old");
 124    $ret[] = update_sql("ALTER TABLE {". $table ."} ADD $column_new $type");
 125    $ret[] = update_sql("UPDATE {". $table ."} SET $column_new = ". $column ."_old");
 126    if ($default) { $ret[] = update_sql("ALTER TABLE {". $table ."} ALTER $column_new SET $default"); }
 127    if ($not_null) { $ret[] = update_sql("ALTER TABLE {". $table ."} ALTER $column_new SET NOT NULL"); }
 128    $ret[] = update_sql("ALTER TABLE {". $table ."} DROP ". $column ."_old");
 129  }
 130  
 131  /**
 132   * If the schema version for Drupal core is stored in the variables table
 133   * (4.6.x and earlier) move it to the schema_version column of the system
 134   * table.
 135   *
 136   * This function may be removed when update 156 is removed, which is the last
 137   * update in the 4.6 to 4.7 migration.
 138   */
 139  function update_fix_schema_version() {
 140    if ($update_start = variable_get('update_start', FALSE)) {
 141      // Some updates were made to the 4.6 branch and 4.7 branch. This sets
 142      // temporary variables to prevent the updates from being executed twice and
 143      // throwing errors.
 144      switch ($update_start) {
 145        case '2005-04-14':
 146          variable_set('update_132_done', TRUE);
 147          break;
 148  
 149        case '2005-05-06':
 150          variable_set('update_132_done', TRUE);
 151          variable_set('update_135_done', TRUE);
 152          break;
 153  
 154        case '2005-05-07':
 155          variable_set('update_132_done', TRUE);
 156          variable_set('update_135_done', TRUE);
 157          variable_set('update_137_done', TRUE);
 158          break;
 159  
 160      }
 161      // The schema_version column (added below) was changed during 4.7beta.
 162      // Update_170 is only for those beta users.
 163      variable_set('update_170_done', TRUE);
 164  
 165      $sql_updates = array(
 166        '2004-10-31: first update since Drupal 4.5.0 release' => 110,
 167        '2004-11-07' => 111, '2004-11-15' => 112, '2004-11-28' => 113,
 168        '2004-12-05' => 114, '2005-01-07' => 115, '2005-01-14' => 116,
 169        '2005-01-18' => 117, '2005-01-19' => 118, '2005-01-20' => 119,
 170        '2005-01-25' => 120, '2005-01-26' => 121, '2005-01-27' => 122,
 171        '2005-01-28' => 123, '2005-02-11' => 124, '2005-02-23' => 125,
 172        '2005-03-03' => 126, '2005-03-18' => 127, '2005-03-21' => 128,
 173        // The following three updates were made on the 4.6 branch
 174        '2005-04-14' => 128, '2005-05-06' => 128, '2005-05-07' => 128,
 175        '2005-04-08: first update since Drupal 4.6.0 release' => 129,
 176        '2005-04-10' => 130, '2005-04-11' => 131, '2005-04-14' => 132,
 177        '2005-04-24' => 133, '2005-04-30' => 134, '2005-05-06' => 135,
 178        '2005-05-08' => 136, '2005-05-09' => 137, '2005-05-10' => 138,
 179        '2005-05-11' => 139, '2005-05-12' => 140, '2005-05-22' => 141,
 180        '2005-07-29' => 142, '2005-07-30' => 143, '2005-08-08' => 144,
 181        '2005-08-15' => 145, '2005-08-25' => 146, '2005-09-07' => 147,
 182        '2005-09-18' => 148, '2005-09-27' => 149, '2005-10-15' => 150,
 183        '2005-10-23' => 151, '2005-10-28' => 152, '2005-11-03' => 153,
 184        '2005-11-14' => 154, '2005-11-27' => 155, '2005-12-03' => 156,
 185      );
 186  
 187      // Add schema version column
 188      switch ($GLOBALS['db_type']) {
 189        case 'pgsql':
 190          $ret = array();
 191          db_add_column($ret, 'system', 'schema_version', 'smallint', array('not null' => TRUE, 'default' => -1));
 192          break;
 193  
 194        case 'mysql':
 195        case 'mysqli':
 196          db_query('ALTER TABLE {system} ADD schema_version smallint(3) not null default -1');
 197          break;
 198      }
 199      // Set all enabled (contrib) modules to schema version 0 (installed)
 200      db_query('UPDATE {system} SET schema_version = 0 WHERE status = 1');
 201  
 202      // Set schema version for core
 203      drupal_set_installed_schema_version('system', $sql_updates[$update_start]);
 204      variable_del('update_start');
 205    }
 206  }
 207  
 208  /**
 209   * System update 130 changes the sessions table, which breaks the update
 210   * script's ability to use session variables. This changes the table
 211   * appropriately.
 212   *
 213   * This code, including the 'update_sessions_fixed' variable, may be removed
 214   * when update 130 is removed. It is part of the Drupal 4.6 to 4.7 migration.
 215   */
 216  function update_fix_sessions() {
 217    $ret = array();
 218  
 219    if (drupal_get_installed_schema_version('system') < 130 && !variable_get('update_sessions_fixed', FALSE)) {
 220      if ($GLOBALS['db_type'] == 'mysql') {
 221        db_query("ALTER TABLE {sessions} ADD cache int(11) NOT NULL default '0' AFTER timestamp");
 222      }
 223      elseif ($GLOBALS['db_type'] == 'pgsql') {
 224        db_add_column($ret, 'sessions', 'cache', 'int', array('default' => 0, 'not null' => TRUE));
 225      }
 226  
 227      variable_set('update_sessions_fixed', TRUE);
 228    }
 229  }
 230  
 231  /**
 232   * System update 115 changes the watchdog table, which breaks the update
 233   * script's ability to use logging. This changes the table appropriately.
 234   *
 235   * This code, including the 'update_watchdog_115_fixed' variable, may be removed
 236   * when update 115 is removed. It is part of the Drupal 4.5 to 4.7 migration.
 237   */
 238  function update_fix_watchdog_115() {
 239    if (drupal_get_installed_schema_version('system') < 115 && !variable_get('update_watchdog_115_fixed', FALSE)) {
 240      if ($GLOBALS['db_type'] == 'mysql') {
 241        $ret[] = update_sql("ALTER TABLE {watchdog} ADD severity tinyint(3) unsigned NOT NULL default '0'");
 242      }
 243      else if ($GLOBALS['db_type'] == 'pgsql') {
 244        $ret[] = update_sql('ALTER TABLE {watchdog} ADD severity smallint');
 245        $ret[] = update_sql('UPDATE {watchdog} SET severity = 0');
 246        $ret[] = update_sql('ALTER TABLE {watchdog} ALTER COLUMN severity SET NOT NULL');
 247        $ret[] = update_sql('ALTER TABLE {watchdog} ALTER COLUMN severity SET DEFAULT 0');
 248      }
 249  
 250      variable_set('update_watchdog_115_fixed', TRUE);
 251    }
 252  }
 253  
 254  /**
 255   * System update 142 changes the watchdog table, which breaks the update
 256   * script's ability to use logging. This changes the table appropriately.
 257   *
 258   * This code, including the 'update_watchdog_fixed' variable, may be removed
 259   * when update 142 is removed. It is part of the Drupal 4.6 to 4.7 migration.
 260   */
 261  function update_fix_watchdog() {
 262    if (drupal_get_installed_schema_version('system') < 142 && !variable_get('update_watchdog_fixed', FALSE)) {
 263      switch ($GLOBALS['db_type']) {
 264        case 'pgsql':
 265          $ret = array();
 266          db_add_column($ret, 'watchdog', 'referer', 'varchar(128)', array('not null' => TRUE, 'default' => "''"));
 267          break;
 268        case 'mysql':
 269        case 'mysqli':
 270          db_query("ALTER TABLE {watchdog} ADD COLUMN referer varchar(128) NOT NULL");
 271          break;
 272      }
 273  
 274      variable_set('update_watchdog_fixed', TRUE);
 275    }
 276  }
 277  
 278  /**
 279   * Perform one update and store the results which will later be displayed on
 280   * the finished page.
 281   *
 282   * @param $module
 283   *   The module whose update will be run.
 284   * @param $number
 285   *   The update number to run.
 286   *
 287   * @return
 288   *   TRUE if the update was finished. Otherwise, FALSE.
 289   */
 290  function update_data($module, $number) {
 291    $ret = module_invoke($module, 'update_'. $number);
 292    // Assume the update finished unless the update results indicate otherwise.
 293    $finished = 1;
 294    if (isset($ret['#finished'])) {
 295      $finished = $ret['#finished'];
 296      unset($ret['#finished']);
 297    }
 298  
 299    // Save the query and results for display by update_finished_page().
 300    if (!isset($_SESSION['update_results'])) {
 301      $_SESSION['update_results'] = array();
 302    }
 303    if (!isset($_SESSION['update_results'][$module])) {
 304      $_SESSION['update_results'][$module] = array();
 305    }
 306    if (!isset($_SESSION['update_results'][$module][$number])) {
 307      $_SESSION['update_results'][$module][$number] = array();
 308    }
 309    $_SESSION['update_results'][$module][$number] = array_merge($_SESSION['update_results'][$module][$number], $ret);
 310  
 311    if ($finished == 1) {
 312      // Update the installed version
 313      drupal_set_installed_schema_version($module, $number);
 314    }
 315  
 316    return $finished;
 317  }
 318  
 319  function update_selection_page() {
 320    $output = '<p>The version of Drupal you are updating from has been automatically detected. You can select a different version, but you should not need to.</p>';
 321    $output .= '<p>Click Update to start the update process.</p>';
 322  
 323    drupal_set_title('Drupal database update');
 324    // Prevent browser from using cached drupal.js or update.js
 325    drupal_add_js('misc/update.js', 'core', 'header', FALSE, TRUE);
 326    $output .= drupal_get_form('update_script_selection_form');
 327  
 328    return $output;
 329  }
 330  
 331  function update_script_selection_form() {
 332    $form = array();
 333    $form['start'] = array(
 334      '#tree' => TRUE,
 335      '#type' => 'fieldset',
 336      '#title' => 'Select versions',
 337      '#collapsible' => TRUE,
 338      '#collapsed' => TRUE,
 339    );
 340  
 341    // Ensure system.module's updates appear first
 342    $form['start']['system'] = array();
 343  
 344    foreach (module_list() as $module) {
 345      $updates = drupal_get_schema_versions($module);
 346      if ($updates !== FALSE) {
 347        $updates = drupal_map_assoc($updates);
 348        $updates[] = 'No updates available';
 349        $default = drupal_get_installed_schema_version($module);
 350        foreach (array_keys($updates) as $update) {
 351          if ($update > $default) {
 352            $default = $update;
 353            break;
 354          }
 355        }
 356  
 357        $form['start'][$module] = array(
 358          '#type' => 'select',
 359          '#title' => $module . ' module',
 360          '#default_value' => $default,
 361          '#options' => $updates,
 362        );
 363      }
 364    }
 365  
 366    $form['has_js'] = array(
 367      '#type' => 'hidden',
 368      '#default_value' => FALSE,
 369      '#attributes' => array('id' => 'edit-has_js'),
 370    );
 371    $form['submit'] = array(
 372      '#type' => 'submit',
 373      '#value' => 'Update',
 374    );
 375    return $form;
 376  }
 377  
 378  function update_update_page() {
 379    // Set the installed version so updates start at the correct place.
 380    foreach ($_POST['start'] as $module => $version) {
 381      drupal_set_installed_schema_version($module, $version - 1);
 382      $updates = drupal_get_schema_versions($module);
 383      $max_version = max($updates);
 384      if ($version <= $max_version) {
 385        foreach ($updates as $update) {
 386          if ($update >= $version) {
 387            $_SESSION['update_remaining'][] = array('module' => $module, 'version' => $update);
 388          }
 389        }
 390      }
 391    }
 392  
 393    // Keep track of total number of updates
 394    if (isset($_SESSION['update_remaining'])) {
 395      $_SESSION['update_total'] = count($_SESSION['update_remaining']);
 396    }
 397  
 398    if ($_POST['has_js']) {
 399      return update_progress_page();
 400    }
 401    else {
 402      return update_progress_page_nojs();
 403    }
 404  }
 405  
 406  function update_progress_page() {
 407    // Prevent browser from using cached drupal.js or update.js
 408    drupal_add_js('misc/progress.js', 'core', 'header', FALSE, TRUE);
 409    drupal_add_js('misc/update.js', 'core', 'header', FALSE, TRUE);
 410  
 411    drupal_set_title('Updating');
 412    $output = '<div id="progress"></div>';
 413    $output .= '<p id="wait">Please wait while your site is being updated.</p>';
 414    return $output;
 415  }
 416  
 417  /**
 418   * Perform updates for one second or until finished.
 419   *
 420   * @return
 421   *   An array indicating the status after doing updates. The first element is
 422   *   the overall percentage finished. The second element is a status message.
 423   */
 424  function update_do_updates() {
 425    while (isset($_SESSION['update_remaining']) && ($update = reset($_SESSION['update_remaining']))) {
 426      $update_finished = update_data($update['module'], $update['version']);
 427      if ($update_finished == 1) {
 428        // Dequeue the completed update.
 429        unset($_SESSION['update_remaining'][key($_SESSION['update_remaining'])]);
 430        $update_finished = 0; // Make sure this step isn't counted double
 431      }
 432      if (timer_read('page') > 1000) {
 433        break;
 434      }
 435    }
 436  
 437    if ($_SESSION['update_total']) {
 438      $percentage = floor(($_SESSION['update_total'] - count($_SESSION['update_remaining']) + $update_finished) / $_SESSION['update_total'] * 100);
 439    }
 440    else {
 441      $percentage = 100;
 442    }
 443  
 444    // When no updates remain, clear the caches in case the data has been updated.
 445    if (!isset($update['module'])) {
 446      cache_clear_all('*', 'cache', TRUE);
 447      cache_clear_all('*', 'cache_page', TRUE);
 448      cache_clear_all('*', 'cache_menu', TRUE);
 449      cache_clear_all('*', 'cache_filter', TRUE);
 450      drupal_clear_css_cache();
 451    }
 452  
 453    return array($percentage, isset($update['module']) ? 'Updating '. $update['module'] .' module' : 'Updating complete');
 454  }
 455  
 456  /**
 457   * Perform updates for the JS version and return progress.
 458   */
 459  function update_do_update_page() {
 460    global $conf;
 461  
 462    // HTTP Post required
 463    if ($_SERVER['REQUEST_METHOD'] != 'POST') {
 464      drupal_set_message('HTTP Post is required.', 'error');
 465      drupal_set_title('Error');
 466      return '';
 467    }
 468  
 469    // Error handling: if PHP dies, the output will fail to parse as JSON, and
 470    // the Javascript will tell the user to continue to the op=error page.
 471    list($percentage, $message) = update_do_updates();
 472    print drupal_to_js(array('status' => TRUE, 'percentage' => $percentage, 'message' => $message));
 473  }
 474  
 475  /**
 476   * Perform updates for the non-JS version and return the status page.
 477   */
 478  function update_progress_page_nojs() {
 479    drupal_set_title('Updating');
 480  
 481    $new_op = 'do_update_nojs';
 482    if ($_SERVER['REQUEST_METHOD'] == 'GET') {
 483      // Error handling: if PHP dies, it will output whatever is in the output
 484      // buffer, followed by the error message.
 485      ob_start();
 486      $fallback = '<p class="error">An unrecoverable error has occurred. You can find the error message below. It is advised to copy it to the clipboard for reference. Please continue to the <a href="update.php?op=error">update summary</a>.</p>';
 487      print theme('maintenance_page', $fallback, FALSE, TRUE);
 488  
 489      list($percentage, $message) = update_do_updates();
 490      if ($percentage == 100) {
 491        $new_op = 'finished';
 492      }
 493  
 494      // Updates successful; remove fallback
 495      ob_end_clean();
 496    }
 497    else {
 498      // This is the first page so return some output immediately.
 499      $percentage = 0;
 500      $message = 'Starting updates';
 501    }
 502  
 503    drupal_set_html_head('<meta http-equiv="Refresh" content="0; URL=update.php?op='. $new_op .'">');
 504    $output = theme('progress_bar', $percentage, $message);
 505    $output .= '<p>Updating your site will take a few seconds.</p>';
 506  
 507    // Note: do not output drupal_set_message()s until the summary page.
 508    print theme('maintenance_page', $output, FALSE);
 509    return NULL;
 510  }
 511  
 512  function update_finished_page($success) {
 513    drupal_set_title('Drupal database update');
 514    // NOTE: we can't use l() here because the URL would point to 'update.php?q=admin'.
 515    $links[] = '<a href="'. base_path() .'">Main page</a>';
 516    $links[] = '<a href="'. base_path() .'?q=admin">Administration pages</a>';
 517  
 518    // Report end result
 519    if ($success) {
 520      $output = '<p>Updates were attempted. If you see no failures below, you may proceed happily to the <a href="index.php?q=admin">administration pages</a>. Otherwise, you may need to update your database manually. All errors have been <a href="index.php?q=admin/logs/watchdog">logged</a>.</p>';
 521    }
 522    else {
 523      $update = reset($_SESSION['update_remaining']);
 524      $output = '<p class="error">The update process was aborted prematurely while running <strong>update #'. $update['version'] .' in '. $update['module'] .'.module</strong>. All other errors have been <a href="index.php?q=admin/logs/watchdog">logged</a>. You may need to check the <code>watchdog</code> database table manually.</p>';
 525    }
 526  
 527    if ($GLOBALS['access_check'] == FALSE) {
 528      $output .= "<p><strong>Reminder: don't forget to set the <code>\$access_check</code> value at the top of <code>update.php</code> back to <code>TRUE</code>.</strong></p>";
 529    }
 530  
 531    $output .= theme('item_list', $links);
 532  
 533    // Output a list of queries executed
 534    if (!empty($_SESSION['update_results'])) {
 535      $output .= '<div id="update-results">';
 536      $output .= '<h2>The following queries were executed</h2>';
 537      foreach ($_SESSION['update_results'] as $module => $updates) {
 538        $output .= '<h3>'. $module .' module</h3>';
 539        foreach ($updates as $number => $queries) {
 540          $output .= '<h4>Update #'. $number .'</h4>';
 541          $output .= '<ul>';
 542          foreach ($queries as $query) {
 543            if ($query['success']) {
 544              $output .= '<li class="success">'. $query['query'] .'</li>';
 545            }
 546            else {
 547              $output .= '<li class="failure"><strong>Failed:</strong> '. $query['query'] .'</li>';
 548            }
 549          }
 550          if (!count($queries)) {
 551            $output .= '<li class="none">No queries</li>';
 552          }
 553          $output .= '</ul>';
 554        }
 555      }
 556      $output .= '</div>';
 557      unset($_SESSION['update_results']);
 558    }
 559  
 560    return $output;
 561  }
 562  
 563  function update_info_page() {
 564    drupal_set_title('Drupal database update');
 565    $output = "<ol>\n";
 566    $output .= "<li>Use this script to <strong>upgrade an existing Drupal installation</strong>. You don't need this script when installing Drupal from scratch.</li>";
 567    $output .= "<li>Before doing anything, backup your database. This process will change your database and its values, and some things might get lost.</li>\n";
 568    $output .= "<li>Update your Drupal sources, check the notes below and <a href=\"update.php?op=selection\">run the database upgrade script</a>. Don't upgrade your database twice as it may cause problems.</li>\n";
 569    $output .= "<li>Go through the various administration pages to change the existing and new settings to your liking.</li>\n";
 570    $output .= "</ol>";
 571    $output .= '<p>For more help, see the <a href="http://drupal.org/node/258">Installation and upgrading handbook</a>. If you are unsure what these terms mean you should probably contact your hosting provider.</p>';
 572    return $output;
 573  }
 574  
 575  function update_access_denied_page() {
 576    drupal_set_title('Access denied');
 577    return '<p>Access denied. You are not authorized to access this page. Please log in as the admin user (the first user you created). If you cannot log in, you will have to edit <code>update.php</code> to bypass this access check. To do this:</p>
 578  <ol>
 579   <li>With a text editor find the update.php file on your system. It should be in the main Drupal directory that you installed all the files into.</li>
 580   <li>There is a line near top of update.php that says <code>$access_check = TRUE;</code>. Change it to <code>$access_check = FALSE;</code>.</li>
 581   <li>As soon as the script is done, you must change the update.php script back to its original form to <code>$access_check = TRUE;</code>.</li>
 582   <li>To avoid having this problem in future, remember to log in to your website as the admin user (the user you first created) before you backup your database at the beginning of the update process.</li>
 583  </ol>';
 584  }
 585  
 586  // This code may be removed later. It is part of the Drupal 4.5 to 4.8 migration.
 587  function update_fix_system_table() {
 588    drupal_bootstrap(DRUPAL_BOOTSTRAP_DATABASE);
 589    $core_modules = array('aggregator', 'archive', 'block', 'blog', 'blogapi', 'book', 'comment', 'contact', 'drupal', 'filter', 'forum', 'help', 'legacy', 'locale', 'menu', 'node', 'page', 'path', 'ping', 'poll', 'profile', 'search', 'statistics', 'story', 'system', 'taxonomy', 'throttle', 'tracker', 'upload', 'user', 'watchdog');
 590    foreach ($core_modules as $module) {
 591      $old_path = "modules/$module.module";
 592      $new_path = "modules/$module/$module.module";
 593      db_query("UPDATE {system} SET filename = '%s' WHERE filename = '%s'", $new_path, $old_path);
 594    }
 595    $row = db_fetch_object(db_query_range('SELECT * FROM {system}', 0, 1));
 596    if (!isset($row->weight)) {
 597      $ret = array();
 598      switch ($GLOBALS['db_type']) {
 599        case 'pgsql':
 600          db_add_column($ret, 'system', 'weight', 'smallint', array('not null' => TRUE, 'default' => 0));
 601          $ret[] = update_sql('CREATE INDEX {system}_weight_idx ON {system} (weight)');
 602          break;
 603        case 'mysql':
 604        case 'mysqli':
 605          $ret[] = update_sql("ALTER TABLE {system} ADD weight tinyint(2) default '0' NOT NULL, ADD KEY (weight)");
 606          break;
 607      }
 608    }
 609  }
 610  
 611  // This code may be removed later. It is part of the Drupal 4.6 to 4.7 migration.
 612  function update_fix_access_table() {
 613    if (variable_get('update_access_fixed', FALSE)) {
 614      return;
 615    }
 616  
 617    switch ($GLOBALS['db_type']) {
 618      // Only for MySQL 4.1+
 619      case 'mysqli':
 620        break;
 621      case 'mysql':
 622        if (version_compare(mysql_get_server_info($GLOBALS['active_db']), '4.1.0', '<')) {
 623          return;
 624        }
 625        break;
 626      case 'pgsql':
 627        return;
 628    }
 629  
 630    // Convert access table to UTF-8 if needed.
 631    $result = db_fetch_array(db_query('SHOW CREATE TABLE {access}'));
 632    if (!preg_match('/utf8/i', array_pop($result))) {
 633      update_convert_table_utf8('access');
 634    }
 635  
 636    // Don't run again
 637    variable_set('update_access_fixed', TRUE);
 638  }
 639  
 640  /**
 641   * Convert a single MySQL table to UTF-8.
 642   *
 643   * We change all text columns to their corresponding binary type,
 644   * then back to text, but with a UTF-8 character set.
 645   * See: http://dev.mysql.com/doc/refman/4.1/en/charset-conversion.html
 646   */
 647  function update_convert_table_utf8($table) {
 648    $ret = array();
 649    $types = array('char' => 'binary',
 650                   'varchar' => 'varbinary',
 651                   'tinytext' => 'tinyblob',
 652                   'text' => 'blob',
 653                   'mediumtext' => 'mediumblob',
 654                   'longtext' => 'longblob');
 655  
 656    // Get next table in list
 657    $convert_to_binary = array();
 658    $convert_to_utf8 = array();
 659  
 660    // Set table default charset
 661    $ret[] = update_sql('ALTER TABLE {'. $table .'} DEFAULT CHARACTER SET utf8');
 662  
 663    // Find out which columns need converting and build SQL statements
 664    $result = db_query('SHOW FULL COLUMNS FROM {'. $table .'}');
 665    while ($column = db_fetch_array($result)) {
 666      list($type) = explode('(', $column['Type']);
 667      if (isset($types[$type])) {
 668        $names = 'CHANGE `'. $column['Field'] .'` `'. $column['Field'] .'` ';
 669        $attributes = ' DEFAULT '. ($column['Default'] == 'NULL' ? 'NULL ' :
 670                       "'". db_escape_string($column['Default']) ."' ") .
 671                      ($column['Null'] == 'YES' ? 'NULL' : 'NOT NULL');
 672  
 673        $convert_to_binary[] = $names . preg_replace('/'. $type .'/i', $types[$type], $column['Type']) . $attributes;
 674        $convert_to_utf8[] = $names . $column['Type'] .' CHARACTER SET utf8'. $attributes;
 675      }
 676    }
 677  
 678    if (count($convert_to_binary)) {
 679      // Convert text columns to binary
 680      $ret[] = update_sql('ALTER TABLE {'. $table .'} '. implode(', ', $convert_to_binary));
 681      // Convert binary columns to UTF-8
 682      $ret[] = update_sql('ALTER TABLE {'. $table .'} '. implode(', ', $convert_to_utf8));
 683    }
 684    return $ret;
 685  }
 686  
 687  /**
 688   * Create tables for the split cache.
 689   *
 690   * This is part of the Drupal 4.7.x to 5.x migration.
 691   */
 692  function update_create_cache_tables() {
 693  
 694    // If cache_filter exists, update is not necessary
 695    if (db_table_exists('cache_filter')) {
 696      return;
 697    }
 698  
 699    $ret = array();
 700    switch ($GLOBALS['db_type']) {
 701      case 'mysql':
 702      case 'mysqli':
 703        $ret[] = update_sql("CREATE TABLE {cache_filter} (
 704          cid varchar(255) NOT NULL default '',
 705          data longblob,
 706          expire int NOT NULL default '0',
 707          created int NOT NULL default '0',
 708          headers text,
 709          PRIMARY KEY (cid),
 710          INDEX expire (expire)
 711        ) /*!40100 DEFAULT CHARACTER SET UTF8 */ ");
 712        $ret[] = update_sql("CREATE TABLE {cache_menu} (
 713          cid varchar(255) NOT NULL default '',
 714          data longblob,
 715          expire int NOT NULL default '0',
 716          created int NOT NULL default '0',
 717          headers text,
 718          PRIMARY KEY (cid),
 719          INDEX expire (expire)
 720        ) /*!40100 DEFAULT CHARACTER SET UTF8 */ ");
 721        $ret[] = update_sql("CREATE TABLE {cache_page} (
 722          cid varchar(255) BINARY NOT NULL default '',
 723          data longblob,
 724          expire int NOT NULL default '0',
 725           created int NOT NULL default '0',
 726          headers text,
 727          PRIMARY KEY (cid),
 728          INDEX expire (expire)
 729        ) /*!40100 DEFAULT CHARACTER SET UTF8 */ ");
 730        break;
 731      case 'pgsql':
 732        $ret[] = update_sql("CREATE TABLE {cache_filter} (
 733          cid varchar(255) NOT NULL default '',
 734          data bytea,
 735          expire int NOT NULL default '0',
 736          created int NOT NULL default '0',
 737          headers text,
 738          PRIMARY KEY (cid)
 739       )");
 740       $ret[] = update_sql("CREATE TABLE {cache_menu} (
 741         cid varchar(255) NOT NULL default '',
 742         data bytea,
 743         expire int NOT NULL default '0',
 744         created int NOT NULL default '0',
 745         headers text,
 746         PRIMARY KEY (cid)
 747       )");
 748       $ret[] = update_sql("CREATE TABLE {cache_page} (
 749         cid varchar(255) NOT NULL default '',
 750         data bytea,
 751         expire int NOT NULL default '0',
 752         created int NOT NULL default '0',
 753         headers text,
 754         PRIMARY KEY (cid)
 755       )");
 756       $ret[] = update_sql("CREATE INDEX {cache_filter}_expire_idx ON {cache_filter} (expire)");
 757       $ret[] = update_sql("CREATE INDEX {cache_menu}_expire_idx ON {cache_menu} (expire)");
 758       $ret[] = update_sql("CREATE INDEX {cache_page}_expire_idx ON {cache_page} (expire)");
 759       break;
 760    }
 761    return $ret;
 762  }
 763  
 764  // Some unavoidable errors happen because the database is not yet up-to-date.
 765  // Our custom error handler is not yet installed, so we just suppress them.
 766  ini_set('display_errors', FALSE);
 767  
 768  include_once  './includes/bootstrap.inc';
 769  update_fix_system_table();
 770  
 771  drupal_bootstrap(DRUPAL_BOOTSTRAP_FULL);
 772  drupal_maintenance_theme();
 773  
 774  // This must happen *after* drupal_bootstrap(), since it calls
 775  // variable_(get|set), which only works after a full bootstrap.
 776  update_fix_access_table();
 777  update_create_cache_tables();
 778  
 779  // Turn error reporting back on. From now on, only fatal errors (which are
 780  // not passed through the error handler) will cause a message to be printed.
 781  ini_set('display_errors', TRUE);
 782  
 783  // Access check:
 784  if (($access_check == FALSE) || ($user->uid == 1)) {
 785  
 786    include_once  './includes/install.inc';
 787    drupal_load_updates();
 788  
 789    update_fix_schema_version();
 790    update_fix_watchdog_115();
 791    update_fix_watchdog();
 792    update_fix_sessions();
 793  
 794    $op = isset($_REQUEST['op']) ? $_REQUEST['op'] : '';
 795    switch ($op) {
 796      case 'Update':
 797        $output = update_update_page();
 798        break;
 799  
 800      case 'finished':
 801        $output = update_finished_page(TRUE);
 802        break;
 803  
 804      case 'error':
 805        $output = update_finished_page(FALSE);
 806        break;
 807  
 808      case 'do_update':
 809        $output = update_do_update_page();
 810        break;
 811  
 812      case 'do_update_nojs':
 813        $output = update_progress_page_nojs();
 814        break;
 815  
 816      case 'selection':
 817        $output = update_selection_page();
 818        break;
 819  
 820      default:
 821        $output = update_info_page();
 822        break;
 823    }
 824  }
 825  else {
 826    $output = update_access_denied_page();
 827  }
 828  
 829  if (isset($output)) {
 830    print theme('maintenance_page', $output);
 831  }