import.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * Core script for import, this is just the glue around all other stuff
   5  *
   6  * @package PhpMyAdmin
   7  */
   8 use PMA\libraries\plugins\ImportPlugin;
   9
  10 /**
  11  * Get the variables sent or posted to this script and a core script
  12  */
  13 require_once 'libraries/common.inc.php';
  14 require_once 'libraries/sql.lib.php';
  15 require_once 'libraries/bookmark.lib.php';
  16 //require_once 'libraries/display_import_functions.lib.php';
  17
  18 if (isset($_REQUEST['show_as_php'])) {
  19     $GLOBALS['show_as_php'] = $_REQUEST['show_as_php'];
  20 }
  21
  22 // Import functions.
  23 require_once 'libraries/import.lib.php';
  24
  25 // If there is a request to 'Simulate DML'.
  26 if (isset($_REQUEST['simulate_dml'])) {
  27     PMA_handleSimulateDMLRequest();
  28     exit;
  29 }
  30
  31 // If it's a refresh console bookmarks request
  32 if (isset($_REQUEST['console_bookmark_refresh'])) {
  33     $response = PMA\libraries\Response::getInstance();
  34     $response->addJSON(
  35         'console_message_bookmark', PMA\libraries\Console::getBookmarkContent()
  36     );
  37     exit;
  38 }
  39 // If it's a console bookmark add request
  40 if (isset($_REQUEST['console_bookmark_add'])) {
  41     $response = PMA\libraries\Response::getInstance();
  42     if (isset($_REQUEST['label']) && isset($_REQUEST['db'])
  43         && isset($_REQUEST['bookmark_query']) && isset($_REQUEST['shared'])
  44     ) {
  45         $cfgBookmark = PMA_Bookmark_getParams();
  46         $bookmarkFields = array(
  47             'bkm_database' => $_REQUEST['db'],
  48             'bkm_user'  => $cfgBookmark['user'],
  49             'bkm_sql_query' => urlencode($_REQUEST['bookmark_query']),
  50             'bkm_label' => $_REQUEST['label']
  51         );
  52         $isShared = ($_REQUEST['shared'] == 'true' ? true : false);
  53         if (PMA_Bookmark_save($bookmarkFields, $isShared)) {
  54             $response->addJSON('message', __('Succeeded'));
  55             $response->addJSON('data', $bookmarkFields);
  56             $response->addJSON('isShared', $isShared);
  57         } else {
  58             $response->addJSON('message', __('Failed'));
  59         }
  60         die();
  61     } else {
  62         $response->addJSON('message', __('Incomplete params'));
  63         die();
  64     }
  65 }
  66
  67 $format = '';
  68
  69 /**
  70  * Sets globals from $_POST
  71  */
  72 $post_params = array(
  73     'charset_of_file',
  74     'format',
  75     'import_type',
  76     'is_js_confirmed',
  77     'MAX_FILE_SIZE',
  78     'message_to_show',
  79     'noplugin',
  80     'skip_queries',
  81     'local_import_file'
  82 );
  83
  84 // TODO: adapt full list of allowed parameters, as in export.php
  85 foreach ($post_params as $one_post_param) {
  86     if (isset($_POST[$one_post_param])) {
  87         $GLOBALS[$one_post_param] = $_POST[$one_post_param];
  88     }
  89 }
  90
  91 // reset import messages for ajax request
  92 $_SESSION['Import_message']['message'] = null;
  93 $_SESSION['Import_message']['go_back_url'] = null;
  94 // default values
  95 $GLOBALS['reload'] = false;
  96
  97 // Use to identify current cycle is executing
  98 // a multiquery statement or stored routine
  99 if (!isset($_SESSION['is_multi_query'])) {
 100     $_SESSION['is_multi_query'] = false;
 101 }
 102
 103 $ajax_reload = array();
 104 // Are we just executing plain query or sql file?
 105 // (eg. non import, but query box/window run)
 106 if (! empty($sql_query)) {
 107
 108     // apply values for parameters
 109     if (! empty($_REQUEST['parameterized'])
 110         && ! empty($_REQUEST['parameters'])
 111         && is_array($_REQUEST['parameters'])) {
 112         $parameters = $_REQUEST['parameters'];
 113         foreach ($parameters as $parameter => $replacement) {
 114             $quoted = preg_quote($parameter);
 115             // making sure that :param does not apply values to :param1
 116             $sql_query = preg_replace(
 117                 '/' . $quoted . '([^a-zA-Z0-9_])/',
 118                 PMA\libraries\Util::sqlAddSlashes($replacement) . '${1}',
 119                 $sql_query
 120             );
 121             // for parameters the appear at the end of the string
 122             $sql_query = preg_replace(
 123                 '/' . $quoted . '$/',
 124                 PMA\libraries\Util::sqlAddSlashes($replacement),
 125                 $sql_query
 126             );
 127         }
 128     }
 129
 130     // run SQL query
 131     $import_text = $sql_query;
 132     $import_type = 'query';
 133     $format = 'sql';
 134     $_SESSION['sql_from_query_box'] = true;
 135
 136     // If there is a request to ROLLBACK when finished.
 137     if (isset($_REQUEST['rollback_query'])) {
 138         PMA_handleRollbackRequest($import_text);
 139     }
 140
 141     // refresh navigation and main panels
 142     if (preg_match('/^(DROP)\s+(VIEW|TABLE|DATABASE|SCHEMA)\s+/i', $sql_query)) {
 143         $GLOBALS['reload'] = true;
 144         $ajax_reload['reload'] = true;
 145     }
 146
 147     // refresh navigation panel only
 148     if (preg_match(
 149         '/^(CREATE|ALTER)\s+(VIEW|TABLE|DATABASE|SCHEMA)\s+/i',
 150         $sql_query
 151     )) {
 152         $ajax_reload['reload'] = true;
 153     }
 154
 155     // do a dynamic reload if table is RENAMED
 156     // (by sending the instruction to the AJAX response handler)
 157     if (preg_match(
 158         '/^RENAME\s+TABLE\s+(.*?)\s+TO\s+(.*?)($|;|\s)/i',
 159         $sql_query,
 160         $rename_table_names
 161     )) {
 162         $ajax_reload['reload'] = true;
 163         $ajax_reload['table_name'] = PMA\libraries\Util::unQuote(
 164             $rename_table_names[2]
 165         );
 166     }
 167
 168     $sql_query = '';
 169 } elseif (! empty($sql_file)) {
 170     // run uploaded SQL file
 171     $import_file = $sql_file;
 172     $import_type = 'queryfile';
 173     $format = 'sql';
 174     unset($sql_file);
 175 } elseif (! empty($_REQUEST['id_bookmark'])) {
 176     // run bookmark
 177     $import_type = 'query';
 178     $format = 'sql';
 179 }
 180
 181 // If we didn't get any parameters, either user called this directly, or
 182 // upload limit has been reached, let's assume the second possibility.
 183 if ($_POST == array() && $_GET == array()) {
 184     $message = PMA\libraries\Message::error(
 185         __(
 186             'You probably tried to upload a file that is too large. Please refer ' .
 187             'to %sdocumentation%s for a workaround for this limit.'
 188         )
 189     );
 190     $message->addParam('[doc@faq1-16]');
 191     $message->addParam('[/doc]');
 192
 193     // so we can obtain the message
 194     $_SESSION['Import_message']['message'] = $message->getDisplay();
 195     $_SESSION['Import_message']['go_back_url'] = $GLOBALS['goto'];
 196
 197     $message->display();
 198     exit; // the footer is displayed automatically
 199 }
 200
 201 // Add console message id to response output
 202 if (isset($_POST['console_message_id'])) {
 203     $response = PMA\libraries\Response::getInstance();
 204     $response->addJSON('console_message_id', $_POST['console_message_id']);
 205 }
 206
 207 /**
 208  * Sets globals from $_POST patterns, for import plugins
 209  * We only need to load the selected plugin
 210  */
 211
 212 if (! in_array(
 213     $format,
 214     array(
 215         'csv',
 216         'ldi',
 217         'mediawiki',
 218         'ods',
 219         'shp',
 220         'sql',
 221         'xml'
 222     )
 223 )
 224 ) {
 225     // this should not happen for a normal user
 226     // but only during an attack
 227     PMA_fatalError('Incorrect format parameter');
 228 }
 229
 230 $post_patterns = array(
 231     '/^force_file_/',
 232     '/^' . $format . '_/'
 233 );
 234
 235 PMA_setPostAsGlobal($post_patterns);
 236
 237 // Check needed parameters
 238 PMA\libraries\Util::checkParameters(array('import_type', 'format'));
 239
 240 // We don't want anything special in format
 241 $format = PMA_securePath($format);
 242
 243 // Create error and goto url
 244 if ($import_type == 'table') {
 245     $err_url = 'tbl_import.php' . PMA_URL_getCommon(
 246         array(
 247             'db' => $db, 'table' => $table
 248         )
 249     );
 250     $_SESSION['Import_message']['go_back_url'] = $err_url;
 251     $goto = 'tbl_import.php';
 252 } elseif ($import_type == 'database') {
 253     $err_url = 'db_import.php' . PMA_URL_getCommon(array('db' => $db));
 254     $_SESSION['Import_message']['go_back_url'] = $err_url;
 255     $goto = 'db_import.php';
 256 } elseif ($import_type == 'server') {
 257     $err_url = 'server_import.php' . PMA_URL_getCommon();
 258     $_SESSION['Import_message']['go_back_url'] = $err_url;
 259     $goto = 'server_import.php';
 260 } else {
 261     if (empty($goto) || !preg_match('@^(server|db|tbl)(_[a-z]*)*\.php$@i', $goto)) {
 262         if (mb_strlen($table) && mb_strlen($db)) {
 263             $goto = 'tbl_structure.php';
 264         } elseif (mb_strlen($db)) {
 265             $goto = 'db_structure.php';
 266         } else {
 267             $goto = 'server_sql.php';
 268         }
 269     }
 270     if (mb_strlen($table) && mb_strlen($db)) {
 271         $common = PMA_URL_getCommon(array('db' => $db, 'table' => $table));
 272     } elseif (mb_strlen($db)) {
 273         $common = PMA_URL_getCommon(array('db' => $db));
 274     } else {
 275         $common = PMA_URL_getCommon();
 276     }
 277     $err_url  = $goto . $common
 278         . (preg_match('@^tbl_[a-z]*\.php$@', $goto)
 279             ? '&amp;table=' . htmlspecialchars($table)
 280             : '');
 281     $_SESSION['Import_message']['go_back_url'] = $err_url;
 282 }
 283 // Avoid setting selflink to 'import.php'
 284 // problem similar to bug 4276
 285 if (basename($_SERVER['SCRIPT_NAME']) === 'import.php') {
 286     $_SERVER['SCRIPT_NAME'] = $goto;
 287 }
 288
 289
 290 if (mb_strlen($db)) {
 291     $GLOBALS['dbi']->selectDb($db);
 292 }
 293
 294 @set_time_limit($cfg['ExecTimeLimit']);
 295 if (! empty($cfg['MemoryLimit'])) {
 296     @ini_set('memory_limit', $cfg['MemoryLimit']);
 297 }
 298
 299 $timestamp = time();
 300 if (isset($_REQUEST['allow_interrupt'])) {
 301     $maximum_time = ini_get('max_execution_time');
 302 } else {
 303     $maximum_time = 0;
 304 }
 305
 306 // set default values
 307 $timeout_passed = false;
 308 $error = false;
 309 $read_multiply = 1;
 310 $finished = false;
 311 $offset = 0;
 312 $max_sql_len = 0;
 313 $file_to_unlink = '';
 314 $sql_query = '';
 315 $sql_query_disabled = false;
 316 $go_sql = false;
 317 $executed_queries = 0;
 318 $run_query = true;
 319 $charset_conversion = false;
 320 $reset_charset = false;
 321 $bookmark_created = false;
 322
 323 // Bookmark Support: get a query back from bookmark if required
 324 if (! empty($_REQUEST['id_bookmark'])) {
 325     $id_bookmark = (int)$_REQUEST['id_bookmark'];
 326     include_once 'libraries/bookmark.lib.php';
 327     switch ($_REQUEST['action_bookmark']) {
 328     case 0: // bookmarked query that have to be run
 329         $import_text = PMA_Bookmark_get(
 330             $db,
 331             $id_bookmark,
 332             'id',
 333             isset($_REQUEST['action_bookmark_all'])
 334         );
 335         if (! empty($_REQUEST['bookmark_variable'])) {
 336             $import_text = PMA_Bookmark_applyVariables(
 337                 $import_text
 338             );
 339         }
 340
 341         // refresh navigation and main panels
 342         if (preg_match(
 343             '/^(DROP)\s+(VIEW|TABLE|DATABASE|SCHEMA)\s+/i',
 344             $import_text
 345         )) {
 346             $GLOBALS['reload'] = true;
 347             $ajax_reload['reload'] = true;
 348         }
 349
 350         // refresh navigation panel only
 351         if (preg_match(
 352             '/^(CREATE|ALTER)\s+(VIEW|TABLE|DATABASE|SCHEMA)\s+/i',
 353             $import_text
 354         )
 355         ) {
 356             $ajax_reload['reload'] = true;
 357         }
 358         break;
 359     case 1: // bookmarked query that have to be displayed
 360         $import_text = PMA_Bookmark_get($db, $id_bookmark);
 361         if ($GLOBALS['is_ajax_request'] == true) {
 362             $message = PMA\libraries\Message::success(__('Showing bookmark'));
 363             $response = PMA\libraries\Response::getInstance();
 364             $response->setRequestStatus($message->isSuccess());
 365             $response->addJSON('message', $message);
 366             $response->addJSON('sql_query', $import_text);
 367             $response->addJSON('action_bookmark', $_REQUEST['action_bookmark']);
 368             exit;
 369         } else {
 370             $run_query = false;
 371         }
 372         break;
 373     case 2: // bookmarked query that have to be deleted
 374         $import_text = PMA_Bookmark_get($db, $id_bookmark);
 375         PMA_Bookmark_delete($id_bookmark);
 376         if ($GLOBALS['is_ajax_request'] == true) {
 377             $message = PMA\libraries\Message::success(
 378                 __('The bookmark has been deleted.')
 379             );
 380             $response = PMA\libraries\Response::getInstance();
 381             $response->setRequestStatus($message->isSuccess());
 382             $response->addJSON('message', $message);
 383             $response->addJSON('action_bookmark', $_REQUEST['action_bookmark']);
 384             $response->addJSON('id_bookmark', $id_bookmark);
 385             exit;
 386         } else {
 387             $run_query = false;
 388             $error = true; // this is kind of hack to skip processing the query
 389         }
 390         break;
 391     }
 392 } // end bookmarks reading
 393
 394 // Do no run query if we show PHP code
 395 if (isset($GLOBALS['show_as_php'])) {
 396     $run_query = false;
 397     $go_sql = true;
 398 }
 399
 400 // We can not read all at once, otherwise we can run out of memory
 401 $memory_limit = trim(@ini_get('memory_limit'));
 402 // 2 MB as default
 403 if (empty($memory_limit)) {
 404     $memory_limit = 2 * 1024 * 1024;
 405 }
 406 // In case no memory limit we work on 10MB chunks
 407 if ($memory_limit == -1) {
 408     $memory_limit = 10 * 1024 * 1024;
 409 }
 410
 411 // Calculate value of the limit
 412 $memoryUnit = mb_strtolower(substr($memory_limit, -1));
 413 if ('m' == $memoryUnit) {
 414     $memory_limit = (int)substr($memory_limit, 0, -1) * 1024 * 1024;
 415 } elseif ('k' == $memoryUnit) {
 416     $memory_limit = (int)substr($memory_limit, 0, -1) * 1024;
 417 } elseif ('g' == $memoryUnit) {
 418     $memory_limit = (int)substr($memory_limit, 0, -1) * 1024 * 1024 * 1024;
 419 } else {
 420     $memory_limit = (int)$memory_limit;
 421 }
 422
 423 // Just to be sure, there might be lot of memory needed for uncompression
 424 $read_limit = $memory_limit / 8;
 425
 426 // handle filenames
 427 if (isset($_FILES['import_file'])) {
 428     $import_file = $_FILES['import_file']['tmp_name'];
 429 }
 430 if (! empty($local_import_file) && ! empty($cfg['UploadDir'])) {
 431
 432     // sanitize $local_import_file as it comes from a POST
 433     $local_import_file = PMA_securePath($local_import_file);
 434
 435     $import_file = PMA\libraries\Util::userDir($cfg['UploadDir'])
 436         . $local_import_file;
 437
 438 } elseif (empty($import_file) || ! is_uploaded_file($import_file)) {
 439     $import_file  = 'none';
 440 }
 441
 442 // Do we have file to import?
 443
 444 if ($import_file != 'none' && ! $error) {
 445     // work around open_basedir and other limitations
 446     $open_basedir = @ini_get('open_basedir');
 447
 448     // If we are on a server with open_basedir, we must move the file
 449     // before opening it.
 450
 451     if (! empty($open_basedir)) {
 452         $tmp_subdir = ini_get('upload_tmp_dir');
 453         if (empty($tmp_subdir)) {
 454             $tmp_subdir = sys_get_temp_dir();
 455         }
 456         $tmp_subdir = rtrim($tmp_subdir, DIRECTORY_SEPARATOR);
 457         if (@is_writable($tmp_subdir)) {
 458             $import_file_new = $tmp_subdir . DIRECTORY_SEPARATOR
 459                 . basename($import_file) . uniqid();
 460             if (move_uploaded_file($import_file, $import_file_new)) {
 461                 $import_file = $import_file_new;
 462                 $file_to_unlink = $import_file_new;
 463             }
 464
 465             $size = filesize($import_file);
 466         } else {
 467
 468             // If the php.ini is misconfigured (eg. there is no /tmp access defined
 469             // with open_basedir), $tmp_subdir won't be writable and the user gets
 470             // a 'File could not be read!' error (at PMA_detectCompression), which
 471             // is not too meaningful. Show a meaningful error message to the user
 472             // instead.
 473
 474             $message = PMA\libraries\Message::error(
 475                 __(
 476                     'Uploaded file cannot be moved, because the server has ' .
 477                     'open_basedir enabled without access to the %s directory ' .
 478                     '(for temporary files).'
 479                 )
 480             );
 481             $message->addParam($tmp_subdir);
 482             PMA_stopImport($message);
 483         }
 484     }
 485
 486     /**
 487      *  Handle file compression
 488      * @todo duplicate code exists in File.php
 489      */
 490     $compression = PMA_detectCompression($import_file);
 491     if ($compression === false) {
 492         $message = PMA\libraries\Message::error(__('File could not be read!'));
 493         PMA_stopImport($message); //Contains an 'exit'
 494     }
 495
 496     switch ($compression) {
 497     case 'application/bzip2':
 498         if ($cfg['BZipDump'] && @function_exists('bzopen')) {
 499             $import_handle = @bzopen($import_file, 'r');
 500         } else {
 501             $message = PMA\libraries\Message::error(
 502                 __(
 503                     'You attempted to load file with unsupported compression ' .
 504                     '(%s). Either support for it is not implemented or disabled ' .
 505                     'by your configuration.'
 506                 )
 507             );
 508             $message->addParam($compression);
 509             PMA_stopImport($message);
 510         }
 511         break;
 512     case 'application/gzip':
 513         if ($cfg['GZipDump'] && @function_exists('gzopen')) {
 514             $import_handle = @gzopen($import_file, 'r');
 515         } else {
 516             $message = PMA\libraries\Message::error(
 517                 __(
 518                     'You attempted to load file with unsupported compression ' .
 519                     '(%s). Either support for it is not implemented or disabled ' .
 520                     'by your configuration.'
 521                 )
 522             );
 523             $message->addParam($compression);
 524             PMA_stopImport($message);
 525         }
 526         break;
 527     case 'application/zip':
 528         if ($cfg['ZipDump'] && @function_exists('zip_open')) {
 529             /**
 530              * Load interface for zip extension.
 531              */
 532             include_once 'libraries/zip_extension.lib.php';
 533             $zipResult = PMA_getZipContents($import_file);
 534             if (! empty($zipResult['error'])) {
 535                 $message = PMA\libraries\Message::rawError($zipResult['error']);
 536                 PMA_stopImport($message);
 537             } else {
 538                 $import_text = $zipResult['data'];
 539             }
 540         } else {
 541             $message = PMA\libraries\Message::error(
 542                 __(
 543                     'You attempted to load file with unsupported compression ' .
 544                     '(%s). Either support for it is not implemented or disabled ' .
 545                     'by your configuration.'
 546                 )
 547             );
 548             $message->addParam($compression);
 549             PMA_stopImport($message);
 550         }
 551         break;
 552     case 'none':
 553         $import_handle = @fopen($import_file, 'r');
 554         break;
 555     default:
 556         $message = PMA\libraries\Message::error(
 557             __(
 558                 'You attempted to load file with unsupported compression (%s). ' .
 559                 'Either support for it is not implemented or disabled by your ' .
 560                 'configuration.'
 561             )
 562         );
 563         $message->addParam($compression);
 564         PMA_stopImport($message);
 565         // the previous function exits
 566     }
 567     // use isset() because zip compression type does not use a handle
 568     if (! $error && isset($import_handle) && $import_handle === false) {
 569         $message = PMA\libraries\Message::error(__('File could not be read!'));
 570         PMA_stopImport($message);
 571     }
 572 } elseif (! $error) {
 573     if (! isset($import_text) || empty($import_text)) {
 574         $message = PMA\libraries\Message::error(
 575             __(
 576                 'No data was received to import. Either no file name was ' .
 577                 'submitted, or the file size exceeded the maximum size permitted ' .
 578                 'by your PHP configuration. See [doc@faq1-16]FAQ 1.16[/doc].'
 579             )
 580         );
 581         PMA_stopImport($message);
 582     }
 583 }
 584
 585 // so we can obtain the message
 586 //$_SESSION['Import_message'] = $message->getDisplay();
 587
 588 // Convert the file's charset if necessary
 589 if ($GLOBALS['PMA_recoding_engine'] != PMA_CHARSET_NONE && isset($charset_of_file)) {
 590     if ($charset_of_file != 'utf-8') {
 591         $charset_conversion = true;
 592     }
 593 } elseif (isset($charset_of_file) && $charset_of_file != 'utf-8') {
 594     $GLOBALS['dbi']->query('SET NAMES \'' . $charset_of_file . '\'');
 595     // We can not show query in this case, it is in different charset
 596     $sql_query_disabled = true;
 597     $reset_charset = true;
 598 }
 599
 600 // Something to skip? (because timeout has passed)
 601 if (! $error && isset($_POST['skip'])) {
 602     $original_skip = $skip = $_POST['skip'];
 603     while ($skip > 0) {
 604         PMA_importGetNextChunk($skip < $read_limit ? $skip : $read_limit);
 605         // Disable read progressivity, otherwise we eat all memory!
 606         $read_multiply = 1;
 607         $skip -= $read_limit;
 608     }
 609     unset($skip);
 610 }
 611
 612 // This array contain the data like numberof valid sql queries in the statement
 613 // and complete valid sql statement (which affected for rows)
 614 $sql_data = array('valid_sql' => array(), 'valid_queries' => 0);
 615
 616 if (! $error) {
 617     // Check for file existence
 618     include_once "libraries/plugin_interface.lib.php";
 619     /* @var $import_plugin ImportPlugin */
 620     $import_plugin = PMA_getPlugin(
 621         "import",
 622         $format,
 623         'libraries/plugins/import/',
 624         $import_type
 625     );
 626     if ($import_plugin == null) {
 627         $message = PMA\libraries\Message::error(
 628             __('Could not load import plugins, please check your installation!')
 629         );
 630         PMA_stopImport($message);
 631     } else {
 632         // Do the real import
 633         try {
 634             $default_fk_check = PMA\libraries\Util::handleDisableFKCheckInit();
 635             $import_plugin->doImport($sql_data);
 636             PMA\libraries\Util::handleDisableFKCheckCleanup($default_fk_check);
 637         } catch (Exception $e) {
 638             PMA\libraries\Util::handleDisableFKCheckCleanup($default_fk_check);
 639             throw $e;
 640         }
 641     }
 642 }
 643
 644 if (! empty($import_handle)) {
 645     fclose($import_handle);
 646 }
 647
 648 // Cleanup temporary file
 649 if ($file_to_unlink != '') {
 650     unlink($file_to_unlink);
 651 }
 652
 653 // Reset charset back, if we did some changes
 654 if ($reset_charset) {
 655     $GLOBALS['dbi']->query('SET CHARACTER SET utf8');
 656     $GLOBALS['dbi']->query(
 657         'SET SESSION collation_connection =\'' . $collation_connection . '\''
 658     );
 659 }
 660
 661 // Show correct message
 662 if (! empty($id_bookmark) && $_REQUEST['action_bookmark'] == 2) {
 663     $message = PMA\libraries\Message::success(__('The bookmark has been deleted.'));
 664     $display_query = $import_text;
 665     $error = false; // unset error marker, it was used just to skip processing
 666 } elseif (! empty($id_bookmark) && $_REQUEST['action_bookmark'] == 1) {
 667     $message = PMA\libraries\Message::notice(__('Showing bookmark'));
 668 } elseif ($bookmark_created) {
 669     $special_message = '[br]'  . sprintf(
 670         __('Bookmark %s has been created.'),
 671         htmlspecialchars($_POST['bkm_label'])
 672     );
 673 } elseif ($finished && ! $error) {
 674     // Do not display the query with message, we do it separately
 675     $display_query = ';';
 676     if ($import_type != 'query') {
 677         $message = PMA\libraries\Message::success(
 678             '<em>'
 679             . _ngettext(
 680                 'Import has been successfully finished, %d query executed.',
 681                 'Import has been successfully finished, %d queries executed.',
 682                 $executed_queries
 683             )
 684             . '</em>'
 685         );
 686         $message->addParam($executed_queries);
 687
 688         if ($import_notice) {
 689             $message->addString($import_notice);
 690         }
 691         if (! empty($local_import_file)) {
 692             $message->addString('(' . htmlspecialchars($local_import_file) . ')');
 693         } else {
 694             $message->addString(
 695                 '(' . htmlspecialchars($_FILES['import_file']['name']) . ')'
 696             );
 697         }
 698     }
 699 }
 700
 701 // Did we hit timeout? Tell it user.
 702 if ($timeout_passed) {
 703     $importUrl = $err_url .= '&timeout_passed=1&offset=' . urlencode(
 704         $GLOBALS['offset']
 705     );
 706     if (isset($local_import_file)) {
 707         $importUrl .= '&local_import_file=' . urlencode($local_import_file);
 708     }
 709     $message = PMA\libraries\Message::error(
 710         __(
 711             'Script timeout passed, if you want to finish import,'
 712             . ' please %sresubmit the same file%s and import will resume.'
 713         )
 714     );
 715     $message->addParam('<a href="' . $importUrl . '">', false);
 716     $message->addParam('</a>', false);
 717
 718     if ($offset == 0 || (isset($original_skip) && $original_skip == $offset)) {
 719         $message->addString(
 720             __(
 721                 'However on last run no data has been parsed,'
 722                 . ' this usually means phpMyAdmin won\'t be able to'
 723                 . ' finish this import unless you increase php time limits.'
 724             )
 725         );
 726     }
 727 }
 728
 729 // if there is any message, copy it into $_SESSION as well,
 730 // so we can obtain it by AJAX call
 731 if (isset($message)) {
 732     $_SESSION['Import_message']['message'] = $message->getDisplay();
 733 }
 734 // Parse and analyze the query, for correct db and table name
 735 // in case of a query typed in the query window
 736 // (but if the query is too large, in case of an imported file, the parser
 737 //  can choke on it so avoid parsing)
 738 $sqlLength = mb_strlen($sql_query);
 739 if ($sqlLength <= $GLOBALS['cfg']['MaxCharactersInDisplayedSQL']) {
 740     include_once 'libraries/parse_analyze.lib.php';
 741
 742     list(
 743         $analyzed_sql_results,
 744         $db,
 745         $table
 746     ) = PMA_parseAnalyze($sql_query, $db);
 747     // @todo: possibly refactor
 748     extract($analyzed_sql_results);
 749 }
 750
 751 // There was an error?
 752 if (isset($my_die)) {
 753     foreach ($my_die as $key => $die) {
 754         PMA\libraries\Util::mysqlDie(
 755             $die['error'], $die['sql'], false, $err_url, $error
 756         );
 757     }
 758 }
 759
 760 if ($go_sql) {
 761
 762     if (! empty($sql_data) && ($sql_data['valid_queries'] > 1)) {
 763         $_SESSION['is_multi_query'] = true;
 764         $sql_queries = $sql_data['valid_sql'];
 765     } else {
 766         $sql_queries = array($sql_query);
 767     }
 768
 769     $html_output = '';
 770     foreach ($sql_queries as $sql_query) {
 771
 772         // parse sql query
 773         include_once 'libraries/parse_analyze.lib.php';
 774         list(
 775             $analyzed_sql_results,
 776             $db,
 777             $table
 778         ) = PMA_parseAnalyze($sql_query, $db);
 779         // @todo: possibly refactor
 780         extract($analyzed_sql_results);
 781
 782         $html_output .= PMA_executeQueryAndGetQueryResponse(
 783             $analyzed_sql_results, // analyzed_sql_results
 784             false, // is_gotofile
 785             $db, // db
 786             $table, // table
 787             null, // find_real_end
 788             $_REQUEST['sql_query'], // sql_query_for_bookmark
 789             null, // extra_data
 790             null, // message_to_show
 791             null, // message
 792             null, // sql_data
 793             $goto, // goto
 794             $pmaThemeImage, // pmaThemeImage
 795             null, // disp_query
 796             null, // disp_message
 797             null, // query_type
 798             $sql_query, // sql_query
 799             null, // selectedTables
 800             null // complete_query
 801         );
 802     }
 803
 804     $response = PMA\libraries\Response::getInstance();
 805     $response->addJSON('ajax_reload', $ajax_reload);
 806     $response->addHTML($html_output);
 807     exit();
 808
 809 } else if ($result) {
 810     // Save a Bookmark with more than one queries (if Bookmark label given).
 811     if (! empty($_POST['bkm_label']) && ! empty($import_text)) {
 812         $cfgBookmark = PMA_Bookmark_getParams();
 813         PMA_storeTheQueryAsBookmark(
 814             $db, $cfgBookmark['user'],
 815             $_REQUEST['sql_query'], $_POST['bkm_label'],
 816             isset($_POST['bkm_replace']) ? $_POST['bkm_replace'] : null
 817         );
 818     }
 819
 820     $response = PMA\libraries\Response::getInstance();
 821     $response->setRequestStatus(true);
 822     $response->addJSON('message', PMA\libraries\Message::success($msg));
 823     $response->addJSON(
 824         'sql_query',
 825         PMA\libraries\Util::getMessage($msg, $sql_query, 'success')
 826     );
 827 } else if ($result == false) {
 828     $response = PMA\libraries\Response::getInstance();
 829     $response->setRequestStatus(false);
 830     $response->addJSON('message', PMA\libraries\Message::error($msg));
 831 } else {
 832     $active_page = $goto;
 833     include '' . $goto;
 834 }
 835
 836 // If there is request for ROLLBACK in the end.
 837 if (isset($_REQUEST['rollback_query'])) {
 838     $GLOBALS['dbi']->query('ROLLBACK');
 839 }