Translated using Weblate (Bulgarian)

[phpmyadmin.git] / export.php

<?php
/* vim: set expandtab sw=4 ts=4 sts=4: */
/**
 * Main export handling code
 *
 * @package PhpMyAdmin
 */

/**
 * Get the variables sent or posted to this script and a core script
 */
if (!defined('TESTSUITE')) {
    /**
     * If we are sending the export file (as opposed to just displaying it
     * as text), we have to bypass the usual PMA_Response mechanism
     */
    if (isset($_POST['output_format']) && $_POST['output_format'] == 'sendit') {
        define('PMA_BYPASS_GET_INSTANCE', 1);
    }
    include_once 'libraries/common.inc.php';
    include_once 'libraries/zip.lib.php';
    include_once 'libraries/plugin_interface.lib.php';

    //check if it's the GET request to check export time out
    if (isset($_GET['check_time_out'])) {
        if (isset($_SESSION['pma_export_error'])) {
            $err = $_SESSION['pma_export_error'];
            unset($_SESSION['pma_export_error']);
            echo $err;
        } else {
            echo "success";
        }
        exit;
    }
    /**
     * Sets globals from $_POST
     *
     * - Please keep the parameters in order of their appearance in the form
     * - Some of these parameters are not used, as the code below directly
     *   verifies from the superglobal $_POST or $_REQUEST
     */
    $post_params = array(
            'db',
            'table',
            'single_table',
            'export_type',
            'export_method',
            'quick_or_custom',
            'db_select',
            'table_select',
            'limit_to',
            'limit_from',
            'allrows',
            'output_format',
            'filename_template',
            'remember_template',
            'charset_of_file',
            'compression',
            'what',
            'knjenc',
            'xkana',
            'htmlword_structure_or_data',
            'htmlword_null',
            'htmlword_columns',
            'mediawiki_structure_or_data',
            'mediawiki_caption',
            'pdf_report_title',
            'pdf_structure_or_data',
            'odt_structure_or_data',
            'odt_relation',
            'odt_comments',
            'odt_mime',
            'odt_columns',
            'odt_null',
            'codegen_structure_or_data',
            'codegen_format',
            'excel_null',
            'excel_removeCRLF',
            'excel_columns',
            'excel_edition',
            'excel_structure_or_data',
            'yaml_structure_or_data',
            'ods_null',
            'ods_structure_or_data',
            'ods_columns',
            'json_structure_or_data',
            'xml_structure_or_data',
            'xml_export_functions',
            'xml_export_procedures',
            'xml_export_tables',
            'xml_export_triggers',
            'xml_export_views',
            'xml_export_contents',
            'texytext_structure_or_data',
            'texytext_columns',
            'texytext_null',
            'phparray_structure_or_data',
            'sql_include_comments',
            'sql_header_comment',
            'sql_dates',
            'sql_relation',
            'sql_mime',
            'sql_use_transaction',
            'sql_disable_fk',
            'sql_compatibility',
            'sql_structure_or_data',
            'sql_create_database',
            'sql_drop_table',
            'sql_procedure_function',
            'sql_create_table_statements',
            'sql_if_not_exists',
            'sql_auto_increment',
            'sql_backquotes',
            'sql_truncate',
            'sql_delayed',
            'sql_ignore',
            'sql_type',
            'sql_insert_syntax',
            'sql_max_query_size',
            'sql_hex_for_blob',
            'sql_utc_time',
            'sql_drop_database',
            'csv_separator',
            'csv_enclosed',
            'csv_escaped',
            'csv_terminated',
            'csv_null',
            'csv_removeCRLF',
            'csv_columns',
            'csv_structure_or_data',
            // csv_replace should have been here but we use it directly from $_POST
            'latex_caption',
            'latex_structure_or_data',
            'latex_structure_caption',
            'latex_structure_continued_caption',
            'latex_structure_label',
            'latex_relation',
            'latex_comments',
            'latex_mime',
            'latex_columns',
            'latex_data_caption',
            'latex_data_continued_caption',
            'latex_data_label',
            'latex_null'
    );

    foreach ($post_params as $one_post_param) {
        if (isset($_POST[$one_post_param])) {
            $GLOBALS[$one_post_param] = $_POST[$one_post_param];
        }
    }

    // sanitize this parameter which will be used below in a file inclusion
    $what = PMA_securePath($what);

    PMA_Util::checkParameters(array('what', 'export_type'));

    // export class instance, not array of properties, as before
    $export_plugin = PMA_getPlugin(
        "export",
        $what,
        'libraries/plugins/export/',
        array(
            'export_type' => $export_type,
            'single_table' => isset($single_table)
        )
    );

    // Backward compatbility
    $type = $what;

    // Check export type
    if (! isset($export_plugin)) {
        PMA_fatalError(__('Bad type!'));
    }

    /**
     * valid compression methods
     */
    $compression_methods = array(
        'zip',
        'gzip'
    );

    /**
     * init and variable checking
     */
    $compression = false;
    $onserver = false;
    $save_on_server = false;
    $buffer_needed = false;

    // Is it a quick or custom export?
    if ($_REQUEST['quick_or_custom'] == 'quick') {
        $quick_export = true;
    } else {
        $quick_export = false;
    }

    if ($_REQUEST['output_format'] == 'astext') {
        $asfile = false;
    } else {
        $asfile = true;
        if (in_array($_REQUEST['compression'], $compression_methods)) {
            $compression = $_REQUEST['compression'];
            $buffer_needed = true;
        }
        if (($quick_export && ! empty($_REQUEST['quick_export_onserver']))
            || (! $quick_export && ! empty($_REQUEST['onserver']))
        ) {
            if ($quick_export) {
                $onserver = $_REQUEST['quick_export_onserver'];
            } else {
                $onserver = $_REQUEST['onserver'];
            }
            // Will we save dump on server?
            $save_on_server = ! empty($cfg['SaveDir']) && $onserver;
        }
    }

    // Does export require to be into file?
    if ($export_plugin->getProperties()->getForceFile() != null && ! $asfile) {
        $message = PMA_Message::error(
            __('Selected export type has to be saved in file!')
        );
        if ($export_type == 'server') {
            $active_page = 'server_export.php';
            include 'server_export.php';
        } elseif ($export_type == 'database') {
            $active_page = 'db_export.php';
            include 'db_export.php';
        } else {
            $active_page = 'tbl_export.php';
            include 'tbl_export.php';
        }
        exit();
    }

    // Generate error url and check for needed variables
    if ($export_type == 'server') {
        $err_url = 'server_export.php?' . PMA_URL_getCommon();
    } elseif ($export_type == 'database' && strlen($db)) {
        $err_url = 'db_export.php?' . PMA_URL_getCommon($db);
        // Check if we have something to export
        if (isset($table_select)) {
            $tables = $table_select;
        } else {
            $tables = array();
        }
    } elseif ($export_type == 'table' && strlen($db) && strlen($table)) {
        $err_url = 'tbl_export.php?' . PMA_URL_getCommon($db, $table);
    } else {
        PMA_fatalError(__('Bad parameters!'));
    }

    /**
     * Increase time limit for script execution and initializes some variables
     */
    @set_time_limit($cfg['ExecTimeLimit']);
    if (! empty($cfg['MemoryLimit'])) {
        @ini_set('memory_limit', $cfg['MemoryLimit']);
    }
    register_shutdown_function('PMA_shutdown');
    // Start with empty buffer
    $dump_buffer = '';
    $dump_buffer_len = 0;

    // We send fake headers to avoid browser timeout when buffering
    $time_start = time();
}

