Empty this root directory except for the package and installer and try again.
Delete just the wp-config.php file and try again. This will over-write all other files in the directory.
');
define('ERR_ZIPNOTFOUND', 'The packaged zip file was not found. Be sure the zip package is in the same directory as the installer file. If you are trying to reinstall a package you can copy the package from the "' . DUPLICATOR_SSDIR_NAME . '" directory back up to your root which is the same location as your installer.php file.');
define('ERR_ZIPOPEN', 'Failed to open zip archive file. Please be sure the archive is completely downloaded before running the installer. Try to extract the archive manually to make sure the file is not corrupted.');
define('ERR_ZIPEXTRACTION', 'Errors extracting zip file. Portions or part of the zip archive did not extract correctly. Try to extract the archive manually with a client side program like unzip/win-zip/winrar to make sure the file is not corrupted. If the file extracts correctly then there is an invalid file or directory that PHP is unable to extract. This can happen if your moving from one operating system to another where certain naming conventions work on one environment and not another.
Workarounds: 1. Create a new package and be sure to exclude any directories that have invalid names or files in them. This warning will be displayed on the scan results under "Invalid Names". 2. Manually extract the zip file with a client side program. Then under advanced options in step 1 of the installer check the "Manual package extraction" option and perform the install.');
define('ERR_ZIPMANUAL', 'When choosing manual package extraction, the contents of the package must already be extracted and the wp-config.php and database.sql files must be present in the same directory as the installer.php for the process to continue. Please manually extract the package into the current directory before continuing in manual extraction mode. Also validate that the wp-config.php and database.sql files are present.');
define('ERR_MAKELOG', 'PHP is having issues writing to the log file ' . DupUtil::set_safe_path($GLOBALS['CURRENT_ROOT_PATH']) . '\installer-log.txt . In order for the Duplicator to proceed validate your owner/group and permission settings for PHP on this path. Try temporarily setting you permissions to 777 to see if the issue gets resolved. If you are on a shared hosting environment please contact your hosting company and tell them you are getting errors writing files to the path above when using PHP.');
define('ERR_ZIPARCHIVE', 'In order to extract the archive.zip file the PHP ZipArchive module must be installed. Please read the FAQ for more details. You can still install this package but you will need to check the Manual package extraction checkbox found in the Advanced Options. Please read the online user guide for details in performing a manual package extraction.');
define('ERR_MYSQLI_SUPPORT', 'In order to complete an install the mysqli extension for PHP is required. If you are on a hosted server please contact your host and request that mysqli be enabled. For more information visit: http://php.net/manual/en/mysqli.installation.php');
define('ERR_DBCONNECT', 'DATABASE CONNECTION FAILED! ');
define('ERR_DBCONNECT_CREATE', 'DATABASE CREATION FAILURE! Unable to create database "%s". Check to make sure the user has "Create" privileges. Some hosts will restrict creation of a database only through the cpanel. Try creating the database manually to proceed with installation. If the database already exists then check the radio button labeled "Connect and Remove All Data" which will remove all existing tables.');
define('ERR_DBTRYCLEAN', 'DATABASE CREATION FAILURE! Unable to remove all tables from database "%s". Please remove all tables from this database and try the installation again.');
define('ERR_DBCREATE', 'The database "%s" does not exists. Change mode to create in order to create a new database.');
define('ERR_DBEMPTY', 'The database "%s" has "%s" tables. The Duplicator only works with an EMPTY database. Enable the action "Connect and Remove All Data" radio button to remove all tables and or create a new database. Some hosting providers do not allow table removal from scripts. In this case you will need to login to your hosting providers control panel and remove the tables manually. Please contact your hosting provider for further details. Always backup all your data before proceeding!');
/** * *****************************************************
* DUPX_Log
* Class used to log information */
class DUPX_Log {
/** METHOD: LOG
* Used to write debug info to the text log file
* @param string $msg Any text data
* @param int $loglevel Log level
*/
static public function Info($msg, $logging = 1) {
if ($logging <= $GLOBALS["LOGGING"]) {
@fwrite($GLOBALS["LOG_FILE_HANDLE"], "{$msg}\n");
}
}
static public function Error($errorMessage) {
if ($logging <= $GLOBALS["LOGGING"]) {
$breaks = array(" "," "," ");
$msg = str_ireplace($breaks, "\r\n", $errorMessage);
@fwrite($GLOBALS["LOG_FILE_HANDLE"], "\nINSTALLER ERROR:\n{$msg}\n");
@fclose($GLOBALS["LOG_FILE_HANDLE"]);
}
die("
INSTALL ERROR! {$errorMessage}
");
}
}
?>
=');
case 'set_charset' :
return version_compare($version, '5.0.7', '>=');
};
return false;
}
/**
* Sets the MySQL connection's character set.
* @param resource $dbh The resource given by mysqli_connect
* @param string $charset The character set (optional)
* @param string $collate The collation (optional)
*/
static public function mysql_set_charset($dbh, $charset = null, $collate = null) {
$charset = (!isset($charset) ) ? $GLOBALS['DBCHARSET_DEFAULT'] : $charset;
$collate = (!isset($collate) ) ? $GLOBALS['DBCOLLATE_DEFAULT'] : $collate;
if (self::mysql_has_ability($dbh, 'collation') && !empty($charset)) {
if (function_exists('mysqli_set_charset') && self::mysql_has_ability($dbh, 'set_charset')) {
return mysqli_set_charset($dbh, $charset);
} else {
$sql = " SET NAMES {$charset}";
if (!empty($collate))
$sql .= " COLLATE {$collate}";
return mysqli_query($dbh, $sql);
}
}
}
/**
* READABLE_BYTESIZE
* Display human readable byte sizes
* @param string $size The size in bytes
*/
static public function readable_bytesize($size) {
try {
$units = array('B', 'KB', 'MB', 'GB', 'TB');
for ($i = 0; $size >= 1024 && $i < 4; $i++)
$size /= 1024;
return round($size, 2) . $units[$i];
} catch (Exception $e) {
return "n/a";
}
}
/**
* PREG_REPLACEMENT_QUOTE
* The characters that are special in the replacement value of preg_replace are not the
* same characters that are special in the pattern
* @param string $str The string to replace on
*/
static public function preg_replacement_quote($str) {
return preg_replace('/(\$|\\\\)(?=\d)/', '\\\\\1', $str);
}
/**
* IS_WEB_CONNECTED
* Check to see if the internet is accessable
* @param string $url A url e.g without prefix "ajax.googleapis.com"
* @param string $port A valid port number
* @return bool
*/
static public function is_url_active($url, $port) {
if (function_exists('fsockopen')) {
$port = isset($port) && is_integer($port) ? $port : 80;
$connected = @fsockopen($url, $port); //website and port
if ($connected){
$is_conn = true;
@fclose($connected);
} else {
$is_conn = false;
}
return $is_conn;
} else {
return false;
}
}
}
?>
RewriteEngine On
RewriteBase {$newpath}
RewriteRule ^index\.php$ - [L]
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . {$newpath}index.php [L]
# END WordPress
HTACCESS;
file_put_contents('.htaccess', $tmp_htaccess);
@chmod('.htaccess', 0644);
DUPX_Log::Info("created basic .htaccess file. If using IIS web.config this process will need to be done manually.");
}
}
?>
0) {
while ($row = mysqli_fetch_assoc($result)) {
$fields[] = $row['Field'];
}
}
//Return Primary which is needed for index lookup
$result = mysqli_query($conn, "SHOW INDEX FROM `{$table}` WHERE KEY_NAME LIKE '%PRIMARY%'");
if (mysqli_num_rows($result) > 0) {
while ($row = mysqli_fetch_assoc($result)) {
$fields[] = $row['Column_name'];
}
}
return (count($fields) > 0) ? $fields : null;
}
/**
* LOAD
* Begins the processing for replace logic
* @param mysql $conn The db connection object
* @param array $list Key value pair of 'search' and 'replace' arrays
* @param array $tables The tables we want to look at.
* @return array Collection of information gathered during the run.
*/
static public function load($conn, $list = array(), $tables = array(), $cols = array(), $fullsearch = false) {
$exclude_cols = $cols;
$report = array('scan_tables' => 0, 'scan_rows' => 0, 'scan_cells' => 0,
'updt_tables' => 0, 'updt_rows' => 0, 'updt_cells' => 0,
'errsql' => array(), 'errser' => array(), 'errkey' => array(),
'errsql_sum' => 0, 'errser_sum' => 0, 'errkey_sum' => 0,
'time' => '', 'err_all' => 0);
$walk_function = create_function('&$str', '$str = "`$str`";');
$profile_start = DupUtil::get_microtime();
if (is_array($tables) && !empty($tables)) {
foreach ($tables as $table) {
$report['scan_tables']++;
$columns = array();
// Get a list of columns in this table
$fields = mysqli_query($conn, 'DESCRIBE ' . $table);
while ($column = mysqli_fetch_array($fields)) {
$columns[$column['Field']] = $column['Key'] == 'PRI' ? true : false;
}
// Count the number of rows we have in the table if large we'll split into blocks
$row_count = mysqli_query($conn, "SELECT COUNT(*) FROM `{$table}`");
$rows_result = mysqli_fetch_array($row_count);
@mysqli_free_result($row_count);
$row_count = $rows_result[0];
if ($row_count == 0) {
DUPX_Log::Info("{$table}^ ({$row_count})");
continue;
}
$page_size = 25000;
$offset = ($page_size + 1);
$pages = ceil($row_count / $page_size);
// Grab the columns of the table. Only grab text based columns because
// they are the only data types that should allow any type of search/replace logic
$colList = '*';
$colMsg = '*';
if (! $fullsearch) {
$colList = self::getTextColumns($conn, $table);
if ($colList != null && is_array($colList)) {
array_walk($colList, $walk_function);
$colList = implode(',', $colList);
}
$colMsg = (empty($colList)) ? '*' : '~';
}
if (empty($colList)) {
DUPX_Log::Info("{$table}^ ({$row_count})");
continue;
} else {
DUPX_Log::Info("{$table}{$colMsg} ({$row_count})");
}
//Paged Records
for ($page = 0; $page < $pages; $page++) {
$current_row = 0;
$start = $page * $page_size;
$end = $start + $page_size;
$sql = sprintf("SELECT {$colList} FROM `%s` LIMIT %d, %d", $table, $start, $offset);
$data = mysqli_query($conn, $sql);
if (!$data)
$report['errsql'][] = mysqli_error($conn);
$scan_count = ($row_count < $end) ? $row_count : $end;
DUPX_Log::Info("\tScan => {$start} of {$scan_count}", 2);
//DEBUG ONLY:
//DUPX_Log::Info("\t{$sql}", 3);
//Loops every row
while ($row = mysqli_fetch_array($data)) {
$report['scan_rows']++;
$current_row++;
$upd_col = array();
$upd_sql = array();
$where_sql = array();
$upd = false;
$serial_err = 0;
//Loops every cell
foreach ($columns as $column => $primary_key) {
if (in_array($column, $exclude_cols)) {
continue;
}
$report['scan_cells']++;
$edited_data = $data_to_fix = $row[$column];
$base64coverted = false;
//Only replacing string values
if (!empty($row[$column]) && !is_numeric($row[$column])) {
//Base 64 detection
if (base64_decode($row[$column], true)) {
$decoded = base64_decode($row[$column], true);
if (self::is_serialized($decoded)) {
$edited_data = $decoded;
$base64coverted = true;
}
}
//Replace logic - level 1: simple check on basic serilized strings
foreach ($list as $item) {
$edited_data = self::recursive_unserialize_replace($item['search'], $item['replace'], $edited_data);
}
//Replace logic - level 2: repair larger/complex serilized strings
$serial_check = self::fix_serial_string($edited_data);
if ($serial_check['fixed']) {
$edited_data = $serial_check['data'];
} elseif ($serial_check['tried'] && !$serial_check['fixed']) {
$serial_err++;
}
}
//Change was made
if ($edited_data != $data_to_fix || $serial_err > 0) {
$report['updt_cells']++;
//Base 64 encode
if ($base64coverted) {
$edited_data = base64_encode($edited_data);
}
$upd_col[] = $column;
$upd_sql[] = $column . ' = "' . mysqli_real_escape_string($conn, $edited_data) . '"';
$upd = true;
}
if ($primary_key) {
$where_sql[] = $column . ' = "' . mysqli_real_escape_string($conn, $data_to_fix) . '"';
}
}
//PERFORM ROW UPDATE
if ($upd && !empty($where_sql)) {
$sql = "UPDATE `{$table}` SET " . implode(', ', $upd_sql) . ' WHERE ' . implode(' AND ', array_filter($where_sql));
$result = mysqli_query($conn, $sql) or $report['errsql'][] = mysqli_error($conn);
//DEBUG ONLY:
DUPX_Log::Info("\t{$sql}", 3);
if ($result) {
if ($serial_err > 0) {
$report['errser'][] = "SELECT " . implode(', ', $upd_col) . " FROM `{$table}` WHERE " . implode(' AND ', array_filter($where_sql)) . ';';
}
$report['updt_rows']++;
}
} elseif ($upd) {
$report['errkey'][] = sprintf("Row [%s] on Table [%s] requires a manual update.", $current_row, $table);
}
}
DupUtil::fcgi_flush();
@mysqli_free_result($data);
}
if ($upd) {
$report['updt_tables']++;
}
}
}
$profile_end = DupUtil::get_microtime();
$report['time'] = DupUtil::elapsed_time($profile_end, $profile_start);
$report['errsql_sum'] = empty($report['errsql']) ? 0 : count($report['errsql']);
$report['errser_sum'] = empty($report['errser']) ? 0 : count($report['errser']);
$report['errkey_sum'] = empty($report['errkey']) ? 0 : count($report['errkey']);
$report['err_all'] = $report['errsql_sum'] + $report['errser_sum'] + $report['errkey_sum'];
return $report;
}
/**
* Take a serialised array and unserialise it replacing elements and
* unserialising any subordinate arrays and performing the replace.
* @param string $from String we're looking to replace.
* @param string $to What we want it to be replaced with
* @param array $data Used to pass any subordinate arrays back to in.
* @param bool $serialised Does the array passed via $data need serialising.
* @return array The original array with all elements replaced as needed.
*/
static private function recursive_unserialize_replace($from = '', $to = '', $data = '', $serialised = false) {
// some unseriliased data cannot be re-serialised eg. SimpleXMLElements
try {
if (is_string($data) && ($unserialized = @unserialize($data)) !== false) {
$data = self::recursive_unserialize_replace($from, $to, $unserialized, true);
} elseif (is_array($data)) {
$_tmp = array();
foreach ($data as $key => $value) {
$_tmp[$key] = self::recursive_unserialize_replace($from, $to, $value, false);
}
$data = $_tmp;
unset($_tmp);
} elseif (is_object($data)) {
$dataClass = get_class($data);
$_tmp = new $dataClass();
foreach ($data as $key => $value) {
$_tmp->$key = self::recursive_unserialize_replace($from, $to, $value, false);
}
$data = $_tmp;
unset($_tmp);
} else {
if (is_string($data)) {
$data = str_replace($from, $to, $data);
}
}
if ($serialised)
return serialize($data);
} catch (Exception $error) {
DUPX_Log::Info("\nRECURSIVE UNSERIALIZE ERROR: With string\n" . $error, 2);
}
return $data;
}
/**
* IS_SERIALIZED
* Test if a string in properly serialized */
static public function is_serialized($data) {
$test = @unserialize(($data));
return ($test !== false || $test === 'b:0;') ? true : false;
}
/**
* FIX_STRING
* Fixes the string length of a string object that has been serialized but the length is broken
* @param string $data The string ojbect to recalculate the size on.
* @return
*/
static private function fix_serial_string($data) {
$result = array('data' => $data, 'fixed' => false, 'tried' => false);
if (preg_match("/s:[0-9]+:/", $data)) {
if (!self::is_serialized($data)) {
$regex = '!(?<=^|;)s:(\d+)(?=:"(.*?)";(?:}|a:|s:|b:|d:|i:|o:|N;))!s';
$serial_string = preg_match('/^s:[0-9]+:"(.*$)/s', trim($data), $matches);
//Nested serial string
if ($serial_string) {
$inner = preg_replace_callback($regex, 'DupDBTextSwap::fix_string_callback', rtrim($matches[1], '";'));
$serialized_fixed = 's:' . strlen($inner) . ':"' . $inner . '";';
} else {
$serialized_fixed = preg_replace_callback($regex, 'DupDBTextSwap::fix_string_callback', $data);
}
if (self::is_serialized($serialized_fixed)) {
$result['data'] = $serialized_fixed;
$result['fixed'] = true;
}
$result['tried'] = true;
}
}
return $result;
}
static private function fix_string_callback($matches) {
return 's:' . strlen(($matches[2]));
}
}
?>
Success" : "