export.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * Main export handling code
   5  *
   6  * @package PhpMyAdmin
   7  */
   8
   9 /**
  10  * Get the variables sent or posted to this script and a core script
  11  */
  12 require_once 'libraries/common.inc.php';
  13 require_once 'libraries/zip.lib.php';
  14 require_once 'libraries/plugin_interface.lib.php';
  15
  16 /**
  17  * Sets globals from all $_POST (in export.php only)
  18  * Would it not be tiresome to list all export-plugin options here?
  19  */
  20 foreach ($_POST as $one_post_param => $one_post_value) {
  21     $GLOBALS[$one_post_param] = $one_post_value;
  22 }
  23
  24 PMA_Util::checkParameters(array('what', 'export_type'));
  25
  26 // export class instance, not array of properties, as before
  27 $export_plugin = PMA_getPlugin(
  28     "export",
  29     $what,
  30     'libraries/plugins/export/',
  31     array(
  32         'export_type' => $export_type,
  33         'single_table' => isset($single_table)
  34     )
  35 );
  36
  37 // Backward compatbility
  38 $type = $what;
  39
  40 // Check export type
  41 if (! isset($export_plugin)) {
  42     PMA_fatalError(__('Bad type!'));
  43 }
  44
  45 /**
  46  * valid compression methods
  47  */
  48 $compression_methods = array(
  49     'zip',
  50     'gzip',
  51     'bzip2',
  52 );
  53
  54 /**
  55  * init and variable checking
  56  */
  57 $compression = false;
  58 $onserver = false;
  59 $save_on_server = false;
  60 $buffer_needed = false;
  61
  62 // Is it a quick or custom export?
  63 if ($_REQUEST['quick_or_custom'] == 'quick') {
  64     $quick_export = true;
  65 } else {
  66     $quick_export = false;
  67 }
  68
  69 if ($_REQUEST['output_format'] == 'astext') {
  70     $asfile = false;
  71 } else {
  72     $asfile = true;
  73     if (in_array($_REQUEST['compression'], $compression_methods)) {
  74         $compression = $_REQUEST['compression'];
  75         $buffer_needed = true;
  76     }
  77     if (($quick_export && ! empty($_REQUEST['quick_export_onserver']))
  78         || (! $quick_export && ! empty($_REQUEST['onserver']))
  79     ) {
  80         if ($quick_export) {
  81             $onserver = $_REQUEST['quick_export_onserver'];
  82         } else {
  83             $onserver = $_REQUEST['onserver'];
  84         }
  85         // Will we save dump on server?
  86         $save_on_server = ! empty($cfg['SaveDir']) && $onserver;
  87     }
  88 }
  89
  90 // Does export require to be into file?
  91 if ($export_plugin->getProperties()->getForceFile() != null && ! $asfile) {
  92     $message = PMA_Message::error(
  93         __('Selected export type has to be saved in file!')
  94     );
  95     if ($export_type == 'server') {
  96         $active_page = 'server_export.php';
  97         include 'server_export.php';
  98     } elseif ($export_type == 'database') {
  99         $active_page = 'db_export.php';
 100         include 'db_export.php';
 101     } else {
 102         $active_page = 'tbl_export.php';
 103         include 'tbl_export.php';
 104     }
 105     exit();
 106 }
 107
 108 // Generate error url and check for needed variables
 109 if ($export_type == 'server') {
 110     $err_url = 'server_export.php?' . PMA_generate_common_url();
 111 } elseif ($export_type == 'database' && strlen($db)) {
 112     $err_url = 'db_export.php?' . PMA_generate_common_url($db);
 113     // Check if we have something to export
 114     if (isset($table_select)) {
 115         $tables = $table_select;
 116     } else {
 117         $tables = array();
 118     }
 119 } elseif ($export_type == 'table' && strlen($db) && strlen($table)) {
 120     $err_url = 'tbl_export.php?' . PMA_generate_common_url($db, $table);
 121 } else {
 122     PMA_fatalError(__('Bad parameters!'));
 123 }
 124
 125 /**
 126  * Increase time limit for script execution and initializes some variables
 127  */
 128 @set_time_limit($cfg['ExecTimeLimit']);
 129 if (! empty($cfg['MemoryLimit'])) {
 130     @ini_set('memory_limit', $cfg['MemoryLimit']);
 131 }
 132
 133 // Start with empty buffer
 134 $dump_buffer = '';
 135 $dump_buffer_len = 0;
 136
 137 // We send fake headers to avoid browser timeout when buffering
 138 $time_start = time();
 139
 140
 141 /**
 142  * Detect ob_gzhandler
 143  *
 144  * @return bool
 145  */
 146 function PMA_isGzHandlerEnabled()
 147 {
 148     return in_array('ob_gzhandler', ob_list_handlers());
 149 }
 150
 151 /**
 152  * Detect whether gzencode is needed; it might not be needed if
 153  * the server is already compressing by itself
 154  *
 155  * @return bool Whether gzencode is needed
 156  */
 157 function PMA_gzencodeNeeded()
 158 {
 159     if (@function_exists('gzencode')
 160         && ! @ini_get('zlib.output_compression')
 161         // Here, we detect Apache's mod_deflate so we bet that
 162         // this module is active for this instance of phpMyAdmin
 163         // and therefore, will gzip encode the content
 164         && ! (function_exists('apache_get_modules')
 165             && in_array('mod_deflate', apache_get_modules()))
 166         && ! PMA_isGzHandlerEnabled()
 167     ) {
 168         return true;
 169     } else {
 170         return false;
 171     }
 172 }
 173
 174 /**
 175  * Output handler for all exports, if needed buffering, it stores data into
 176  * $dump_buffer, otherwise it prints thems out.
 177  *
 178  * @param string $line the insert statement
 179  *
 180  * @return bool Whether output succeeded
 181  */
 182 function PMA_exportOutputHandler($line)
 183 {
 184     global $time_start, $dump_buffer, $dump_buffer_len, $save_filename;
 185
 186     // Kanji encoding convert feature
 187     if ($GLOBALS['output_kanji_conversion']) {
 188         $line = PMA_kanji_str_conv(
 189             $line,
 190             $GLOBALS['knjenc'],
 191             isset($GLOBALS['xkana']) ? $GLOBALS['xkana'] : ''
 192         );
 193     }
 194     // If we have to buffer data, we will perform everything at once at the end
 195     if ($GLOBALS['buffer_needed']) {
 196
 197         $dump_buffer .= $line;
 198         if ($GLOBALS['onfly_compression']) {
 199
 200             $dump_buffer_len += strlen($line);
 201
 202             if ($dump_buffer_len > $GLOBALS['memory_limit']) {
 203                 if ($GLOBALS['output_charset_conversion']) {
 204                     $dump_buffer = PMA_convert_string(
 205                         'utf-8',
 206                         $GLOBALS['charset_of_file'],
 207                         $dump_buffer
 208                     );
 209                 }
 210                 // as bzipped
 211                 if ($GLOBALS['compression'] == 'bzip2'
 212                     && @function_exists('bzcompress')
 213                 ) {
 214                     $dump_buffer = bzcompress($dump_buffer);
 215                 } elseif ($GLOBALS['compression'] == 'gzip'
 216                      && PMA_gzencodeNeeded()
 217                 ) {
 218                     // as a gzipped file
 219                     // without the optional parameter level because it bugs
 220                     $dump_buffer = gzencode($dump_buffer);
 221                 }
 222                 if ($GLOBALS['save_on_server']) {
 223                     $write_result = @fwrite($GLOBALS['file_handle'], $dump_buffer);
 224                     if (! $write_result || ($write_result != strlen($dump_buffer))) {
 225                         $GLOBALS['message'] = PMA_Message::error(
 226                             __('Insufficient space to save the file %s.')
 227                         );
 228                         $GLOBALS['message']->addParam($save_filename);
 229                         return false;
 230                     }
 231                 } else {
 232                     echo $dump_buffer;
 233                 }
 234                 $dump_buffer = '';
 235                 $dump_buffer_len = 0;
 236             }
 237         } else {
 238             $time_now = time();
 239             if ($time_start >= $time_now + 30) {
 240                 $time_start = $time_now;
 241                 header('X-pmaPing: Pong');
 242             } // end if
 243         }
 244     } else {
 245         if ($GLOBALS['asfile']) {
 246             if ($GLOBALS['output_charset_conversion']) {
 247                 $line = PMA_convert_string(
 248                     'utf-8',
 249                     $GLOBALS['charset_of_file'],
 250                     $line
 251                 );
 252             }
 253             if ($GLOBALS['save_on_server'] && strlen($line) > 0) {
 254                 $write_result = @fwrite($GLOBALS['file_handle'], $line);
 255                 if (! $write_result || ($write_result != strlen($line))) {
 256                     $GLOBALS['message'] = PMA_Message::error(
 257                         __('Insufficient space to save the file %s.')
 258                     );
 259                     $GLOBALS['message']->addParam($save_filename);
 260                     return false;
 261                 }
 262                 $time_now = time();
 263                 if ($time_start >= $time_now + 30) {
 264                     $time_start = $time_now;
 265                     header('X-pmaPing: Pong');
 266                 } // end if
 267             } else {
 268                 // We export as file - output normally
 269                 echo $line;
 270             }
 271         } else {
 272             // We export as html - replace special chars
 273             echo htmlspecialchars($line);
 274         }
 275     }
 276     return true;
 277 } // end of the 'PMA_exportOutputHandler()' function
 278
 279 // Defines the default <CR><LF> format.
 280 // For SQL always use \n as MySQL wants this on all platforms.
 281 if ($what == 'sql') {
 282     $crlf = "\n";
 283 } else {
 284     $crlf = PMA_Util::whichCrlf();
 285 }
 286
 287 $output_kanji_conversion = function_exists('PMA_kanji_str_conv') && $type != 'xls';
 288
 289 // Do we need to convert charset?
 290 $output_charset_conversion = $asfile
 291     && $GLOBALS['PMA_recoding_engine'] != PMA_CHARSET_NONE
 292     && isset($charset_of_file) && $charset_of_file != 'utf-8'
 293     && $type != 'xls';
 294
 295 // Use on the fly compression?
 296 $onfly_compression = $GLOBALS['cfg']['CompressOnFly']
 297     && ($compression == 'gzip' || $compression == 'bzip2');
 298 if ($onfly_compression) {
 299     $memory_limit = trim(@ini_get('memory_limit'));
 300     // 2 MB as default
 301     if (empty($memory_limit)) {
 302         $memory_limit = 2 * 1024 * 1024;
 303     }
 304
 305     if (strtolower(substr($memory_limit, -1)) == 'm') {
 306         $memory_limit = (int)substr($memory_limit, 0, -1) * 1024 * 1024;
 307     } elseif (strtolower(substr($memory_limit, -1)) == 'k') {
 308         $memory_limit = (int)substr($memory_limit, 0, -1) * 1024;
 309     } elseif (strtolower(substr($memory_limit, -1)) == 'g') {
 310         $memory_limit = (int)substr($memory_limit, 0, -1) * 1024 * 1024 * 1024;
 311     } else {
 312         $memory_limit = (int)$memory_limit;
 313     }
 314
 315     // Some of memory is needed for other thins and as treshold.
 316     // Nijel: During export I had allocated (see memory_get_usage function)
 317     //        approx 1.2MB so this comes from that.
 318     if ($memory_limit > 1500000) {
 319         $memory_limit -= 1500000;
 320     }
 321
 322     // Some memory is needed for compression, assume 1/3
 323     $memory_limit /= 8;
 324 }
 325
 326 // Generate filename and mime type if needed
 327 if ($asfile) {
 328     $pma_uri_parts = parse_url($cfg['PmaAbsoluteUri']);
 329     if ($export_type == 'server') {
 330         if (isset($remember_template)) {
 331             $GLOBALS['PMA_Config']->setUserValue(
 332                 'pma_server_filename_template',
 333                 'Export/file_template_server',
 334                 $filename_template
 335             );
 336         }
 337     } elseif ($export_type == 'database') {
 338         if (isset($remember_template)) {
 339             $GLOBALS['PMA_Config']->setUserValue(
 340                 'pma_db_filename_template',
 341                 'Export/file_template_database',
 342                 $filename_template
 343             );
 344         }
 345     } else {
 346         if (isset($remember_template)) {
 347             $GLOBALS['PMA_Config']->setUserValue(
 348                 'pma_table_filename_template',
 349                 'Export/file_template_table',
 350                 $filename_template
 351             );
 352         }
 353     }
 354     $filename = PMA_Util::expandUserString($filename_template);
 355     $filename = PMA_sanitizeFilename($filename);
 356
 357     // Grab basic dump extension and mime type
 358     // Check if the user already added extension;
 359     // get the substring where the extension would be if it was included
 360     $extension_start_pos = strlen($filename) - strlen(
 361         $export_plugin->getProperties()->getExtension()
 362     ) - 1;
 363     $user_extension = substr($filename, $extension_start_pos, strlen($filename));
 364     $required_extension = "." . $export_plugin->getProperties()->getExtension();
 365     if (strtolower($user_extension) != $required_extension) {
 366         $filename  .= $required_extension;
 367     }
 368     $mime_type  = $export_plugin->getProperties()->getMimeType();
 369
 370     // If dump is going to be compressed, set correct mime_type and add
 371     // compression to extension
 372     if ($compression == 'bzip2') {
 373         $filename  .= '.bz2';
 374         $mime_type = 'application/x-bzip2';
 375     } elseif ($compression == 'gzip') {
 376         $filename  .= '.gz';
 377         $mime_type = 'application/x-gzip';
 378     } elseif ($compression == 'zip') {
 379         $filename  .= '.zip';
 380         $mime_type = 'application/zip';
 381     }
 382 }
 383
 384 // Open file on server if needed
 385 if ($save_on_server) {
 386     $save_filename = PMA_Util::userDir($cfg['SaveDir'])
 387         . preg_replace('@[/\\\\]@', '_', $filename);
 388     unset($message);
 389     if (file_exists($save_filename)
 390         && ((! $quick_export && empty($onserverover))
 391         || ($quick_export
 392         && $_REQUEST['quick_export_onserverover'] != 'saveitover'))
 393     ) {
 394         $message = PMA_Message::error(
 395             __('File %s already exists on server, change filename or check overwrite option.')
 396         );
 397         $message->addParam($save_filename);
 398     } else {
 399         if (is_file($save_filename) && ! is_writable($save_filename)) {
 400             $message = PMA_Message::error(
 401                 __('The web server does not have permission to save the file %s.')
 402             );
 403             $message->addParam($save_filename);
 404         } else {
 405             if (! $file_handle = @fopen($save_filename, 'w')) {
 406                 $message = PMA_Message::error(
 407                     __('The web server does not have permission to save the file %s.')
 408                 );
 409                 $message->addParam($save_filename);
 410             }
 411         }
 412     }
 413     if (isset($message)) {
 414         if ($export_type == 'server') {
 415             $active_page = 'server_export.php';
 416             include 'server_export.php';
 417         } elseif ($export_type == 'database') {
 418             $active_page = 'db_export.php';
 419             include 'db_export.php';
 420         } else {
 421             $active_page = 'tbl_export.php';
 422             include 'tbl_export.php';
 423         }
 424         exit();
 425     }
 426 }
 427
 428 /**
 429  * Send headers depending on whether the user chose to download a dump file
 430  * or not
 431  */
 432 if (! $save_on_server) {
 433     if ($asfile) {
 434         // Download
 435         // (avoid rewriting data containing HTML with anchors and forms;
 436         // this was reported to happen under Plesk)
 437         @ini_set('url_rewriter.tags', '');
 438         $filename = PMA_sanitizeFilename($filename);
 439
 440         PMA_downloadHeader($filename, $mime_type);
 441     } else {
 442         // HTML
 443         if ($export_type == 'database') {
 444             $num_tables = count($tables);
 445             if ($num_tables == 0) {
 446                 $message = PMA_Message::error(__('No tables found in database.'));
 447                 $active_page = 'db_export.php';
 448                 include 'db_export.php';
 449                 exit();
 450             }
 451         }
 452         $backup_cfgServer = $cfg['Server'];
 453         $cfg['Server'] = $backup_cfgServer;
 454         unset($backup_cfgServer);
 455         echo "\n" . '<div style="text-align: ' . $cell_align_left . '">' . "\n";
 456         //echo '    <pre>' . "\n";
 457
 458         /**
 459          * Displays a back button with all the $_REQUEST data in the URL
 460          * (store in a variable to also display after the textarea)
 461          */
 462         $back_button = '<p>[ <a href="';
 463         if ($export_type == 'server') {
 464             $back_button .= 'server_export.php?' . PMA_generate_common_url();
 465         } elseif ($export_type == 'database') {
 466             $back_button .= 'db_export.php?' . PMA_generate_common_url($db);
 467         } else {
 468             $back_button .= 'tbl_export.php?' . PMA_generate_common_url($db, $table);
 469         }
 470
 471         // Convert the multiple select elements from an array to a string
 472         if ($export_type == 'server' && isset($_REQUEST['db_select'])) {
 473             $_REQUEST['db_select'] = implode(",", $_REQUEST['db_select']);
 474         } elseif ($export_type == 'database' && isset($_REQUEST['table_select'])) {
 475             $_REQUEST['table_select'] = implode(",", $_REQUEST['table_select']);
 476         }
 477
 478         foreach ($_REQUEST as $name => $value) {
 479             $back_button .= '&amp;' . urlencode($name) . '=' . urlencode($value);
 480         }
 481         $back_button .= '&amp;repopulate=1">Back</a> ]</p>';
 482
 483         echo $back_button;
 484         echo '    <form name="nofunction">' . "\n"
 485            // remove auto-select for now: there is no way to select
 486            // only a part of the text; anyway, it should obey
 487            // $cfg['TextareaAutoSelect']
 488            //. '        <textarea name="sqldump" cols="50" rows="30" onclick="this.select();" id="textSQLDUMP" wrap="OFF">' . "\n";
 489            . '        <textarea name="sqldump" cols="50" rows="30" id="textSQLDUMP" wrap="OFF">' . "\n";
 490     } // end download
 491 }
 492
 493 // Fake loop just to allow skip of remain of this code by break, I'd really
 494 // need exceptions here :-)
 495 do {
 496
 497     // Add possibly some comments to export
 498     if (! $export_plugin->exportHeader($db)) {
 499         break;
 500     }
 501
 502     // Will we need relation & co. setup?
 503     $do_relation = isset($GLOBALS[$what . '_relation']);
 504     $do_comments = isset($GLOBALS[$what . '_include_comments']);
 505     $do_mime     = isset($GLOBALS[$what . '_mime']);
 506     if ($do_relation || $do_comments || $do_mime) {
 507         $cfgRelation = PMA_getRelationsParam();
 508     }
 509     if ($do_mime) {
 510         include_once 'libraries/transformations.lib.php';
 511     }
 512
 513     // Include dates in export?
 514     $do_dates = isset($GLOBALS[$what . '_dates']);
 515
 516     /**
 517      * Builds the dump
 518      */
 519     // Gets the number of tables if a dump of a database has been required
 520     if ($export_type == 'server') {
 521         if (isset($db_select)) {
 522             $tmp_select = implode($db_select, '|');
 523             $tmp_select = '|' . $tmp_select . '|';
 524         }
 525         // Walk over databases
 526         foreach ($GLOBALS['pma']->databases as $current_db) {
 527             if ((isset($tmp_select)
 528                 && strpos(' ' . $tmp_select, '|' . $current_db . '|'))
 529                 || ! isset($tmp_select)
 530             ) {
 531                 if (! $export_plugin->exportDBHeader($current_db)) {
 532                     break 2;
 533                 }
 534                 if (! $export_plugin->exportDBCreate($current_db)) {
 535                     break 2;
 536                 }
 537                 if (method_exists($export_plugin, 'exportRoutines')
 538                     && strpos($GLOBALS['sql_structure_or_data'], 'structure') !== false
 539                     && isset($GLOBALS['sql_procedure_function'])
 540                 ) {
 541                     $export_plugin->exportRoutines($current_db);
 542                 }
 543
 544                 $tables = PMA_DBI_get_tables($current_db);
 545                 $views = array();
 546                 foreach ($tables as $table) {
 547                     // if this is a view, collect it for later;
 548                     // views must be exported after the tables
 549                     $is_view = PMA_Table::isView($current_db, $table);
 550                     if ($is_view) {
 551                         $views[] = $table;
 552                     }
 553                     if ($GLOBALS[$what . '_structure_or_data'] == 'structure'
 554                         || $GLOBALS[$what . '_structure_or_data'] == 'structure_and_data'
 555                     ) {
 556                         // for a view, export a stand-in definition of the table
 557                         // to resolve view dependencies
 558                         if (! $export_plugin->exportStructure(
 559                             $current_db, $table, $crlf, $err_url,
 560                             $is_view ? 'stand_in' : 'create_table', $export_type,
 561                             $do_relation, $do_comments, $do_mime, $do_dates
 562                         )) {
 563                             break 3;
 564                         }
 565                     }
 566                     // if this is a view or a merge table, don't export data
 567                     if (($GLOBALS[$what . '_structure_or_data'] == 'data'
 568                         || $GLOBALS[$what . '_structure_or_data'] == 'structure_and_data')
 569                         && ! ($is_view || PMA_Table::isMerge($current_db, $table))
 570                     ) {
 571                         $local_query  = 'SELECT * FROM ' . PMA_Util::backquote($current_db)
 572                             . '.' . PMA_Util::backquote($table);
 573                         if (! $export_plugin->exportData($current_db, $table, $crlf, $err_url, $local_query)) {
 574                             break 3;
 575                         }
 576                     }
 577                     // now export the triggers (needs to be done after the data
 578                     // because triggers can modify already imported tables)
 579                     if ($GLOBALS[$what . '_structure_or_data'] == 'structure'
 580                         || $GLOBALS[$what . '_structure_or_data'] == 'structure_and_data'
 581                     ) {
 582                         if (! $export_plugin->exportStructure(
 583                             $current_db, $table, $crlf, $err_url,
 584                             'triggers', $export_type,
 585                             $do_relation, $do_comments, $do_mime, $do_dates
 586                         )) {
 587                             break 2;
 588                         }
 589                     }
 590                 }
 591                 foreach ($views as $view) {
 592                     // no data export for a view
 593                     if ($GLOBALS[$what . '_structure_or_data'] == 'structure'
 594                         || $GLOBALS[$what . '_structure_or_data'] == 'structure_and_data'
 595                     ) {
 596                         if (! $export_plugin->exportStructure(
 597                             $current_db, $view, $crlf, $err_url,
 598                             'create_view', $export_type,
 599                             $do_relation, $do_comments, $do_mime, $do_dates
 600                         )) {
 601                             break 3;
 602                         }
 603                     }
 604                 }
 605                 if (! $export_plugin->exportDBFooter($current_db)) {
 606                     break 2;
 607                 }
 608             }
 609         }
 610     } elseif ($export_type == 'database') {
 611         if (! $export_plugin->exportDBHeader($db)) {
 612             break;
 613         }
 614
 615         if (method_exists($export_plugin, 'exportRoutines')
 616             && strpos($GLOBALS['sql_structure_or_data'], 'structure') !== false
 617             && isset($GLOBALS['sql_procedure_function'])
 618         ) {
 619             $export_plugin->exportRoutines($db);
 620         }
 621
 622         $i = 0;
 623         $views = array();
 624         // $tables contains the choices from the user (via $table_select)
 625         foreach ($tables as $table) {
 626             // if this is a view, collect it for later; views must be exported after
 627             // the tables
 628             $is_view = PMA_Table::isView($db, $table);
 629             if ($is_view) {
 630                 $views[] = $table;
 631             }
 632             if ($GLOBALS[$what . '_structure_or_data'] == 'structure'
 633                 || $GLOBALS[$what . '_structure_or_data'] == 'structure_and_data'
 634             ) {
 635                 // for a view, export a stand-in definition of the table
 636                 // to resolve view dependencies
 637                 if (! $export_plugin->exportStructure(
 638                     $db, $table, $crlf, $err_url,
 639                     $is_view ? 'stand_in' : 'create_table', $export_type,
 640                     $do_relation, $do_comments, $do_mime, $do_dates
 641                 )) {
 642                     break 2;
 643                 }
 644             }
 645             // if this is a view or a merge table, don't export data
 646             if (($GLOBALS[$what . '_structure_or_data'] == 'data'
 647                 || $GLOBALS[$what . '_structure_or_data'] == 'structure_and_data')
 648                 && ! ($is_view || PMA_Table::isMerge($db, $table))
 649             ) {
 650                 $local_query  = 'SELECT * FROM ' . PMA_Util::backquote($db)
 651                     . '.' . PMA_Util::backquote($table);
 652                 if (! $export_plugin->exportData($db, $table, $crlf, $err_url, $local_query)) {
 653                     break 2;
 654                 }
 655             }
 656             // now export the triggers (needs to be done after the data because
 657             // triggers can modify already imported tables)
 658             if ($GLOBALS[$what . '_structure_or_data'] == 'structure'
 659                 || $GLOBALS[$what . '_structure_or_data'] == 'structure_and_data'
 660             ) {
 661                 if (! $export_plugin->exportStructure(
 662                     $db, $table, $crlf, $err_url,
 663                     'triggers', $export_type,
 664                     $do_relation, $do_comments, $do_mime, $do_dates
 665                 )) {
 666                     break 2;
 667                 }
 668             }
 669         }
 670         foreach ($views as $view) {
 671             // no data export for a view
 672             if ($GLOBALS[$what . '_structure_or_data'] == 'structure'
 673                 || $GLOBALS[$what . '_structure_or_data'] == 'structure_and_data'
 674             ) {
 675                 if (! $export_plugin->exportStructure(
 676                     $db, $view, $crlf, $err_url,
 677                     'create_view', $export_type,
 678                     $do_relation, $do_comments, $do_mime, $do_dates
 679                 )) {
 680                     break 2;
 681                 }
 682             }
 683         }
 684
 685         if (! $export_plugin->exportDBFooter($db)) {
 686             break;
 687         }
 688     } else {
 689         if (! $export_plugin->exportDBHeader($db)) {
 690             break;
 691         }
 692         // We export just one table
 693         // $allrows comes from the form when "Dump all rows" has been selected
 694         if (isset($allrows) && $allrows == '0' && $limit_to > 0 && $limit_from >= 0) {
 695             $add_query  = ' LIMIT '
 696                         . (($limit_from > 0) ? $limit_from . ', ' : '')
 697                         . $limit_to;
 698         } else {
 699             $add_query  = '';
 700         }
 701
 702         $is_view = PMA_Table::isView($db, $table);
 703         if ($GLOBALS[$what . '_structure_or_data'] == 'structure'
 704             || $GLOBALS[$what . '_structure_or_data'] == 'structure_and_data'
 705         ) {
 706             if (! $export_plugin->exportStructure(
 707                 $db, $table, $crlf, $err_url,
 708                 $is_view ? 'create_view' : 'create_table', $export_type,
 709                 $do_relation, $do_comments, $do_mime, $do_dates
 710             )) {
 711                 break;
 712             }
 713         }
 714         // If this is an export of a single view, we have to export data;
 715         // for example, a PDF report
 716         // if it is a merge table, no data is exported
 717         if (($GLOBALS[$what . '_structure_or_data'] == 'data'
 718             || $GLOBALS[$what . '_structure_or_data'] == 'structure_and_data')
 719             && ! PMA_Table::isMerge($db, $table)
 720         ) {
 721             if (! empty($sql_query)) {
 722                 // only preg_replace if needed
 723                 if (! empty($add_query)) {
 724                     // remove trailing semicolon before adding a LIMIT
 725                     $sql_query = preg_replace('%;\s*$%', '', $sql_query);
 726                 }
 727                 $local_query = $sql_query . $add_query;
 728                 PMA_DBI_select_db($db);
 729             } else {
 730                 $local_query  = 'SELECT * FROM ' . PMA_Util::backquote($db)
 731                     . '.' . PMA_Util::backquote($table) . $add_query;
 732             }
 733             if (! $export_plugin->exportData($db, $table, $crlf, $err_url, $local_query)) {
 734                 break;
 735             }
 736         }
 737         // now export the triggers (needs to be done after the data because
 738         // triggers can modify already imported tables)
 739         if ($GLOBALS[$what . '_structure_or_data'] == 'structure'
 740             || $GLOBALS[$what . '_structure_or_data'] == 'structure_and_data'
 741         ) {
 742             if (! $export_plugin->exportStructure(
 743                 $db, $table, $crlf, $err_url,
 744                 'triggers', $export_type,
 745                 $do_relation, $do_comments, $do_mime, $do_dates
 746             )) {
 747                 break 2;
 748             }
 749         }
 750         if (! $export_plugin->exportDBFooter($db)) {
 751             break;
 752         }
 753     }
 754     if (! $export_plugin->exportFooter()) {
 755         break;
 756     }
 757
 758 } while (false);
 759 // End of fake loop
 760
 761 if ($save_on_server && isset($message)) {
 762     if ($export_type == 'server') {
 763         $active_page = 'server_export.php';
 764         include 'server_export.php';
 765     } elseif ($export_type == 'database') {
 766         $active_page = 'db_export.php';
 767         include 'db_export.php';
 768     } else {
 769         $active_page = 'tbl_export.php';
 770         include 'tbl_export.php';
 771     }
 772     exit();
 773 }
 774
 775 /**
 776  * Send the dump as a file...
 777  */
 778 if (! empty($asfile)) {
 779     // Convert the charset if required.
 780     if ($output_charset_conversion) {
 781         $dump_buffer = PMA_convert_string(
 782             'utf-8',
 783             $GLOBALS['charset_of_file'],
 784             $dump_buffer
 785         );
 786     }
 787
 788     // Do the compression
 789     // 1. as a zipped file
 790     if ($compression == 'zip') {
 791         if (@function_exists('gzcompress')) {
 792             $zipfile = new ZipFile();
 793             $zipfile->addFile($dump_buffer, substr($filename, 0, -4));
 794             $dump_buffer = $zipfile->file();
 795         }
 796     } elseif ($compression == 'bzip2') {
 797         // 2. as a bzipped file
 798         if (@function_exists('bzcompress')) {
 799             $dump_buffer = bzcompress($dump_buffer);
 800         }
 801     } elseif ($compression == 'gzip' && PMA_gzencodeNeeded()) {
 802         // 3. as a gzipped file
 803         // without the optional parameter level because it bugs
 804             $dump_buffer = gzencode($dump_buffer);
 805     }
 806
 807     /* If we saved on server, we have to close file now */
 808     if ($save_on_server) {
 809         $write_result = @fwrite($file_handle, $dump_buffer);
 810         fclose($file_handle);
 811         if (strlen($dump_buffer) > 0
 812             && (! $write_result || ($write_result != strlen($dump_buffer)))
 813         ) {
 814             $message = new PMA_Message(
 815                 __('Insufficient space to save the file %s.'),
 816                 PMA_Message::ERROR,
 817                 $save_filename
 818             );
 819         } else {
 820             $message = new PMA_Message(
 821                 __('Dump has been saved to file %s.'),
 822                 PMA_Message::SUCCESS,
 823                 $save_filename
 824             );
 825         }
 826
 827         if ($export_type == 'server') {
 828             $active_page = 'server_export.php';
 829             include_once 'server_export.php';
 830         } elseif ($export_type == 'database') {
 831             $active_page = 'db_export.php';
 832             include_once 'db_export.php';
 833         } else {
 834             $active_page = 'tbl_export.php';
 835             include_once 'tbl_export.php';
 836         }
 837         exit();
 838     } else {
 839         PMA_Response::getInstance()->disable();
 840         echo $dump_buffer;
 841     }
 842 } else {
 843     /**
 844      * Displays the dump...
 845      *
 846      * Close the html tags and add the footers if dump is displayed on screen
 847      */
 848     echo '</textarea>' . "\n"
 849        . '    </form>' . "\n";
 850     echo $back_button;
 851
 852     echo "\n";
 853     echo '</div>' . "\n";
 854     echo "\n";
 855 ?>
 856 <script type="text/javascript">
 857 //<![CDATA[
 858     var $body = $("body");
 859     $("#textSQLDUMP")
 860         .width($body.width() - 50)
 861         .height($body.height() - 100);
 862 //]]>
 863 </script>
 864 <?php
 865 } // end if
 866 ?>