/**
 * Sets a session variable upon a possible fatal error during export
 *
 * @return void
 */
function PMA_shutdown()
{
    $a = error_get_last();
    if ($a != null && strpos($a['message'], "execution time")) {
        //write in partially downloaded file for future reference of user
        print_r($a);
        //set session variable to check if there was error while exporting
        $_SESSION['pma_export_error'] = $a['message'];
    }
}
/**
 * Detect ob_gzhandler
 *
 * @return bool
 */
function PMA_isGzHandlerEnabled()
{
    return in_array('ob_gzhandler', ob_list_handlers());
}

/**
 * Detect whether gzencode is needed; it might not be needed if
 * the server is already compressing by itself
 *
 * @return bool Whether gzencode is needed
 */
function PMA_gzencodeNeeded()
{
    /*
     * We should gzencode only if the function exists
     * but we don't want to compress twice, therefore
     * gzencode only if transparent compression is not enabled
     * and gz compression was not asked via $cfg['OBGzip']
     * but transparent compression does not apply when saving to server
     */
    if (@function_exists('gzencode')
        && ((! @ini_get('zlib.output_compression')
        && ! PMA_isGzHandlerEnabled())
        || $GLOBALS['save_on_server'])
    ) {
        return true;
    } else {
        return false;
    }
}

