function connect($server, $db, $user, $password, $socketPath, $charset = null, $port = false)
{
$connection = false;
if ($socketPath !== false) {
ini_set("mysqli.default_socket", $socketPath);
}
if ($this->UsePersistentConnection == true) {
// Only supported on PHP 5.3 (mysqlnd)
if (version_compare(PHP_VERSION, '5.3') > 0) {
$this->Server = 'p:' . $this->Server;
} else {
eZDebug::writeWarning('mysqli only supports persistent connections when using php 5.3 and higher', 'eZMySQLiDB::connect');
}
}
eZPerfLogger::accumulatorStart('mysqli_connection', 'mysqli_total', 'Database connection');
$connection = mysqli_connect($server, $user, $password, null, (int) $port, $socketPath);
$dbErrorText = mysqli_connect_error();
eZPerfLogger::accumulatorStop('mysqli_connection');
$maxAttempts = $this->connectRetryCount();
$waitTime = $this->connectRetryWaitTime();
$numAttempts = 1;
while (!$connection && $numAttempts <= $maxAttempts) {
sleep($waitTime);
eZPerfLogger::accumulatorStart('mysqli_connection', 'mysqli_total', 'Database connection');
$connection = mysqli_connect($this->Server, $this->User, $this->Password, null, (int) $this->Port, $this->SocketPath);
eZPerfLogger::accumulatorStop('mysqli_connection');
$numAttempts++;
}
$this->setError();
$this->IsConnected = true;
if (!$connection) {
eZDebug::writeError("Connection error: Couldn't connect to database. Please try again later or inform the system administrator.\n{$dbErrorText}", __CLASS__);
$this->IsConnected = false;
throw new eZDBNoConnectionException($server);
}
if ($this->IsConnected && $db != null) {
eZPerfLogger::accumulatorStart('mysqli_connection', 'mysqli_total', 'Database connection');
$ret = mysqli_select_db($connection, $db);
eZPerfLogger::accumulatorStop('mysqli_connection');
if (!$ret) {
//$this->setError();
eZDebug::writeError("Connection error: " . mysqli_errno($connection) . ": " . mysqli_error($connection), "eZMySQLiDB");
$this->IsConnected = false;
}
}
if ($charset !== null) {
$originalCharset = $charset;
$charset = eZCharsetInfo::realCharsetCode($charset);
}
if ($this->IsConnected and $charset !== null) {
eZPerfLogger::accumulatorStart('mysqli_connection', 'mysqli_total', 'Database connection');
$status = mysqli_set_charset($connection, eZMySQLCharset::mapTo($charset));
eZPerfLogger::accumulatorStop('mysqli_connection');
if (!$status) {
$this->setError();
eZDebug::writeWarning("Connection warning: " . mysqli_errno($connection) . ": " . mysqli_error($connection), "eZMySQLiDB");
}
}
return $connection;
}
function eZCodePageMapper( $input_charset_code, $output_charset_code, $use_cache = true )
{
$this->RequestedInputCharsetCode = $input_charset_code;
$this->InputCharsetCode = eZCharsetInfo::realCharsetCode( $input_charset_code );
$this->RequestedOutputCharsetCode = $output_charset_code;
$this->OutputCharsetCode = eZCharsetInfo::realCharsetCode( $output_charset_code );
$this->Valid = false;
$this->load( $use_cache );
$this->setSubstituteCharacter( 63 ); // ?
}
function transformByGroup($text, $group, $charset = false, $useCache = true)
{
if ($text === '') {
return $text;
}
$charsetName = $charset === false ? eZTextCodec::internalCharset() : eZCharsetInfo::realCharsetCode($charset);
if ($useCache) {
// CRC32 is used for speed, MD5 would be more unique but is slower
$keyText = 'Group:' . $group;
$key = eZSys::ezcrc32($keyText . '-' . $charset);
$filepath = $this->cacheFilePath('g-' . $group . '-', '-' . $charsetName, $key);
// Try to execute code in the cache file, if it succeeds
// \a $text will/ transformated
$retText = $this->executeCacheFile($text, $filepath);
if ($retText !== false) {
return $retText;
}
}
$commands = $this->groupCommands($group);
if ($commands === false) {
return false;
}
$mapper = new eZCodeMapper();
$mapper->loadTransformationFiles($charsetName, $group);
$rules = array();
foreach ($commands as $command) {
$rules = array_merge($rules, $mapper->decodeCommand($command['command'], $command['parameters']));
}
// First generate a unicode based mapping table from the rules
$unicodeTable = $mapper->generateMappingCode($rules);
unset($unicodeTable[0]);
// Then transform that to a table that works with the current charset
// Any character not available in the current charset will be removed
$charsetTable = $mapper->generateCharsetMappingTable($unicodeTable, $charset);
$transformationData = array('table' => $charsetTable);
unset($unicodeTable);
if ($useCache) {
$extraCode = '';
foreach ($commands as $command) {
$code = $mapper->generateCommandCode($command, $charsetName);
if ($code !== false) {
$extraCode .= $code . "\n";
}
}
$this->storeCacheFile($filepath, $transformationData, $extraCode, 'Group:' . $group, $charsetName);
}
// Execute transformations
$text = strtr($text, $transformationData['table']);
// Execute custom code
foreach ($commands as $command) {
$mapper->executeCommandCode($text, $command, $charsetName);
}
return $text;
}
function domString($domDocument)
{
$ini = eZINI::instance();
$xmlCharset = $ini->variable('RegionalSettings', 'ContentXMLCharset');
if ($xmlCharset == 'enabled') {
$charset = eZTextCodec::internalCharset();
} else {
if ($xmlCharset == 'disabled') {
$charset = true;
} else {
$charset = $xmlCharset;
}
}
if ($charset !== true) {
$charset = eZCharsetInfo::realCharsetCode($charset);
}
$domString = $domDocument->saveXML();
return $domString;
}
/**
* @param \eZLocale $primaryLanguage
* @param \eZLocale[]|null $allLanguages
* @param bool $canUseUnicode
* @return array
*/
function findAppropriateCharsetsList($primaryLanguage, $allLanguages, $canUseUnicode)
{
$commonCharsets = array();
if (is_array($allLanguages) and count($allLanguages) > 0) {
$language = $allLanguages[0];
$charsets = $language->allowedCharsets();
foreach ($charsets as $charset) {
$commonCharsets[] = eZCharsetInfo::realCharsetCode($charset);
}
$commonCharsets = array_unique($commonCharsets);
for ($i = 1; $i < count($allLanguages); ++$i) {
$language = $allLanguages[$i];
$charsets = $language->allowedCharsets();
$realCharsets = array();
foreach ($charsets as $charset) {
$realCharsets[] = eZCharsetInfo::realCharsetCode($charset);
}
$realCharsets = array_unique($realCharsets);
$commonCharsets = array_intersect($commonCharsets, $realCharsets);
}
}
$usableCharsets = array_values($commonCharsets);
if (count($usableCharsets) > 0) {
if (in_array($primaryLanguage->charset(), $usableCharsets)) {
array_unshift($usableCharsets, $primaryLanguage->charset());
$usableCharsets = array_unique($usableCharsets);
}
} else {
if ($canUseUnicode) {
$usableCharsets[] = eZCharsetInfo::realCharsetCode('utf-8');
}
}
return $usableCharsets;
}
function tableCharsetName( $charset )
{
$charset = eZCharsetInfo::realCharsetCode( $charset );
// Convert charset names into something MySQL will understand
$charsetMapping = array( 'iso-8859-1' => 'latin1',
'iso-8859-2' => 'latin2',
'iso-8859-8' => 'hebrew',
'iso-8859-7' => 'greek',
'iso-8859-9' => 'latin5',
'iso-8859-13' => 'latin7',
'windows-1250' => 'cp1250',
'windows-1251' => 'cp1251',
'windows-1256' => 'cp1256',
'windows-1257' => 'cp1257',
'utf-8' => 'utf8',
'koi8-r' => 'koi8r',
'koi8-u' => 'koi8u' );
$charset = strtolower( $charset );
if ( isset( $charsetMapping[$charset] ) )
return $charsetMapping[$charset];
return $charset;
}
if ( $http->hasPostVariable( 'TemplateContent' ) )
{
$templateContent = $http->postVariable( 'TemplateContent' );
if ( $templateConfig->variable( 'CharsetSettings', 'AutoConvertOnSave') == 'enabled' )
{
$outputCharset = eZCharsetInfo::realCharsetCode( $outputCharset );
if ( preg_match( '|{\*\?template.*charset=([a-zA-Z0-9-]*).*\?\*}|', $templateContent, $matches ) )
{
$templateContent = preg_replace( '|({\*\?template.*charset=)[a-zA-Z0-9-]*(.*\?\*})|',
'\\1'. $outputCharset. '\\2',
$templateContent );
}
else
{
$templateCharset = eZCharsetInfo::realCharsetCode( $templateConfig->variable( 'CharsetSettings', 'DefaultTemplateCharset') );
if ( $templateCharset != $outputCharset )
$templateContent = "{*?template charset=$outputCharset?*}\n" . $templateContent;
}
}
else
{
/* Here we figure out the characterset of the template. If there is a charset
* associated with the template in the header we use that one, if not we fall
* back to the INI setting "DefaultTemplateCharset". */
if ( preg_match( '|{\*\?template.*charset=([a-zA-Z0-9-]*).*\?\*}|', $templateContent, $matches ) )
{
$templateCharset = $matches[1];
}
else
{
function checkCharsetPriv( $charset, &$currentCharset )
{
$query = "SHOW CREATE DATABASE `{$this->DB}`";
$status = mysql_query( $query, $this->DBConnection );
$this->reportQuery( __CLASS__, $query, false, false );
if ( !$status )
{
$this->setError();
eZDebug::writeWarning( "Connection warning: " . mysql_errno( $this->DBConnection ) . ": " . mysql_error( $this->DBConnection ), "eZMySQLDB" );
return false;
}
$numRows = mysql_num_rows( $status );
if ( $numRows == 0 )
return false;
for ( $i = 0; $i < $numRows; ++$i )
{
$tmpRow = mysql_fetch_array( $status, MYSQL_ASSOC );
if ( $tmpRow['Database'] == $this->DB )
{
$createText = $tmpRow['Create Database'];
if ( preg_match( '#DEFAULT CHARACTER SET ([a-zA-Z0-9_-]+)#', $createText, $matches ) )
{
$currentCharset = $matches[1];
$currentCharset = eZCharsetInfo::realCharsetCode( $currentCharset );
// Convert charset names into something MySQL will understand
$unmappedCurrentCharset = eZMySQLCharset::mapFrom( $currentCharset );
if ( is_array( $charset ) )
{
if ( in_array( $unmappedCurrentCharset, $charset ) )
{
return $unmappedCurrentCharset;
}
}
else if ( $unmappedCurrentCharset == $charset )
{
return true;
}
return false;
}
break;
}
}
return true;
}
function isAllowedCharset( $charset )
{
$realCharset = eZCharsetInfo::realCharsetCode( $charset );
$charsets = $this->allowedCharsets();
foreach ( $charsets as $charsetName )
{
$realName = eZCharsetInfo::realCharsetCode( $charsetName );
if ( $realName == $realCharset )
return true;
}
return false;
}
static function httpCharset()
{
$realCharset =& $GLOBALS['eZTextCodecHTTPCharsetReal'];
if (!isset($realCharset)) {
$charset = '';
if (isset($GLOBALS['eZTextCodecHTTPCharset'])) {
$charset = $GLOBALS['eZTextCodecHTTPCharset'];
}
if ($charset == '') {
if (isset($GLOBALS['eZTextCodecInternalCharsetReal'])) {
$realCharset = $GLOBALS['eZTextCodecInternalCharsetReal'];
} else {
$realCharset = eZTextCodec::internalCharset();
}
} else {
$realCharset = eZCharsetInfo::realCharsetCode($charset);
}
}
return $realCharset;
}
function loadTransformationFiles($currentCharset, $transformationGroup)
{
$ini = eZINI::instance('transform.ini');
$repositoryList = array($ini->variable('Transformation', 'Repository'));
$files = $ini->variable('Transformation', 'Files');
$extensions = $ini->variable('Transformation', 'Extensions');
$repositoryList = array_merge($repositoryList, eZExtension::expandedPathList($extensions, 'transformations'));
// Check if the current charset maps to a unicode group
// If it does it can trigger loading of additional files
$unicodeGroups = array();
$charsets = $ini->variable('Transformation', 'Charsets');
foreach ($charsets as $entry) {
list($charset, $group) = explode(';', $entry, 2);
$charset = eZCharsetInfo::realCharsetCode($charset);
if ($charset == $currentCharset) {
if (!in_array($group, $unicodeGroups)) {
$unicodeGroups[] = $group;
}
}
}
// If we are using transformation groups then add that as
// a unicode group. This causes it load transformation files
// specific to that group.
if ($transformationGroup !== false) {
$unicodeGroups[] = $transformationGroup;
}
// Add any extra files from the unicode groups
foreach ($unicodeGroups as $unicodeGroup) {
if ($ini->hasGroup($unicodeGroup)) {
$files = array_merge($files, $ini->variable($unicodeGroup, 'Files'));
$extensions = $ini->variable($unicodeGroup, 'Extensions');
$repositoryList = array_merge($repositoryList, eZExtension::expandedPathList($extensions, 'transformations'));
}
}
foreach ($files as $file) {
// Only load files that are not currently loaded
if ($this->isTranformationLoaded($file)) {
continue;
}
foreach ($repositoryList as $repository) {
$trFile = $repository . '/' . $file;
if (file_exists($trFile)) {
$this->parseTransformationFile($trFile, $file);
}
}
}
}
function cacheFileName($charset_code)
{
$permissionArray = eZCodePage::permissionSetting();
if ($permissionArray === false) {
return false;
}
$charset_code = eZCharsetInfo::realCharsetCode($charset_code);
$cache_dir = $permissionArray['var_directory'] . "/codepages/";
$cache_filename = md5($charset_code);
$cache = $cache_dir . $cache_filename . ".php";
return $cache;
}
function isCharsetSupported( $charset_code )
{
$charset_code = eZCharsetInfo::realCharsetCode( $charset_code );
return in_array( $charset_code, eZMBStringMapper::charsetList() );
}
static function characterEncodingScheme($charsetCode, $isRealCharset = false)
{
if (!$isRealCharset) {
$charsetCode = eZCharsetInfo::realCharsetCode($charsetCode);
}
$reverseEncodingTable =& eZCharsetInfo::reverseEncodingTable();
if (isset($reverseEncodingTable[$charsetCode])) {
return $reverseEncodingTable[$charsetCode];
}
return 'singlebyte';
}