| Server IP : 104.21.14.103 / Your IP : 3.139.80.52 Web Server : LiteSpeed System : Linux business53.web-hosting.com 4.18.0-553.lve.el8.x86_64 #1 SMP Mon May 27 15:27:34 UTC 2024 x86_64 User : giankuin ( 1871) PHP Version : 7.4.33 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : OFF | Pkexec : OFF Directory : /home/giankuin/sieuthiweb.com.vn/dup-installer/classes/ |
Upload File : |
<?php
/**
* Walks every table in db that then walks every row and column replacing searches with replaces
* large tables are split into 50k row blocks to save on memory.
*
* Standard: PSR-2
* @link http://www.php-fig.org/psr/psr-2 Full Documentation
*
* @package SC\DUPX\UpdateEngine
*
*/
defined('ABSPATH') || defined('DUPXABSPATH') || exit;
class DUPX_UpdateEngine
{
const SR_PRORITY_HIGH = 5;
const SR_PRORITY_DEFAULT = 10;
const SR_PRORITY_LOW = 20;
const SR_PRORITY_NETWORK_SUBSITE_HIGH = 4;
const SR_PRORITY_NETWORK_SUBSITE = 5;
const SR_PRORITY_GENERIC_SUBST = 10;
const SR_PRORITY_GENERIC_SUBST_P1 = 10;
const SR_PRORITY_GENERIC_SUBST_P2 = 11;
const SR_PRORITY_GENERIC_SUBST_P3 = 12;
const SR_PRORITY_GENERIC_SUBST_P4 = 13;
const SR_PRORITY_CUSTOM = 20;
const SERIALIZE_OPEN_STR_REGEX = '/^(s:\d+:")/';
const SERIALIZE_CLOSE_STR_REGEX = '/^";}*(?:"|a:|s:|S:|b:|d:|i:|o:|O:|C:|r:|R:|N;|$)/';
const SERIALIZE_CLOSE_STR = '";';
const SERIALIZE_CLOSE_STR_LEN = 2;
private static $report = null;
/**
* Used to report on all log errors into the installer-txt.log
*
* @return string Writes the results of the update engine tables to the log
*/
public static function logErrors()
{
$s3Funcs = DUPX_S3_Funcs::getInstance();
if (!empty($s3Funcs->report['errsql'])) {
DUPX_Log::info("--------------------------------------");
DUPX_Log::info("DATA-REPLACE ERRORS (MySQL)");
foreach ($s3Funcs->report['errsql'] as $error) {
DUPX_Log::info($error);
}
DUPX_Log::info("");
}
if (!empty($s3Funcs->report['errser'])) {
DUPX_Log::info("--------------------------------------");
DUPX_Log::info("DATA-REPLACE ERRORS (Serialization):");
foreach ($s3Funcs->report['errser'] as $error) {
DUPX_Log::info($error);
}
DUPX_Log::info("");
}
if (!empty($s3Funcs->report['errkey'])) {
DUPX_Log::info("--------------------------------------");
DUPX_Log::info("DATA-REPLACE ERRORS (Key):");
DUPX_Log::info('Use SQL: SELECT @row := @row + 1 as row, t.* FROM some_table t, (SELECT @row := 0) r');
foreach ($s3Funcs->report['errkey'] as $error) {
DUPX_Log::info($error);
}
}
}
/**
* Used to report on all log stats into the installer-txt.log
*
* @return string Writes the results of the update engine tables to the log
*/
public static function logStats()
{
$s3Funcs = DUPX_S3_Funcs::getInstance();
DUPX_Log::resetIndent();
if (!empty($s3Funcs->report) && is_array($s3Funcs->report)) {
$stats = "--------------------------------------\n";
$stats .= sprintf("SCANNED:\tTables:%d \t|\t Rows:%d \t|\t Cells:%d \n", $s3Funcs->report['scan_tables'], $s3Funcs->report['scan_rows'], $s3Funcs->report['scan_cells']);
$stats .= sprintf("UPDATED:\tTables:%d \t|\t Rows:%d \t|\t Cells:%d \n", $s3Funcs->report['updt_tables'], $s3Funcs->report['updt_rows'], $s3Funcs->report['updt_cells']);
$stats .= sprintf("ERRORS:\t\t%d \nRUNTIME:\t%f sec", $s3Funcs->report['err_all'], $s3Funcs->report['time']);
DUPX_Log::info($stats);
}
}
/**
* Returns only the text type columns of a table ignoring all numeric types
*
* @param obj $conn A valid database link handle
* @param string $table A valid table name
*
* @return array All the column names of a table
*/
private static function getTextColumns($table)
{
$dbh = DUPX_S3_Funcs::getInstance()->getDbConnection();
$type_where = '';
$type_where .= "type LIKE '%char%' OR ";
$type_where .= "type LIKE '%text' OR ";
$type_where .= "type LIKE '%blob' ";
$sql = "SHOW COLUMNS FROM `".mysqli_real_escape_string($dbh, $table)."` WHERE {$type_where}";
$result = DUPX_DB::mysqli_query($dbh, $sql);
if (!$result) {
return null;
}
$fields = array();
if (mysqli_num_rows($result) > 0) {
while ($row = mysqli_fetch_assoc($result)) {
$fields[] = $row['Field'];
}
}
//Return Primary which is needed for index lookup. LIKE '%PRIMARY%' is less accurate with lookup
//$result = mysqli_query($dbh, "SHOW INDEX FROM `{$table}` WHERE KEY_NAME LIKE '%PRIMARY%'");
$result = mysqli_query($dbh, "SHOW INDEX FROM `".mysqli_real_escape_string($dbh, $table)."`");
if (mysqli_num_rows($result) > 0) {
while ($row = mysqli_fetch_assoc($result)) {
$fields[] = $row['Column_name'];
}
}
return (count($fields) > 0) ? array_unique($fields) : null;
}
public static function set_sql_column_safe(&$str)
{
$str = "`$str`";
}
public static function loadInit()
{
DUPX_Log::info('ENGINE LOAD INIT', DUPX_Log::LV_DEBUG);
$s3Funcs = DUPX_S3_Funcs::getInstance();
$s3Funcs->report['profile_start'] = DUPX_U::getMicrotime();
$dbh = $s3Funcs->getDbConnection();
@mysqli_autocommit($dbh, false);
}
/**
* Begins the processing for replace logic
*
* @param array $tables The tables we want to look at
*
* @return array Collection of information gathered during the run.
*/
public static function load($tables = array())
{
self::loadInit();
if (is_array($tables)) {
foreach ($tables as $table) {
self::evaluateTalbe($table);
}
}
self::commitAndSave();
return self::loadEnd();
}
public static function commitAndSave()
{
DUPX_Log::info('ENGINE COMMIT AND SAVE', DUPX_Log::LV_DEBUG);
$dbh = DUPX_S3_Funcs::getInstance()->getDbConnection();
@mysqli_commit($dbh);
@mysqli_autocommit($dbh, true);
DUPX_NOTICE_MANAGER::getInstance()->saveNotices();
}
public static function loadEnd()
{
$s3Funcs = DUPX_S3_Funcs::getInstance();
DUPX_Log::info('ENGINE LOAD END', DUPX_Log::LV_DEBUG);
$s3Funcs->report['profile_end'] = DUPX_U::getMicrotime();
$s3Funcs->report['time'] = DUPX_U::elapsedTime($s3Funcs->report['profile_end'], $s3Funcs->report['profile_start']);
$s3Funcs->report['errsql_sum'] = empty($s3Funcs->report['errsql']) ? 0 : count($s3Funcs->report['errsql']);
$s3Funcs->report['errser_sum'] = empty($s3Funcs->report['errser']) ? 0 : count($s3Funcs->report['errser']);
$s3Funcs->report['errkey_sum'] = empty($s3Funcs->report['errkey']) ? 0 : count($s3Funcs->report['errkey']);
$s3Funcs->report['err_all'] = $s3Funcs->report['errsql_sum'] + $s3Funcs->report['errser_sum'] + $s3Funcs->report['errkey_sum'];
return $s3Funcs->report;
}
public static function getTableRowParamsDefault($table = '')
{
return array(
'table' => $table,
'updated' => false,
'row_count' => 0,
'columns' => array(),
'colList' => '*',
'colMsg' => 'every column',
'columnsSRList' => array(),
'pages' => 0,
'page_size' => 0,
'page' => 0,
'current_row' => 0
);
}
private static function getTableRowsParams($table)
{
$s3Funcs = DUPX_S3_Funcs::getInstance();
$dbh = $s3Funcs->getDbConnection();
$rowsParams = self::getTableRowParamsDefault($table);
// Count the number of rows we have in the table if large we'll split into blocks
$rowsParams['row_count'] = mysqli_query($dbh, "SELECT COUNT(*) FROM `".mysqli_real_escape_string($dbh, $rowsParams['table'])."`");
if (!$rowsParams['row_count']) {
return null;
}
$rows_result = mysqli_fetch_array($rowsParams['row_count']);
@mysqli_free_result($rowsParams['row_count']);
$rowsParams['row_count'] = $rows_result[0];
if ($rowsParams['row_count'] == 0) {
$rowsParams['colMsg'] = 'no columns ';
self::logEvaluateTable($rowsParams);
return null;
}
// Get a list of columns in this table
$sql = 'DESCRIBE '.mysqli_real_escape_string($dbh, $rowsParams['table']);
$fields = mysqli_query($dbh, $sql);
if (!$fields) {
return null;
}
while ($column = mysqli_fetch_array($fields)) {
$rowsParams['columns'][$column['Field']] = $column['Key'] == 'PRI' ? true : false;
}
$rowsParams['page_size'] = $GLOBALS['DATABASE_PAGE_SIZE'];
$rowsParams['pages'] = ceil($rowsParams['row_count'] / $rowsParams['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
if (!$s3Funcs->getPost('fullsearch')) {
$rowsParams['colList'] = self::getTextColumns($rowsParams['table']);
if ($rowsParams['colList'] != null && is_array($rowsParams['colList'])) {
array_walk($rowsParams['colList'], array(__CLASS__, 'set_sql_column_safe'));
$rowsParams['colList'] = implode(',', $rowsParams['colList']);
}
$rowsParams['colMsg'] = (empty($rowsParams['colList'])) ? 'every column' : 'text columns';
}
if (empty($rowsParams['colList'])) {
$rowsParams['colMsg'] = 'no columns ';
}
self::logEvaluateTable($rowsParams);
if (empty($rowsParams['colList'])) {
return null;
} else {
// PREPARE SEARCH AN REPLACE LISF FOR TABLES
$rowsParams['columnsSRList'] = self::getColumnsSearchReplaceList($rowsParams['table'], $rowsParams['columns']);
return $rowsParams;
}
}
public static function logEvaluateTable($rowsParams)
{
DUPX_Log::resetIndent();
$log = "\n".'EVALUATE TABLE: '.str_pad(DUPX_Log::varToString($rowsParams['table']), 50, '_', STR_PAD_RIGHT);
$log .= '[ROWS:'.str_pad($rowsParams['row_count'], 6, " ", STR_PAD_LEFT).']';
$log .= '[PG:'.str_pad($rowsParams['pages'], 4, " ", STR_PAD_LEFT).']';
$log .= '[SCAN:'.$rowsParams['colMsg'].']';
if (DUPX_Log::isLevel(DUPX_Log::LV_DETAILED)) {
$log .= '[COLS: '.$rowsParams['colList'].']';
}
DUPX_Log::info($log);
DUPX_Log::incIndent();
}
public static function evaluateTalbe($table)
{
$s3Funcs = DUPX_S3_Funcs::getInstance();
// init table params if isn't initialized
if (!self::initTableParams($table)) {
return false;
}
//Paged Records
$pages = $s3Funcs->cTableParams['pages'];
for ($page = 0; $page < $pages; $page++) {
self::evaluateTableRows($table, $page);
}
if ($s3Funcs->cTableParams['updated']) {
$s3Funcs->report['updt_tables']++;
}
}
public static function evaluateTableRows($table, $page)
{
$s3Funcs = DUPX_S3_Funcs::getInstance();
// init table params if isn't initialized
if (!self::initTableParams($table)) {
return false;
}
$s3Funcs->cTableParams['page'] = $page;
if ($s3Funcs->cTableParams['page'] >= $s3Funcs->cTableParams['pages']) {
DUPX_Log::info('ENGINE EXIT PAGE:'.DUPX_Log::varToString($table).' PAGES:'.$s3Funcs->cTableParams['pages'], DUPX_Log::LV_DEBUG);
return false;
}
return self::evaluatePagedRows($s3Funcs->cTableParams);
}
public static function initTableParams($table)
{
$s3Funcs = DUPX_S3_Funcs::getInstance();
if (is_null($s3Funcs->cTableParams) || $s3Funcs->cTableParams['table'] !== $table) {
DUPX_Log::resetIndent();
DUPX_Log::info("\n".'ENGINE INIT TABLE PARAMS '.DUPX_Log::varToString($table), DUPX_Log::LV_DETAILED);
if (!DUPX_DB::tableExists($s3Funcs->getDbConnection(), $table, true)) {
DUPX_Log::info('ENGINE TABLE DOESN\'T EXIST IN THE DATABASE', DUPX_Log::LV_DEBUG);
$longMsg = <<<MSG
The table could not be found in the database.
If the "Manual SQL Execution (Advanced)" option was chosen in step 2, make sure you insert the database manually before continuing to step 3.
Also, verify the database that was inserted contains the urls and paths of the original site before step 3 for proper migration.
MSG;
DUPX_NOTICE_MANAGER::getInstance()->addFinalReportNotice(array(
'shortMsg' => 'Table '.$table.' doesn\'t exist in the database',
'level' => DUPX_NOTICE_ITEM::HARD_WARNING,
'longMsg' => $longMsg,
'sections' => 'search_replace'
));
return false;
}
$s3Funcs->report['scan_tables']++;
if (($s3Funcs->cTableParams = self::getTableRowsParams($table)) === null) {
DUPX_Log::info('ENGINE TABLE PARAMS EMPTY', DUPX_Log::LV_DEBUG);
return false;
}
}
return true;
}
/**
* evaluate rows with pagination
*
* @param array $rowsParams
*
* @return boolean // if true table is modified and updated
*/
private static function evaluatePagedRows(&$rowsParams)
{
$nManager = DUPX_NOTICE_MANAGER::getInstance();
$s3Funcs = DUPX_S3_Funcs::getInstance();
$dbh = $s3Funcs->getDbConnection();
$start = $rowsParams['page'] * $rowsParams['page_size'];
$end = $start + $rowsParams['page_size'] - 1;
if (DUPX_Log::isLevel(DUPX_Log::LV_DETAILED)) {
$scan_count = min($rowsParams['row_count'], $end);
DUPX_Log::info('ENGINE EV TABLE '.str_pad(DUPX_Log::varToString($rowsParams['table']), 50, '_', STR_PAD_RIGHT).
'[PAGE:'.str_pad($rowsParams['page'], 4, " ", STR_PAD_LEFT).']'.
'[START:'.str_pad($start, 6, " ", STR_PAD_LEFT).']'.
'[OF:'.str_pad($scan_count, 6, " ", STR_PAD_LEFT).']', DUPX_Log::LV_DETAILED);
}
$sql = sprintf("SELECT {$rowsParams['colList']} FROM `%s` LIMIT %d, %d", $rowsParams['table'], $start, $rowsParams['page_size']);
if (($data = DUPX_DB::mysqli_query($dbh, $sql)) === false) {
$errMsg = mysqli_error($dbh);
$s3Funcs->report['errsql'][] = $errMsg;
$nManager->addFinalReportNotice(array(
'shortMsg' => 'DATA-REPLACE ERRORS: MySQL',
'level' => DUPX_NOTICE_ITEM::SOFT_WARNING,
'longMsg' => $errMsg,
'sections' => 'search_replace'
));
return false;
} else {
//Loops every row
while ($row = mysqli_fetch_assoc($data)) {
self::evaluateRow($rowsParams, $row);
}
@mysqli_free_result($data);
return $rowsParams['updated'];
}
}
/**
* evaluate single row columns
*
* @param array $rowsParams
* @param array $row
*
* @return boolean true if row is modified and updated
*/
private static function evaluateRow(&$rowsParams, $row)
{
$nManager = DUPX_NOTICE_MANAGER::getInstance();
$s3Funcs = DUPX_S3_Funcs::getInstance();
$dbh = $s3Funcs->getDbConnection();
$maxSerializeLenCheck = $s3Funcs->getPost('maxSerializeStrlen');
$s3Funcs->report['scan_rows']++;
$rowsParams['current_row']++;
$upd_col = array();
$upd_sql = array();
$where_sql = array();
$upd = false;
$serial_err = false;
$is_unkeyed = !in_array(true, $rowsParams['columns']);
$rowErrors = array();
//Loops every cell
foreach ($rowsParams['columns'] as $column => $primary_key) {
$s3Funcs->report['scan_cells']++;
if (!isset($row[$column])) {
continue;
}
$safe_column = '`'.mysqli_real_escape_string($dbh, $column).'`';
$edited_data = $originalData = $row[$column];
$base64converted = false;
$txt_found = false;
//Unkeyed table code
//Added this here to add all columns to $where_sql
//The if statement with $txt_found would skip additional columns -TG
if ($is_unkeyed && !empty($originalData)) {
$where_sql[] = $safe_column.' = "'.mysqli_real_escape_string($dbh, $originalData).'"';
}
//Only replacing string values
if (!empty($row[$column]) && !is_numeric($row[$column]) && $primary_key != 1) {
// get search and reaplace list for column
$tColList = &$rowsParams['columnsSRList'][$column]['list'];
$tColSearchList = &$rowsParams['columnsSRList'][$column]['sList'];
$tColreplaceList = &$rowsParams['columnsSRList'][$column]['rList'];
$tColExactMatch = $rowsParams['columnsSRList'][$column]['exactMatch'];
// skip empty search col
if (empty($tColSearchList)) {
continue;
}
// Search strings in data
foreach ($tColList as $item) {
if (preg_match($item['search'], $edited_data)) {
$txt_found = true;
break;
}
}
if (!$txt_found) {
//if not found decetc Base 64
if (($decoded = DUPX_U::is_base64($row[$column])) !== false) {
$edited_data = $decoded;
$base64converted = true;
// Search strings in data decoded
foreach ($tColList as $item) {
if (preg_match($item['search'], $edited_data)) {
$txt_found = true;
break;
}
}
}
//Skip table cell if match not found
if (!$txt_found) {
continue;
}
}
// 0 no limit
if ($maxSerializeLenCheck > 0 && self::is_serialized_string($edited_data) && strlen($edited_data) > $maxSerializeLenCheck) {
$serial_err = true;
$trimLen = DUPX_Log::isLevel(DUPX_Log::LV_HARD_DEBUG) ? 10000 : 200;
$rowErrors[$column] = 'ENGINE: serialize data too big to convert; data len:'.strlen($edited_data).' Max size:'.$maxSerializeLenCheck;
$rowErrors[$column] .= "\n\tDATA: ".mb_strimwidth($edited_data, 0, $trimLen, ' [...]');
} else {
//Replace logic - level 1: simple check on any string or serlized strings
if ($tColExactMatch) {
// if is exact match search and replace the itentical string
if (($rIndex = array_search($edited_data, $tColSearchList)) !== false) {
DUPX_Log::info("ColExactMatch ".$column.' search:'.$edited_data.' replace:'.$tColreplaceList[$rIndex].' index:'.$rIndex, DUPX_Log::LV_DEBUG);
$edited_data = $tColreplaceList[$rIndex];
}
} else {
// search if column contain search list
$edited_data = self::searchAndReplaceItems($tColSearchList, $tColreplaceList, $edited_data);
//Replace logic - level 2: repair serialized strings that have become broken
// check value without unserialize it
if (self::is_serialized_string($edited_data)) {
$serial_check = self::fixSerialString($edited_data);
if ($serial_check['fixed']) {
$edited_data = $serial_check['data'];
} else {
$trimLen = DUPX_Log::isLevel(DUPX_Log::LV_HARD_DEBUG) ? 10000 : 200;
$message = 'ENGINE: serialize data serial check error'.
"\n\tDATA: ".mb_strimwidth($edited_data, 0, $trimLen, ' [...]');
DUPX_Log::info($message);
$serial_err = true;
$rowErrors[$column] = $message;
}
}
}
}
}
//Base 64 encode
if ($base64converted) {
$edited_data = base64_encode($edited_data);
}
//Change was made
if ($serial_err == false && $edited_data != $originalData) {
$s3Funcs->report['updt_cells']++;
$upd_col[] = $safe_column;
$upd_sql[] = $safe_column.' = "'.mysqli_real_escape_string($dbh, $edited_data).'"';
$upd = true;
}
if ($primary_key) {
$where_sql[] = $safe_column.' = "'.mysqli_real_escape_string($dbh, $originalData).'"';
}
}
foreach ($rowErrors as $errCol => $msgCol) {
$longMsg = $msgCol."\n\tTABLE:".$rowsParams['table'].' COLUMN: '.$errCol.' WHERE: '.implode(' AND ', array_filter($where_sql));
$s3Funcs->report['errser'][] = $longMsg;
$nManager->addFinalReportNotice(array(
'shortMsg' => 'DATA-REPLACE ERROR: Serialization',
'level' => DUPX_NOTICE_ITEM::SOFT_WARNING,
'longMsg' => $longMsg,
'longMsgMode' => DUPX_NOTICE_ITEM::MSG_MODE_PRE,
'sections' => 'search_replace'
));
}
//PERFORM ROW UPDATE
if ($upd && !empty($where_sql)) {
$sql = "UPDATE `{$rowsParams['table']}` SET ".implode(', ', $upd_sql).' WHERE '.implode(' AND ', array_filter($where_sql));
$result = DUPX_DB::mysqli_query($dbh, $sql);
if ($result) {
$s3Funcs->report['updt_rows']++;
$rowsParams['updated'] = true;
} else {
$errMsg = mysqli_error($dbh)."\n\tTABLE:".$rowsParams['table'].' WHERE: '.implode(' AND ', array_filter($where_sql));
$s3Funcs->report['errsql'][] = 'DB ERROR: '.$errMsg.(DUPX_Log::isLevel(DUPX_Log::LV_DETAILED) ? "\nSQL: [{$sql}]\n" : '');
$nManager->addFinalReportNotice(array(
'shortMsg' => 'DATA-REPLACE ERRORS: MySQL',
'level' => DUPX_NOTICE_ITEM::SOFT_WARNING,
'longMsg' => $errMsg,
'longMsgMode' => DUPX_NOTICE_ITEM::MSG_MODE_PRE,
'sections' => 'search_replace'
));
}
} elseif ($upd) {
$errMsg = sprintf("Row [%s] on Table [%s] requires a manual update.", $rowsParams['current_row'], $rowsParams['table']);
$s3Funcs->report['errkey'][] = $errMsg;
$nManager->addFinalReportNotice(array(
'shortMsg' => 'DATA-REPLACE ERROR: Key',
'level' => DUPX_NOTICE_ITEM::SOFT_WARNING,
'longMsg' => $errMsg,
'sections' => 'search_replace'
));
}
return $rowsParams['updated'];
}
private static function getColumnsSearchReplaceList($table, $columns)
{
// PREPARE SEARCH AN REPLACE LISF FOR TABLES
$srManager = DUPX_S_R_MANAGER::getInstance();
$searchList = array();
$replaceList = array();
$list = $srManager->getSearchReplaceList($table);
foreach ($list as $item) {
$searchList[] = $item['search'];
$replaceList[] = $item['replace'];
}
$columnsSRList = array();
foreach ($columns as $column => $primary_key) {
if (($cScope = self::getSearchReplaceCustomScope($table, $column)) === false) {
// if don't have custom scope get normal search and reaplce table list
$columnsSRList[$column] = array(
'list' => &$list,
'sList' => &$searchList,
'rList' => &$replaceList,
'exactMatch' => false
);
} else {
// if column have custom scope overvrite default table search/replace list
$columnsSRList[$column] = array(
'list' => $srManager->getSearchReplaceList($cScope, true, false),
'sList' => array(),
'rList' => array(),
'exactMatch' => self::isExactMatch($table, $column)
);
foreach ($columnsSRList[$column]['list'] as $item) {
$columnsSRList[$column]['sList'][] = $item['search'];
$columnsSRList[$column]['rList'][] = $item['replace'];
}
}
}
return $columnsSRList;
}
/**
* searches and replaces strings without deserializing
* recursion for arrays
*
* @param array $search
* @param array $replace
* @param mixed $data
*
* @return mixed
*/
public static function searchAndReplaceItems($search, $replace, $data)
{
if (empty($data) || is_numeric($data) || is_bool($data) || is_callable($data)) {
/* do nothing */
} else if (is_string($data)) {
foreach ($search as $index => $cs) {
// Multiple replace string. If the string is serialized will fixed with fixSerialString
$data = preg_replace($cs, $replace[$index], $data);
}
} else if (is_array($data)) {
$_tmp = array();
foreach ($data as $key => $value) {
// prevent recursion overhead
if (empty($value) || is_numeric($value) || is_bool($value) || is_callable($value) || is_object($data)) {
$_tmp[$key] = $value;
} else {
$_tmp[$key] = self::searchAndReplaceItems($search, $replace, $value, false);
}
}
$data = $_tmp;
unset($_tmp);
} elseif (is_object($data)) {
// it can never be an object type
DUPX_Log::info("OBJECT DATA IMPOSSIBLE\n");
}
return $data;
}
/**
* FROM WORDPRESS
* Check value to find if it was serialized.
*
* If $data is not an string, then returned value will always be false.
* Serialized data is always a string.
*
* @since 2.0.5
*
* @param string $data Value to check to see if was serialized.
* @param bool $strict Optional. Whether to be strict about the end of the string. Default true.
* @return bool False if not serialized and true if it was.
*/
public static function is_serialized_string($data, $strict = true)
{
// if it isn't a string, it isn't serialized.
if (!is_string($data)) {
return false;
}
$data = trim($data);
if ('N;' == $data) {
return true;
}
if (strlen($data) < 4) {
return false;
}
if (':' !== $data[1]) {
return false;
}
if ($strict) {
$lastc = substr($data, -1);
if (';' !== $lastc && '}' !== $lastc) {
return false;
}
} else {
$semicolon = strpos($data, ';');
$brace = strpos($data, '}');
// Either ; or } must exist.
if (false === $semicolon && false === $brace) {
return false;
}
// But neither must be in the first X characters.
if (false !== $semicolon && $semicolon < 3) {
return false;
}
if (false !== $brace && $brace < 4) {
return false;
}
}
$token = $data[0];
switch ($token) {
case 's' :
if ($strict) {
if ('"' !== substr($data, -2, 1)) {
return false;
}
} elseif (false === strpos($data, '"')) {
return false;
}
// or else fall through
case 'a' :
case 'O' :
return (bool) preg_match("/^{$token}:[0-9]+:/s", $data);
case 'b' :
case 'i' :
case 'd' :
$end = $strict ? '$' : '';
return (bool) preg_match("/^{$token}:[0-9.E-]+;$end/", $data);
}
return false;
}
/**
* Test if a string in properly serialized
*
* @param string $data Any string type
*
* @return bool Is the string a serialized string
*/
public static function unserializeTest($data)
{
if (!is_string($data)) {
return false;
} else if ($data === 'b:0;') {
return true;
} else {
try {
DUPX_Handler::setMode(DUPX_Handler::MODE_OFF);
$unserialize_ret = @unserialize($data);
DUPX_Handler::setMode();
return ($unserialize_ret !== false);
}
catch (Exception $e) {
DUPX_Log::info("Unserialize exception: ".$e->getMessage());
//DEBUG ONLY:
DUPX_Log::info("Serialized data\n".$data, DUPX_Log::LV_DEBUG);
return false;
}
}
}
/**
* custom columns list
* if the table / column pair exists in this array then the search scope will be overwritten with that contained in the array
*
* @var array
*/
private static $customScopes = array(
'signups' => array(
'domain' => array(
'scope' => 'domain_host',
'exact' => true
),
'path' => array(
'scope' => 'domain_path',
'exact' => true
)
),
'site' => array(
'domain' => array(
'scope' => 'domain_host',
'exact' => true
),
'path' => array(
'scope' => 'domain_path',
'exact' => true
)
)
);
/**
*
* @param string $table
* @param string $column
* @return boolean|string false if custom scope not found or return custom scoper for table/column
*/
private static function getSearchReplaceCustomScope($table, $column)
{
$tablePrefix = DUPX_Paramas_Manager::getInstance()->getValue(DUPX_Paramas_Manager::PARAM_DB_TABLE_PREFIX);
if (strpos($table, $tablePrefix) !== 0) {
return false;
}
$table_key = substr($table, strlen($tablePrefix));
if (!array_key_exists($table_key, self::$customScopes)) {
return false;
}
if (!array_key_exists($column, self::$customScopes[$table_key])) {
return false;
}
return self::$customScopes[$table_key][$column]['scope'];
}
/**
*
* @param string $table
* @param string $column
* @return boolean if true search a exact match in column if false search as LIKE
*/
private static function isExactMatch($table, $column)
{
$tablePrefix = DUPX_Paramas_Manager::getInstance()->getValue(DUPX_Paramas_Manager::PARAM_DB_TABLE_PREFIX);
if (strpos($table, $tablePrefix) !== 0) {
return false;
}
$table_key = substr($table, strlen($tablePrefix));
if (!array_key_exists($table_key, self::$customScopes)) {
return false;
}
if (!array_key_exists($column, self::$customScopes[$table_key])) {
return false;
}
return self::$customScopes[$table_key][$column]['exact'];
}
/**
* Fixes the string length of a string object that has been serialized but the length is broken
*
* @param string $data The string object to recalculate the size on.
*
* @return string A serialized string that fixes and string length types
*/
public static function fixSerialString($data)
{
$result = array(
'data' => null,
'fixed' => false,
'tried' => false
);
// check if serialized string must be fixed
if (self::unserializeTest($data)) {
$result['data'] = $data;
$result['fixed'] = true;
} else {
$result['tried'] = true;
$serialized_fixed = self::recursiveFixSerialString($data);
if (self::unserializeTest($serialized_fixed)) {
$result['data'] = $serialized_fixed;
$result['fixed'] = true;
} else {
$result['fixed'] = false;
}
}
return $result;
}
/**
* Fixes the string length of a string object that has been serialized but the length is broken
* Work on nested serialized string recursively.
*
* @param string $data The string ojbect to recalculate the size on.
*
* @return string A serialized string that fixes and string length types
*/
public static function recursiveFixSerialString($data)
{
if (!self::is_serialized_string($data)) {
return $data;
}
$result = '';
$matches = null;
$openLevel = 0;
$openContent = '';
$openContentL2 = '';
// parse every char
for ($i = 0; $i < strlen($data); $i++) {
$cChar = $data[$i];
$addChar = true;
if ($cChar == 's') {
// test if is a open string
if (preg_match(self::SERIALIZE_OPEN_STR_REGEX, substr($data, $i, 20), $matches)) {
if ($openLevel > 1) {
$openContentL2 .= $matches[0];
}
$addChar = false;
$openLevel++;
$i += strlen($matches[0]) - 1;
}
} else if ($openLevel > 0 && $cChar == '"') {
// test if is a close string
if (preg_match(self::SERIALIZE_CLOSE_STR_REGEX, substr($data, $i, 7))) {
$addChar = false;
switch ($openLevel) {
case 1:
// level 1
// flush string content
$result .= 's:'.strlen($openContent).':"'.$openContent.'";';
$openContent = '';
break;
case 2;
// level 2
// fix serial string level2
$sublevelstr = self::recursiveFixSerialString($openContentL2);
// flush content on level 1
$openContent .= 's:'.strlen($sublevelstr).':"'.$sublevelstr.'";';
$openContentL2 = '';
break;
default:
// level > 2
// keep writing at level 2; it will be corrected with recursion
$openContentL2 .= self::SERIALIZE_CLOSE_STR;
break;
}
$openLevel--;
$i += self::SERIALIZE_CLOSE_STR_LEN - 1;
}
}
if ($addChar) {
switch ($openLevel) {
case 0:
// level 0
// add char on result
$result .= $cChar;
break;
case 1:
// level 1
// add char on content level1
$openContent .= $cChar;
break;
default:
// level > 1
// add char on content level2
$openContentL2 .= $cChar;
break;
}
}
}
return $result;
}
public static function replaceBlogsAndSiteTables()
{
$s3Funcs = DUPX_S3_Funcs::getInstance();
$nManager = DUPX_NOTICE_MANAGER::getInstance();
$paramsManager = DUPX_Paramas_Manager::getInstance();
$muMode = $s3Funcs->getPost('action_mu_mode');
if ($muMode == DUPX_MultisiteMode::Subdomain || $muMode == DUPX_MultisiteMode::Subdirectory) {
$dbh = $s3Funcs->getDbConnection();
DUPX_Log::resetIndent();
if ($s3Funcs->isMapping()) {
$newMuUrls = $paramsManager->getValue(DUPX_Paramas_Manager::PARAM_MU_REPLACE);
} else {
$newMuUrls = DUPX_ArchiveConfig::getInstance()->getNewUrlsArrayIdVal();
}
DUPX_Log::info("ENGINE UPDATE BLOGS TABLE\n".DUPX_Log::varToString($newMuUrls));
$escapedTablePrefix = mysqli_real_escape_string($dbh, DUPX_Paramas_Manager::getInstance()->getValue(DUPX_Paramas_Manager::PARAM_DB_TABLE_PREFIX));
$table = '`'.$escapedTablePrefix.'blogs`';
foreach ($newMuUrls as $currentSubid => $newSiteUrl) {
$rUrlInfo = parse_url($newSiteUrl);
$rHost = isset($rUrlInfo['host']) ? $rUrlInfo['host'] : '';
$rPath = isset($rUrlInfo['path']) ? $rUrlInfo['path'] : '';
$rPath = rtrim($rPath, '/').'/';
$sql = 'UPDATE '.$table.' SET `domain` = \''.$rHost.'\', `path` = \''.$rPath.'\' WHERE '.$table.'.`blog_id` = '.$currentSubid;
if (DUPX_DB::mysqli_query($dbh, $sql) === false) {
$errMsg = 'blogs table updates error'.
"\n\t".mysqli_error($dbh).
"\n\tTABLE:".$table.' HOST: '.$rHost.' PATH: '.$rPath.' SUBSITEID: '.$currentSubid;
$s3Funcs->report['errsql'][] = 'DB ERROR: '.$errMsg.(DUPX_Log::isLevel(DUPX_Log::LV_DETAILED) ? "\nSQL: [{$sql}]\n" : '');
$nManager->addFinalReportNotice(array(
'shortMsg' => 'DATA-REPLACE ERRORS: MySQL',
'level' => DUPX_NOTICE_ITEM::CRITICAL,
'longMsg' => $errMsg,
'longMsgMode' => DUPX_NOTICE_ITEM::MSG_MODE_PRE,
'sections' => 'search_replace'
));
} else {
DUPX_Log::info('ENGINE BLOG TALBE UPDATED ID:'.$currentSubid.' DOMAIN:'.$rHost.' PATH:'.$rPath, DUPX_Log::LV_DETAILED);
}
}
}
}
/**
*
* @param object $dbh
* @param string $table
* @param string $column
* @param string $oldPrefix
* @param string $newPrefix
*
* @return boolean
*/
public static function updateTablePrefix($dbh, $table, $column, $oldPrefix, $newPrefix)
{
if ($oldPrefix === $newPrefix) {
return true;
}
$lenOldPrefix = strlen($oldPrefix) + 1;
$regexOldTablePrefix = mysqli_real_escape_string($dbh, preg_quote($oldPrefix, null /* no delimiter */));
$escapedNewTablePrefix = mysqli_real_escape_string($dbh, $newPrefix);
// remove old prefix values if exists
$sql = 'DELETE FROM '.$table.' WHERE '.$column.' IN ('
.'SELECT CONCAT(\''.$escapedNewTablePrefix.'\',SUBSTRING('.$column.' , '.$lenOldPrefix.')) '
.'FROM (SELECT * FROM '.$table.' WHERE `'.$column.'` REGEXP \'^'.$regexOldTablePrefix.'\') selectTableAlias'
.')';
if (DUPX_DB::mysqli_query($dbh, $sql) === false) {
$nManager = DUPX_NOTICE_MANAGER::getInstance();
$s3Funcs = DUPX_S3_Funcs::getInstance();
$errMsg = 'Query error on table prefix user meta '."\n\t".mysqli_error($dbh);
$s3Funcs->report['errsql'][] = 'DB ERROR: '.$errMsg.(DUPX_Log::isLevel(DUPX_Log::LV_DETAILED) ? "\nSQL: [{$sql}]\n" : '');
$nManager->addFinalReportNotice(array(
'shortMsg' => 'UPDATE PREFIX TABLE ERROR',
'level' => DUPX_NOTICE_ITEM::CRITICAL,
'longMsg' => $errMsg,
'longMsgMode' => DUPX_NOTICE_ITEM::MSG_MODE_PRE,
'sections' => 'search_replace'
));
return false;
}
/// rename table prefix value
$sql = 'UPDATE '.$table.' SET '.$column.' = CONCAT(\''.$escapedNewTablePrefix.'\',SUBSTRING('.$column.' , '.$lenOldPrefix.')) WHERE `'.$column.'` REGEXP \'^'.$regexOldTablePrefix.'\'';
if (DUPX_DB::mysqli_query($dbh, $sql) === false) {
$nManager = DUPX_NOTICE_MANAGER::getInstance();
$s3Funcs = DUPX_S3_Funcs::getInstance();
$errMsg = 'Query error on table prefix user meta '."\n\t".mysqli_error($dbh);
$s3Funcs->report['errsql'][] = 'DB ERROR: '.$errMsg.(DUPX_Log::isLevel(DUPX_Log::LV_DETAILED) ? "\nSQL: [{$sql}]\n" : '');
$nManager->addFinalReportNotice(array(
'shortMsg' => 'UPDATE PREFIX TABLE ERROR',
'level' => DUPX_NOTICE_ITEM::CRITICAL,
'longMsg' => $errMsg,
'longMsgMode' => DUPX_NOTICE_ITEM::MSG_MODE_PRE,
'sections' => 'search_replace'
));
return false;
}
return true;
}
public static function updateTablePrefixKeys()
{
if (!DUPX_ArchiveConfig::getInstance()->isTablePrefixChanged()) {
return true;
}
$nManager = DUPX_NOTICE_MANAGER::getInstance();
$s3Funcs = DUPX_S3_Funcs::getInstance();
$paramsManager = DUPX_Paramas_Manager::getInstance();
$archiveConfig = DUPX_ArchiveConfig::getInstance();
$dbh = $s3Funcs->getDbConnection();
$oldPrefix = DUPX_ArchiveConfig::getInstance()->wp_tableprefix;
$newPrefix = $paramsManager->getValue(DUPX_Paramas_Manager::PARAM_DB_TABLE_PREFIX);
$tables = DUPX_MU::getTablesByPrefix($newPrefix, $dbh);
if (!is_array($tables)) {
$nManager->addFinalReportNotice(array(
'shortMsg' => 'CAN\'T FIND ANY TABLE IN DATABASE',
'level' => DUPX_NOTICE_ITEM::CRITICAL,
'longMsgMode' => DUPX_NOTICE_ITEM::MSG_MODE_PRE,
'sections' => 'search_replace'
));
return false;
}
$optionsTable = $newPrefix.'options';
if (in_array($optionsTable, $tables)) {
DUPX_Log::info('UPDATE PREFIX IN TABLE '.DUPX_Log::varToString($optionsTable), DUPX_Log::LV_DETAILED);
self::updateTablePrefix($dbh, $optionsTable, 'option_name', $oldPrefix, $newPrefix);
} else {
DUPX_Log::info('CAN\'T UPDATE PREFIX IN TABLE '.DUPX_Log::varToString($optionsTable).' BACAUSE TABLE NOT IN LIST', DUPX_Log::LV_DETAILED);
}
$usermetaTable = $newPrefix.'usermeta';
if (in_array($usermetaTable, $tables)) {
DUPX_Log::info('UPDATE PREFIX IN TABLE '.DUPX_Log::varToString($usermetaTable), DUPX_Log::LV_DETAILED);
self::updateTablePrefix($dbh, $usermetaTable, 'meta_key', $oldPrefix, $newPrefix);
} else {
DUPX_Log::info('CAN\'T UPDATE PREFIX IN TABLE '.DUPX_Log::varToString($usermetaTable).' BACAUSE TABLE NOT IN LIST', DUPX_Log::LV_DETAILED);
}
$muMode = $s3Funcs->getPost('action_mu_mode');
if ($muMode == DUPX_MultisiteMode::Subdomain || $muMode == DUPX_MultisiteMode::Subdirectory) {
foreach ($archiveConfig->subsites as $subsiteInfo) {
$oldSubsitePrefix = $subsiteInfo->blog_prefix;
// main prefix already done
if ($oldPrefix == $oldSubsitePrefix) {
continue;
}
$newSubsitePrefix = $archiveConfig->getSubsitePrefixByParam($subsiteInfo->id);
DUPX_Log::info('SUBSITE ID: '.DUPX_Log::varToString($subsiteInfo->id).' NEW SUBSITE PREFIX:'.DUPX_Log::varToString($newSubsitePrefix), DUPX_Log::LV_DEBUG);
$optionsTable = $newSubsitePrefix.'options';
if (in_array($optionsTable, $tables)) {
DUPX_Log::info('UPDATE PREFIX IN TABLE '.DUPX_Log::varToString($optionsTable), DUPX_Log::LV_DETAILED);
self::updateTablePrefix($dbh, $optionsTable, 'option_name', $oldSubsitePrefix, $newSubsitePrefix);
} else {
DUPX_Log::info('CAN\'T UPDATE PREFIX IN TABLE '.DUPX_Log::varToString($optionsTable).' BACAUSE TABLE NOT IN LIST');
}
}
}
return true;
}
}