/**
 * Output handler for all exports, if needed buffering, it stores data into
 * $dump_buffer, otherwise it prints thems out.
 *
 * @param string $line the insert statement
 *
 * @return bool Whether output succeeded
 */
function PMA_exportOutputHandler($line)
{
    global $time_start, $dump_buffer, $dump_buffer_len, $save_filename;

    // Kanji encoding convert feature
    if ($GLOBALS['output_kanji_conversion']) {
        $line = PMA_Kanji_strConv(
            $line,
            $GLOBALS['knjenc'],
            isset($GLOBALS['xkana']) ? $GLOBALS['xkana'] : ''
        );
    }
    // If we have to buffer data, we will perform everything at once at the end
    if ($GLOBALS['buffer_needed']) {

        $dump_buffer .= $line;
        if ($GLOBALS['onfly_compression']) {

            $dump_buffer_len += strlen($line);

            if ($dump_buffer_len > $GLOBALS['memory_limit']) {
                if ($GLOBALS['output_charset_conversion']) {
                    $dump_buffer = PMA_convertString(
                        'utf-8',
                        $GLOBALS['charset_of_file'],
                        $dump_buffer
                    );
                }
                if ($GLOBALS['compression'] == 'gzip'
                    && PMA_gzencodeNeeded()
                ) {
                    // as a gzipped file
                    // without the optional parameter level because it bugs
                    $dump_buffer = gzencode($dump_buffer);
                }
                if ($GLOBALS['save_on_server']) {
                    $write_result = @fwrite($GLOBALS['file_handle'], $dump_buffer);
                    if ($write_result != strlen($dump_buffer)) {
                        $GLOBALS['message'] = PMA_Message::error(
                            __('Insufficient space to save the file %s.')
                        );
                        $GLOBALS['message']->addParam($save_filename);
                        return false;
                    }
                } else {
                    echo $dump_buffer;
                }
                $dump_buffer = '';
                $dump_buffer_len = 0;
            }
        } else {
            $time_now = time();
            if ($time_start >= $time_now + 30) {
                $time_start = $time_now;
                header('X-pmaPing: Pong');
            } // end if
        }
    } else {
        if ($GLOBALS['asfile']) {
            if ($GLOBALS['output_charset_conversion']) {
                $line = PMA_convertString(
                    'utf-8',
                    $GLOBALS['charset_of_file'],
                    $line
                );
            }
            if ($GLOBALS['save_on_server'] && strlen($line) > 0) {
                $write_result = @fwrite($GLOBALS['file_handle'], $line);
                if (! $write_result || ($write_result != strlen($line))) {
                    $GLOBALS['message'] = PMA_Message::error(
                        __('Insufficient space to save the file %s.')
                    );
                    $GLOBALS['message']->addParam($save_filename);
                    return false;
                }
                $time_now = time();
                if ($time_start >= $time_now + 30) {
                    $time_start = $time_now;
                    header('X-pmaPing: Pong');
                } // end if
            } else {
                // We export as file - output normally
                echo $line;
            }
        } else {
            // We export as html - replace special chars
            echo htmlspecialchars($line);
        }
    }
    return true;
} // end of the 'PMA_exportOutputHandler()' function

// Defines the default <CR><LF> format.
// For SQL always use \n as MySQL wants this on all platforms.
if (!defined('TESTSUITE')) {
    if ($what == 'sql') {
        $crlf = "\n";
    } else {
        $crlf = PMA_Util::whichCrlf();
    }

    $output_kanji_conversion = function_exists('PMA_Kanji_strConv')
        && $type != 'xls';

    // Do we need to convert charset?
    $output_charset_conversion = $asfile
        && $GLOBALS['PMA_recoding_engine'] != PMA_CHARSET_NONE
        && isset($charset_of_file) && $charset_of_file != 'utf-8'
        && $type != 'xls';

    // Use on the fly compression?
    $onfly_compression = $GLOBALS['cfg']['CompressOnFly']
        && $compression == 'gzip';
    if ($onfly_compression) {
        $memory_limit = trim(@ini_get('memory_limit'));
        $memory_limit_num = (int)substr($memory_limit, 0, -1);
        // 2 MB as default
        if (empty($memory_limit) || '-1' == $memory_limit) {
            $memory_limit = 2 * 1024 * 1024;
        } elseif (strtolower(substr($memory_limit, -1)) == 'm') {
            $memory_limit = $memory_limit_num * 1024 * 1024;
        } elseif (strtolower(substr($memory_limit, -1)) == 'k') {
            $memory_limit = $memory_limit_num * 1024;
        } elseif (strtolower(substr($memory_limit, -1)) == 'g') {
            $memory_limit = $memory_limit_num * 1024 * 1024 * 1024;
        } else {
            $memory_limit = (int)$memory_limit;
        }

        // Some of memory is needed for other things and as threshold.
        // During export I had allocated (see memory_get_usage function)
        // approx 1.2MB so this comes from that.
        if ($memory_limit > 1500000) {
            $memory_limit -= 1500000;
        }

        // Some memory is needed for compression, assume 1/3
        $memory_limit /= 8;
    }

    // Generate filename and mime type if needed
    if ($asfile) {
        $pma_uri_parts = parse_url($cfg['PmaAbsoluteUri']);
        if ($export_type == 'server') {
            if (isset($remember_template)) {
                $GLOBALS['PMA_Config']->setUserValue(
                    'pma_server_filename_template',
                    'Export/file_template_server',
                    $filename_template
                );
            }
        } elseif ($export_type == 'database') {
            if (isset($remember_template)) {
                $GLOBALS['PMA_Config']->setUserValue(
                    'pma_db_filename_template',
                    'Export/file_template_database',
                    $filename_template
                );
            }
        } else {
            if (isset($remember_template)) {
                $GLOBALS['PMA_Config']->setUserValue(
                    'pma_table_filename_template',
                    'Export/file_template_table',
                    $filename_template
                );
            }
        }
        $filename = PMA_Util::expandUserString($filename_template);
        // remove dots in filename (coming from either the template or already
        // part of the filename) to avoid a remote code execution vulnerability
        $filename = PMA_sanitizeFilename($filename, $replaceDots = true);

        // Grab basic dump extension and mime type
        // Check if the user already added extension;
        // get the substring where the extension would be if it was included
        $extension_start_pos = strlen($filename) - strlen(
            $export_plugin->getProperties()->getExtension()
        ) - 1;
        $user_extension = substr($filename, $extension_start_pos, strlen($filename));
        $required_extension = "." . $export_plugin->getProperties()->getExtension();
        if (strtolower($user_extension) != $required_extension) {
            $filename  .= $required_extension;
        }
        $mime_type  = $export_plugin->getProperties()->getMimeType();

        // If dump is going to be compressed, set correct mime_type and add
        // compression to extension
        if ($compression == 'gzip') {
            $filename  .= '.gz';
            $mime_type = 'application/x-gzip';
        } elseif ($compression == 'zip') {
            $filename  .= '.zip';
            $mime_type = 'application/zip';
        }
    }

    // Open file on server if needed
    if ($save_on_server) {
        $save_filename = PMA_Util::userDir($cfg['SaveDir'])
            . preg_replace('@[/\\\\]@', '_', $filename);
        unset($message);
        if (file_exists($save_filename)
            && ((! $quick_export && empty($_REQUEST['onserverover']))
            || ($quick_export
            && $_REQUEST['quick_export_onserverover'] != 'saveitover'))
        ) {
            $message = PMA_Message::error(
                __(
                    'File %s already exists on server, '
                    . 'change filename or check overwrite option.'
                )
            );
            $message->addParam($save_filename);
        } else {
            if (is_file($save_filename) && ! is_writable($save_filename)) {
                $message = PMA_Message::error(
                    __(
                        'The web server does not have permission '
                        . 'to save the file %s.'
                    )
                );
                $message->addParam($save_filename);
            } else {
                if (! $file_handle = @fopen($save_filename, 'w')) {
                    $message = PMA_Message::error(
                        __(
                            'The web server does not have permission '
                            . 'to save the file %s.'
                        )
                    );
                    $message->addParam($save_filename);
                }
            }
        }
        if (isset($message)) {
            if ($export_type == 'server') {
                $active_page = 'server_export.php';
                include 'server_export.php';
            } elseif ($export_type == 'database') {
                $active_page = 'db_export.php';
                include 'db_export.php';
            } else {
                $active_page = 'tbl_export.php';
                include 'tbl_export.php';
            }
            exit();
        }
    }

    /**
     * Send headers depending on whether the user chose to download a dump file
     * or not
     */
    if (! $save_on_server) {
        if ($asfile) {
            // Download
            // (avoid rewriting data containing HTML with anchors and forms;
            // this was reported to happen under Plesk)
            @ini_set('url_rewriter.tags', '');
            $filename = PMA_sanitizeFilename($filename);

            PMA_downloadHeader($filename, $mime_type);
        } else {
            // HTML
            if ($export_type == 'database') {
                $num_tables = count($tables);
                if ($num_tables == 0) {
                    $message = PMA_Message::error(
                        __('No tables found in database.')
                    );
                    $active_page = 'db_export.php';
                    include 'db_export.php';
                    exit();
                }
            }
            $backup_cfgServer = $cfg['Server'];
            $cfg['Server'] = $backup_cfgServer;
            unset($backup_cfgServer);
            echo "\n" . '<div style="text-align: ' . $cell_align_left . '">' . "\n";
            //echo '    <pre>' . "\n";

            /**
             * Displays a back button with all the $_REQUEST data in the URL
             * (store in a variable to also display after the textarea)
             */
            $back_button = '<p>[ <a href="';
            if ($export_type == 'server') {
                $back_button .= 'server_export.php?' . PMA_URL_getCommon();
            } elseif ($export_type == 'database') {
                $back_button .= 'db_export.php?' . PMA_URL_getCommon($db);
            } else {
                $back_button .= 'tbl_export.php?' . PMA_URL_getCommon($db, $table);
            }

            // Convert the multiple select elements from an array to a string
            if ($export_type == 'server' && isset($_REQUEST['db_select'])) {
                $_REQUEST['db_select'] = implode(",", $_REQUEST['db_select']);
            } elseif ($export_type == 'database'
             && isset($_REQUEST['table_select'])
            ) {
                $_REQUEST['table_select'] = implode(",", $_REQUEST['table_select']);
            }

            foreach ($_REQUEST as $name => $value) {
                $back_button .= '&amp;' . urlencode($name) . '=' . urlencode($value);
            }
            $back_button .= '&amp;repopulate=1">Back</a> ]</p>';

            echo $back_button;
            echo '<form name="nofunction">' . "\n";
            echo '<textarea name="sqldump" cols="50" rows="30" '
                . 'id="textSQLDUMP" wrap="OFF">' . "\n";
        } // end download
    }

    // Fake loop just to allow skip of remain of this code by break, I'd really
    // need exceptions here :-)
    do {

        // Add possibly some comments to export
        if (! $export_plugin->exportHeader($db)) {
            break;
        }

        // Will we need relation & co. setup?
        $do_relation = isset($GLOBALS[$what . '_relation']);
        $do_comments = isset($GLOBALS[$what . '_include_comments'])
            || isset($GLOBALS[$what . '_comments']) ;
        $do_mime     = isset($GLOBALS[$what . '_mime']);
        if ($do_relation || $do_comments || $do_mime) {
            $cfgRelation = PMA_getRelationsParam();
        }
        if ($do_mime) {
            include_once 'libraries/transformations.lib.php';
        }

        // Include dates in export?
        $do_dates = isset($GLOBALS[$what . '_dates']);

        $whatStrucOrData = $GLOBALS[$what . '_structure_or_data'];

        /**
         * Builds the dump
         */
        // Gets the number of tables if a dump of a database has been required
        if ($export_type == 'server') {
            if (isset($db_select)) {
                $tmp_select = implode($db_select, '|');
                $tmp_select = '|' . $tmp_select . '|';
            }
            // Walk over databases
            foreach ($GLOBALS['pma']->databases as $current_db) {
                if (isset($tmp_select)
                    && strpos(' ' . $tmp_select, '|' . $current_db . '|')
                ) {
                    if (! $export_plugin->exportDBHeader($current_db)) {
                        break 2;
                    }
                    if (! $export_plugin->exportDBCreate($current_db)) {
                        break 2;
                    }
                    if (method_exists($export_plugin, 'exportRoutines')
                        && strpos($whatStrucOrData, 'structure') !== false
                        && isset($GLOBALS['sql_procedure_function'])
                    ) {
                        $export_plugin->exportRoutines($current_db);
                    }

                    $tables = $GLOBALS['dbi']->getTables($current_db);
                    $views = array();
                    foreach ($tables as $table) {
                        // if this is a view, collect it for later;
                        // views must be exported after the tables
                        $is_view = PMA_Table::isView($current_db, $table);
                        if ($is_view) {
                            $views[] = $table;
                        }
                        if ($whatStrucOrData == 'structure'
                            || $whatStrucOrData == 'structure_and_data'
                        ) {
                            // for a view, export a stand-in definition of the table
                            // to resolve view dependencies
                            if (! $export_plugin->exportStructure(
                                $current_db, $table, $crlf, $err_url,
                                $is_view ? 'stand_in' : 'create_table', $export_type,
                                $do_relation, $do_comments, $do_mime, $do_dates
                            )) {
                                break 3;
                            }
                        }
                        // if this is a view or a merge table, don't export data
                        if (($whatStrucOrData == 'data'
                            || $whatStrucOrData == 'structure_and_data')
                            && ! ($is_view || PMA_Table::isMerge($current_db, $table))
                        ) {
                            $local_query  = 'SELECT * FROM '
                                . PMA_Util::backquote($current_db)
                                . '.' . PMA_Util::backquote($table);
                            if (! $export_plugin->exportData(
                                $current_db, $table, $crlf, $err_url, $local_query
                            )) {
                                break 3;
                            }
                        }
                        // now export the triggers (needs to be done after the data
                        // because triggers can modify already imported tables)
                        if ($whatStrucOrData == 'structure'
                            || $whatStrucOrData == 'structure_and_data'
                        ) {
                            if (! $export_plugin->exportStructure(
                                $current_db, $table, $crlf, $err_url,
                                'triggers', $export_type,
                                $do_relation, $do_comments, $do_mime, $do_dates
                            )) {
                                break 2;
                            }
                        }
                    }
                    foreach ($views as $view) {
                        // no data export for a view
                        if ($whatStrucOrData == 'structure'
                            || $whatStrucOrData == 'structure_and_data'
                        ) {
                            if (! $export_plugin->exportStructure(
                                $current_db, $view, $crlf, $err_url,
                                'create_view', $export_type,
                                $do_relation, $do_comments, $do_mime, $do_dates
                            )) {
                                break 3;
                            }
                        }
                    }
                    if (! $export_plugin->exportDBFooter($current_db)) {
                        break 2;
                    }
                }
            }
        } elseif ($export_type == 'database') {
            if (! $export_plugin->exportDBHeader($db)) {
                break;
            }
            if (! $export_plugin->exportDBCreate($db)) {
                break;
            }

            if (method_exists($export_plugin, 'exportRoutines')
                && strpos($GLOBALS['sql_structure_or_data'], 'structure') !== false
                && isset($GLOBALS['sql_procedure_function'])
            ) {
                $export_plugin->exportRoutines($db);
            }

            $i = 0;
            $views = array();

            // $tables contains the choices from the user (via $table_select)
            foreach ($tables as $table) {
                // if this is a view, collect it for later;
                // views must be exported after the tables
                $is_view = PMA_Table::isView($db, $table);
                if ($is_view) {
                    $views[] = $table;
                }
                if ($whatStrucOrData == 'structure'
                    || $whatStrucOrData == 'structure_and_data'
                ) {
                    // for a view, export a stand-in definition of the table
                    // to resolve view dependencies
                    if (! $export_plugin->exportStructure(
                        $db, $table, $crlf, $err_url,
                        $is_view ? 'stand_in' : 'create_table', $export_type,
                        $do_relation, $do_comments, $do_mime, $do_dates
                    )) {
                        break 2;
                    }
                }
                // if this is a view or a merge table, don't export data
                if (($whatStrucOrData == 'data'
                    || $whatStrucOrData == 'structure_and_data')
                    && ! ($is_view || PMA_Table::isMerge($db, $table))
                ) {
                    $local_query  = 'SELECT * FROM ' . PMA_Util::backquote($db)
                        . '.' . PMA_Util::backquote($table);
                    if (! $export_plugin->exportData(
                        $db, $table, $crlf, $err_url, $local_query
                    )) {
                        break 2;
                    }
                }
                // now export the triggers (needs to be done after the data because
                // triggers can modify already imported tables)
                if ($whatStrucOrData == 'structure'
                    || $whatStrucOrData == 'structure_and_data'
                ) {
                    if (! $export_plugin->exportStructure(
                        $db, $table, $crlf, $err_url,
                        'triggers', $export_type,
                        $do_relation, $do_comments, $do_mime, $do_dates
                    )) {
                        break 2;
                    }
                }
            }
            foreach ($views as $view) {
                // no data export for a view
                if ($whatStrucOrData == 'structure'
                    || $whatStrucOrData == 'structure_and_data'
                ) {
                    if (! $export_plugin->exportStructure(
                        $db, $view, $crlf, $err_url,
                        'create_view', $export_type,
                        $do_relation, $do_comments, $do_mime, $do_dates
                    )) {
                        break 2;
                    }
                }
            }

            if (! $export_plugin->exportDBFooter($db)) {
                break;
            }
        } else {
            if (! $export_plugin->exportDBHeader($db)) {
                break;
            }
            // We export just one table
            // $allrows comes from the form when "Dump all rows" has been selected
            if (isset($allrows)
                && $allrows == '0'
                && $limit_to > 0
                && $limit_from >= 0
            ) {
                $add_query  = ' LIMIT '
                            . (($limit_from > 0) ? $limit_from . ', ' : '')
                            . $limit_to;
            } else {
                $add_query  = '';
            }

            $is_view = PMA_Table::isView($db, $table);
            if ($whatStrucOrData == 'structure'
                || $whatStrucOrData == 'structure_and_data'
            ) {
                if (! $export_plugin->exportStructure(
                    $db, $table, $crlf, $err_url,
                    $is_view ? 'create_view' : 'create_table', $export_type,
                    $do_relation, $do_comments, $do_mime, $do_dates
                )) {
                    break;
                }
            }
            // If this is an export of a single view, we have to export data;
            // for example, a PDF report
            // if it is a merge table, no data is exported
            if (($whatStrucOrData == 'data'
                || $whatStrucOrData == 'structure_and_data')
                && ! PMA_Table::isMerge($db, $table)
            ) {
                if (! empty($sql_query)) {
                    // only preg_replace if needed
                    if (! empty($add_query)) {
                        // remove trailing semicolon before adding a LIMIT
                        $sql_query = preg_replace('%;\s*$%', '', $sql_query);
                    }
                    $local_query = $sql_query . $add_query;
                    $GLOBALS['dbi']->selectDb($db);
                } else {
                    $local_query  = 'SELECT * FROM ' . PMA_Util::backquote($db)
                        . '.' . PMA_Util::backquote($table) . $add_query;
                }
                if (! $export_plugin->exportData(
                    $db, $table, $crlf, $err_url, $local_query
                )) {
                    break;
                }
            }
            // now export the triggers (needs to be done after the data because
            // triggers can modify already imported tables)
            if ($whatStrucOrData == 'structure'
                || $whatStrucOrData == 'structure_and_data'
            ) {
                if (! $export_plugin->exportStructure(
                    $db, $table, $crlf, $err_url,
                    'triggers', $export_type,
                    $do_relation, $do_comments, $do_mime, $do_dates
                )) {
                    break 2;
                }
            }
            if (! $export_plugin->exportDBFooter($db)) {
                break;
            }
        }
        if (! $export_plugin->exportFooter()) {
            break;
        }

    } while (false);
    // End of fake loop

    if ($save_on_server && isset($message)) {
        if ($export_type == 'server') {
            $active_page = 'server_export.php';
            include 'server_export.php';
        } elseif ($export_type == 'database') {
            $active_page = 'db_export.php';
            include 'db_export.php';
        } else {
            $active_page = 'tbl_export.php';
            include 'tbl_export.php';
        }
        exit();
    }

    /**
     * Send the dump as a file...
     */
    if (! empty($asfile)) {
        // Convert the charset if required.
        if ($output_charset_conversion) {
            $dump_buffer = PMA_convertString(
                'utf-8',
                $GLOBALS['charset_of_file'],
                $dump_buffer
            );
        }

        // Do the compression
        // 1. as a zipped file
        if ($compression == 'zip') {
            if (@function_exists('gzcompress')) {
                $zipfile = new ZipFile();
                $zipfile->addFile($dump_buffer, substr($filename, 0, -4));
                $dump_buffer = $zipfile->file();
            }
        } elseif ($compression == 'gzip' && PMA_gzencodeNeeded()) {
            // 3. as a gzipped file
            // without the optional parameter level because it bugs
                $dump_buffer = gzencode($dump_buffer);
        }

        /* If we saved on server, we have to close file now */
        if ($save_on_server) {
            $write_result = @fwrite($file_handle, $dump_buffer);
            fclose($file_handle);
            if (strlen($dump_buffer) > 0
                && (! $write_result || ($write_result != strlen($dump_buffer)))
            ) {
                $message = new PMA_Message(
                    __('Insufficient space to save the file %s.'),
                    PMA_Message::ERROR,
                    $save_filename
                );
            } else {
                $message = new PMA_Message(
                    __('Dump has been saved to file %s.'),
                    PMA_Message::SUCCESS,
                    $save_filename
                );
            }

            if ($export_type == 'server') {
                $active_page = 'server_export.php';
                include_once 'server_export.php';
            } elseif ($export_type == 'database') {
                $active_page = 'db_export.php';
                include_once 'db_export.php';
            } else {
                $active_page = 'tbl_export.php';
                include_once 'tbl_export.php';
            }
            exit();
        } else {
            echo $dump_buffer;
        }
    } else {
        /**
         * Displays the dump...
         *
         * Close the html tags and add the footers if dump is displayed on screen
         */
        echo '</textarea>' . "\n"
           . '    </form>' . "\n";
        echo $back_button;

        echo "\n";
        echo '</div>' . "\n";
        echo "\n";
        ?>
        <script type="text/javascript">
        //<![CDATA[
            var $body = $("body");
            $("#textSQLDUMP")
                .width($body.width() - 50)
                .height($body.height() - 100);
        //]]>
        </script>
        <?php
    } // end if
}
?>