//
// String
//
static void FmtString(StringBuffer & oBuffer,
const CDT & oCurrentArgument,
const UINT_32 iFmtFlags,
const INT_32 iWidth,
const INT_32 iMaxChars,
CHAR_8 chPadSymbol)
{
const STLW::string sTMP = oCurrentArgument.GetString();
INT_32 iFormatSize = sTMP.size();
if (iFormatSize > iMaxChars && iMaxChars > 0) { iFormatSize = iMaxChars; }
if (iFmtFlags & F_LEFT_ALIGN)
{
oBuffer.Append(sTMP.data(), iFormatSize);
if (iWidth > iFormatSize) { oBuffer.Append(iWidth - iFormatSize, chPadSymbol); }
}
else
{
if (iWidth > iFormatSize) { oBuffer.Append(iWidth - iFormatSize, chPadSymbol); }
oBuffer.Append(sTMP.data(), iFormatSize);
}
}
//
// Handler
//
INT_32 FnMBTruncate::Handler(CDT * aArguments,
const UINT_32 iArgNum,
CDT & oCDTRetVal,
Logger & oLogger)
{
if (iArgNum == 2)
{
const UINT_32 iMaxLen = UINT_32(aArguments[0].GetInt());
const STLW::string sData = aArguments[1].GetString();
CCHAR_P szStart = sData.data();
CCHAR_P szEnd = sData.data() + sData.size();
INT_32 iPos = 0;
UINT_32 iCharPos = 0;
for(;;)
{
INT_32 iCharLen = utf_charlen(szStart + iPos, szEnd);
if (iCharLen == -3) { break; }
// Check character length
if (iCharLen < 0) { iCharLen = 1; }
// Skip errors
else { ++iCharPos; }
iPos += iCharLen;
if (iCharPos >= iMaxLen) { break; }
}
if (iCharPos == iMaxLen) { oCDTRetVal = STLW::string(sData, 0, iPos); }
else { oCDTRetVal = sData; }
return 0;
}
else if (iArgNum == 3)
{
const UINT_32 iMaxLen = UINT_32(aArguments[1].GetInt());
STLW::string sData = aArguments[2].GetString();
CCHAR_P szStart = sData.data();
CCHAR_P szEnd = sData.data() + sData.size();
INT_32 iPos = 0;
UINT_32 iCharPos = 0;
for(;;)
{
INT_32 iCharLen = utf_charlen(szStart + iPos, szEnd);
if (iCharLen == -3) { break; }
// Check character length
if (iCharLen < 0) { iCharLen = 1; }
// Skip errors
else { ++iCharPos; }
iPos += iCharLen;
if (iCharPos >= iMaxLen) { break; }
}
if (iCharPos >= iMaxLen)
{
sData = STLW::string(sData, 0, iPos);
sData.append(aArguments[0].GetString());
}
oCDTRetVal = sData;
return 0;
}
oLogger.Emerg("Usage: MB_TRUNCATE(data, offset) or MB_TRUNCATE(data, offset, add_on)");
return -1;
}
INT_32 FormatString(const STLW::string & sFormatString, STLW::string & sResult, const CDT & oArgs)
{
using namespace CTPP;
StringBuffer oBuffer(sResult);
CCHAR_P sPos = sFormatString.data();
CCHAR_P sEnd = sFormatString.data() + sFormatString.size();
CCHAR_P sEndSave = sPos;
UINT_32 iPos = 0;
for(;;)
{
INT_32 iWidth = -1;
INT_32 iPrecision = -1;
CHAR_8 chPadSymbol = ' ';
UINT_32 iFmtFlags = 0;
eFmtLengths oFmtLengths = F_NONE;
eParserState oParserState = C_INITIAL_STATE;
// Find "%" at start of token
while(sPos != sEnd)
{
if (*sPos == '%')
{
oParserState = C_START_FOUND;
break;
}
++sPos;
}
oBuffer.Append(sEndSave, sPos);
if (oParserState == C_START_FOUND)
{
++sPos;
// Check end of string
if (sPos == sEnd) { return -1; }
bool bEndCycle = false;
while (!bEndCycle)
{
// Flags
switch(*sPos)
{
// '-' Left-justify within the given field width; Right justification is the default (see width sub-specifier).
case '-':
iFmtFlags |= F_LEFT_ALIGN;
++sPos;
break;
// '+' Forces to preceed the result with a plus or minus sign (+ or -) even for positive numbers.
// By default, only negative numbers are preceded with a - sign.
case '+':
iFmtFlags |= F_FORCE_SIGN;
iFmtFlags &= ~F_SIGN_SPACE;
++sPos;
break;
// ' ' (space) If no sign is going to be written, a blank space is inserted before the value.
case ' ':
iFmtFlags |= F_SIGN_SPACE;
iFmtFlags &= ~F_FORCE_SIGN;
++sPos;
break;
// '#' Used with o, x or X specifiers the value is preceeded with 0, 0x or 0X respectively for values different than zero.
// Used with e, E and f, it forces the written output to contain a decimal point even if no digits would follow.
// By default, if no digits follow, no decimal point is written.
// Used with g or G the result is the same as with e or E but trailing zeros are not removed.
case '#':
iFmtFlags |= F_HASH_SIGN;
++sPos;
break;
// '0' Left-pads the number with zeroes (0) instead of spaces, where padding is specified (see width sub-specifier).
case '0':
chPadSymbol = '0';
++sPos;
break;
default:
bEndCycle = true;
break;
}
// Check end of string
if (sPos == sEnd) { return -1; }
}
/* Width
* number Minimum number of characters to be printed. If the value to be printed is shorter than this number,
* the result is padded with blank spaces. The value is not truncated even if the result is larger.
*/
if (*sPos > '0' && *sPos <= '9')
{
iWidth = 0;
while (sPos != sEnd && (*sPos >= '0' && *sPos <= '9'))
{
iWidth = iWidth * 10 + *sPos - '0';
++sPos;
}
}
/*
* '*' The width is not specified in the format string, but as an additional integer value argument
* preceding the argument that has to be formatted.
*/
else if (*sPos == '*')
{
iWidth = oArgs.GetCDT(iPos).GetInt();
++iPos;
++sPos;
}
// Check end of string
if (sPos == sEnd) { return -1; }
// .precision
if (*sPos == '.')
{
++sPos;
if (sPos == sEnd) { return -1; }
iPrecision = 0;
if (*sPos >= '0' && *sPos <= '9')
{
while (sPos != sEnd && (*sPos >= '0' && *sPos <= '9'))
{
iPrecision = iPrecision * 10 + *sPos - '0';
++sPos;
}
}
else if (*sPos == '*')
{
iPrecision = oArgs.GetCDT(iPos).GetInt();
++iPos;
++sPos;
}
}
// length
switch(*sPos)
{
// h The argument is interpreted as a short int or unsigned short int (only applies to integer specifiers: i, d, o, u, x and X).
case 'h':
oFmtLengths = F_SHORT;
++sPos;
break;
// l The argument is interpreted as a long int or unsigned long int for integer specifiers (i, d, o, u, x and X), and as a wide character or wide character string for specifiers c and s.
case 'l':
// L The argument is interpreted as a long double (only applies to floating point specifiers: e, E, f, g and G).
case 'L':
{
oFmtLengths = F_LONG;
++sPos;
if (sPos == sEnd) { return -1; }
if (*sPos == 'l' || *sPos == 'L')
{
oFmtLengths = F_LONG_LONG;
++sPos;
}
}
break;
}
// Check end of string
if (sPos == sEnd) { return -1; }
// Specifiers
// A % followed by another % character will write % to the string.
if (*sPos == '%') { oBuffer.Append(sPos, 1); }
else
{
const CDT oCurrentArgument = oArgs.GetCDT(iPos);
++iPos;
switch(*sPos)
{
// Character 'a'
case 'c':
FmtChar(oBuffer, oCurrentArgument, iFmtFlags, iWidth, chPadSymbol);
break;
// 'd' or 'i' Signed decimal integer '392'
case 'd':
case 'i':
FmtInt(oBuffer, oCurrentArgument, iFmtFlags, oFmtLengths, szDigitsLc, F_DECIMAL, 10, iWidth, iPrecision, chPadSymbol);
break;
// Scientific notation (mantise/exponent) using e character '3.9265e+2'
case 'e':
FmtSci(oBuffer, oCurrentArgument, iFmtFlags, oFmtLengths, 'e', iWidth, iPrecision, chPadSymbol);
break;
// Scientific notation (mantise/exponent) using E character '3.9265E+2'
case 'E':
FmtSci(oBuffer, oCurrentArgument, iFmtFlags, oFmtLengths, 'E', iWidth, iPrecision, chPadSymbol);
break;
// Decimal floating point '392.65'
case 'f':
FmtFloat(oBuffer, oCurrentArgument, iFmtFlags, oFmtLengths, 'e', F_FLOAT_F, iWidth, iPrecision, chPadSymbol);
break;
// Use the shorter of %e or %f '392.65'
case 'g':
FmtFloat(oBuffer, oCurrentArgument, iFmtFlags, oFmtLengths, 'e', F_FLOAT_G, iWidth, iPrecision, chPadSymbol);
break;
case 'F':
FmtFloat(oBuffer, oCurrentArgument, iFmtFlags, oFmtLengths, 'E', F_FLOAT_F, iWidth, iPrecision, chPadSymbol);
break;
case 'G':
FmtFloat(oBuffer, oCurrentArgument, iFmtFlags, oFmtLengths, 'E', F_FLOAT_G, iWidth, iPrecision, chPadSymbol);
break;
// Signed octal '610'
case 'o':
FmtInt(oBuffer, oCurrentArgument, iFmtFlags, oFmtLengths, szDigitsLc, F_OCTAL, 8, iWidth, iPrecision, chPadSymbol);
break;
// String of characters 'sample'
case 's':
FmtString(oBuffer, oCurrentArgument, iFmtFlags, iWidth, iPrecision, chPadSymbol);
break;
// Unsigned decimal integer '7235'
case 'u':
FmtInt(oBuffer, oCurrentArgument, iFmtFlags, oFmtLengths, szDigitsLc, F_UNSIGNED, 10, iWidth, iPrecision, chPadSymbol);
break;
// Unsigned hexadecimal integer '7fa'
case 'x':
FmtInt(oBuffer, oCurrentArgument, iFmtFlags, oFmtLengths, szDigitsLc, F_HEX, 16, iWidth, iPrecision, chPadSymbol);
break;
// Unsigned hexadecimal integer (capital letters) 7FA
case 'X':
FmtInt(oBuffer, oCurrentArgument, iFmtFlags, oFmtLengths, szDigitsUc, F_HEX, 16, iWidth, iPrecision, chPadSymbol);
break;
// Pointer address 1a2b3c4e
case 'p':
FmtInt(oBuffer, oCurrentArgument, iFmtFlags, oFmtLengths, szDigitsLc, F_POINTER, 16, iWidth, iPrecision, chPadSymbol);
break;
// Invalid format; return error code
default:
return -1;
}
++sPos;
}
sEndSave = sPos;
}
if (sPos == sEnd) { break; }
}
oBuffer.Flush();
return 0;
}
void CTPP2::output(zval *out, Bytecode *bytecode, const char *src_enc, const char *dst_enc) {
unsigned int IP = 0;
if (!bytecode || !bytecode->check()) {
error = CTPPError("", "Invalid Bytecode", CTPP_VM_ERROR | STL_UNKNOWN_ERROR, 0, 0, IP);
} else {
try {
if (charset.convert || (src_enc && dst_enc)) {
STLW::string src_charset, dst_charset;
if (src_enc && dst_enc) {
src_charset = STLW::string(src_enc);
dst_charset = STLW::string(dst_enc);
} else {
src_charset = charset.src;
dst_charset = charset.dst;
}
STLW::string result;
CTPPPerlLogger logger;
StringIconvOutputCollector output_collector(result, src_charset, dst_charset, 3);
vm->Init(bytecode->getCode(), &output_collector, &logger);
vm->Run(bytecode->getCode(), &output_collector, IP, *params, &logger);
vm->Reset();
ZVAL_STRINGL(out, result.data(), result.length());
return;
} else {
CTPPPerlLogger logger;
if (out) {
// STLW::string result;
// StringOutputCollector output_collector(result);
// vm->Init(bytecode->getCode(), &output_collector, &logger);
// vm->Run(bytecode->getCode(), &output_collector, IP, *params, &logger);
// ZVAL_STRINGL(out, result.data(), result.length());
CTPPPHPVarOutputCollector output_collector(out);
vm->Init(bytecode->mem, &output_collector, &logger);
vm->Run(bytecode->mem, &output_collector, IP, *params, &logger);
} else {
CTPPPHPOutputCollector output_collector;
vm->Init(bytecode->mem, &output_collector, &logger);
vm->Run(bytecode->mem, &output_collector, IP, *params, &logger);
}
vm->Reset();
return;
}
} catch (ZeroDivision &e) {
error = CTPPError(e.GetSourceName(), e.what(), CTPP_VM_ERROR | CTPP_ZERO_DIVISION_ERROR, VMDebugInfo(e.GetDebugInfo()).GetLine(),
VMDebugInfo(e.GetDebugInfo()).GetLinePos(), e.GetIP());
} catch (ExecutionLimitReached &e) {
error = CTPPError(e.GetSourceName(), e.what(), CTPP_VM_ERROR | CTPP_EXECUTION_LIMIT_REACHED_ERROR, VMDebugInfo(e.GetDebugInfo()).GetLine(),
VMDebugInfo(e.GetDebugInfo()).GetLinePos(), e.GetIP());
} catch (CodeSegmentOverrun &e) {
error = CTPPError(e.GetSourceName(), e.what(), CTPP_VM_ERROR | CTPP_CODE_SEGMENT_OVERRUN_ERROR, VMDebugInfo(e.GetDebugInfo()).GetLine(),
VMDebugInfo(e.GetDebugInfo()).GetLinePos(), e.GetIP());
} catch (InvalidSyscall &e) {
if (e.GetIP() != 0) {
error = CTPPError(e.GetSourceName(), e.what(), CTPP_VM_ERROR | CTPP_INVALID_SYSCALL_ERROR, VMDebugInfo(e.GetDebugInfo()).GetLine(),
VMDebugInfo(e.GetDebugInfo()).GetLinePos(), e.GetIP());
} else {
error = CTPPError(e.GetSourceName(), STLW::string("Unsupported syscall: \"") + e.what() + "\"", CTPP_VM_ERROR | CTPP_INVALID_SYSCALL_ERROR,
VMDebugInfo(e.GetDebugInfo()).GetLine(), VMDebugInfo(e.GetDebugInfo()).GetLinePos(), e.GetIP());
}
} catch (IllegalOpcode &e) {
error = CTPPError(e.GetSourceName(), e.what(), CTPP_VM_ERROR | CTPP_ILLEGAL_OPCODE_ERROR, VMDebugInfo(e.GetDebugInfo()).GetLine(),
VMDebugInfo(e.GetDebugInfo()).GetLinePos(), e.GetIP());
} catch (StackOverflow &e) {
error = CTPPError(e.GetSourceName(), e.what(), CTPP_VM_ERROR | CTPP_STACK_OVERFLOW_ERROR, VMDebugInfo(e.GetDebugInfo()).GetLine(),
VMDebugInfo(e.GetDebugInfo()).GetLinePos(), e.GetIP());
} catch (StackUnderflow &e) {
error = CTPPError(e.GetSourceName(), e.what(), CTPP_VM_ERROR | CTPP_STACK_UNDERFLOW_ERROR, VMDebugInfo(e.GetDebugInfo()).GetLine(),
VMDebugInfo(e.GetDebugInfo()).GetLinePos(), e.GetIP());
} catch (VMException &e) {
error = CTPPError(e.GetSourceName(), e.what(), CTPP_VM_ERROR | CTPP_VM_GENERIC_ERROR, VMDebugInfo(e.GetDebugInfo()).GetLine(),
VMDebugInfo(e.GetDebugInfo()).GetLinePos(), e.GetIP());
} catch (CTPPUnixException &e) {
error = CTPPError("", e.what(), CTPP_VM_ERROR | CTPP_UNIX_ERROR, 0, 0, IP);
} catch (CDTRangeException &e) {
error = CTPPError("", e.what(), CTPP_VM_ERROR | CTPP_RANGE_ERROR, 0, 0, IP);
} catch (CDTAccessException &e) {
error = CTPPError("", e.what(), CTPP_VM_ERROR | CTPP_ACCESS_ERROR, 0, 0, IP);
} catch (CDTTypeCastException &e) {
error = CTPPError("", e.what(), CTPP_VM_ERROR | CTPP_TYPE_CAST_ERROR, 0, 0, IP);
} catch (CTPPLogicError &e) {
error = CTPPError("", e.what(), CTPP_VM_ERROR | CTPP_LOGIC_ERROR, 0, 0, IP);
} catch(CTPPCharsetRecodeException &e) {
error = CTPPError("", e.what(), CTPP_VM_ERROR | CTPP_CHARSET_RECODE_ERROR, 0, 0, 0);
} catch (CTPPException &e) {
error = CTPPError("", e.what(), CTPP_VM_ERROR | CTPP_UNKNOWN_ERROR, 0, 0, IP);
} catch (STLW::exception &e) {
error = CTPPError("", e.what(), CTPP_VM_ERROR | STL_UNKNOWN_ERROR, 0, 0, IP);
} catch (...) {
error = CTPPError("", "Unknown Error", CTPP_VM_ERROR | STL_UNKNOWN_ERROR, 0, 0, IP);
}
}
vm->Reset();
if (error.line > 0) {
php_error(E_WARNING, "CTPP2::output(): %s (error code 0x%08X); IP: 0x%08X, file %s line %d pos %d", error.error_descr.c_str(),
error.error_code, error.ip, error.template_name.c_str(), error.line, error.pos);
} else {
php_error(E_WARNING, "CTPP2::output(): %s (error code 0x%08X); IP: 0x%08X", error.error_descr.c_str(), error.error_code, error.ip);
}
if (out)
ZVAL_BOOL(out, 0);
}
//
// Handler
//
INT_32 FnMBSubstring::Handler(CDT * aArguments,
const UINT_32 iArgNum,
CDT & oCDTRetVal,
Logger & oLogger)
{
// Check number of parameters
if (iArgNum == 0) { oCDTRetVal = ""; return 0; }
// substr('foobar', 2) -> 'obar'
if (iArgNum == 2)
{
const UINT_32 iOffset = UINT_32(aArguments[0].GetInt());
const STLW::string sResult = aArguments[1].GetString();
CCHAR_P szStart = sResult.data();
CCHAR_P szEnd = sResult.data() + sResult.size();
INT_32 iPos = 0;
UINT_32 iCharPos = 0;
for(;;)
{
INT_32 iCharLen = utf_charlen(szStart + iPos, szEnd);
if (iCharLen == -3) { break; }
// Check character length
if (iCharLen < 0) { iCharLen = 1; }
// Skip errors
else { ++iCharPos; }
iPos += iCharLen;
if (iCharPos >= iOffset) { break; }
}
if (iCharPos < iOffset) { oCDTRetVal = ""; }
else { oCDTRetVal = sResult.substr(iPos); }
return 0;
}
// substr('foobar', 2, 3) -> 'oba'
if (iArgNum == 3)
{
const UINT_32 iBytes = UINT_32(aArguments[0].GetInt());
const UINT_32 iOffset = UINT_32(aArguments[1].GetInt());
const STLW::string sResult = aArguments[2].GetString();
CCHAR_P szStart = sResult.data();
CCHAR_P szEnd = sResult.data() + sResult.size();
INT_32 iPos = 0;
UINT_32 iCharOffset = 0;
UINT_32 iCharPos = 0;
for(;;)
{
INT_32 iCharLen = utf_charlen(szStart + iPos, szEnd);
if (iCharLen == -3) { break; }
// Check character length
if (iCharLen < 0) { iCharLen = 1; }
// Skip errors
else { ++iCharPos; }
iPos += iCharLen;
if (iCharPos == iOffset) { iCharOffset = iPos; }
if (iCharPos == iOffset + iBytes) { break; }
}
if (sResult.size() < iCharOffset) { oCDTRetVal = ""; }
else { oCDTRetVal = sResult.substr(iCharOffset, iPos - iCharOffset); }
return 0;
}
// substr('foobar', 2, 3, '1234567') -> 'fo1234567r'
if (iArgNum == 4)
{
STLW::string sReplacement = aArguments[0].GetString();
const UINT_32 iBytes = UINT_32(aArguments[1].GetInt());
const UINT_32 iOffset = UINT_32(aArguments[2].GetInt());
const STLW::string sTMP = aArguments[3].GetString();
CCHAR_P szStart = sTMP.data();
CCHAR_P szEnd = sTMP.data() + sTMP.size();
UINT_32 iPos = 0;
UINT_32 iCharOffset = 0;
UINT_32 iCharPos = 0;
for(;;)
{
INT_32 iCharLen = utf_charlen(szStart + iPos, szEnd);
if (iCharLen == -3) { break; }
// Check character length
if (iCharLen < 0) { iCharLen = 1; }
// Skip errors
else { ++iCharPos; }
iPos += iCharLen;
if (iCharPos == iOffset) { iCharOffset = iPos; }
if (iCharPos == iOffset + iBytes) { break; }
}
if (sTMP.size() < iCharOffset) { oCDTRetVal = ""; return 0; }
STLW::string sResult(sTMP, 0, iCharOffset);
sResult.append(sReplacement);
if (iPos == sTMP.size()) { oCDTRetVal = sResult; return 0; }
sResult.append(sTMP, iPos, STLW::string::npos);
oCDTRetVal = sResult;
return 0;
}
oLogger.Emerg("Usage: MB_SUBSTR(x, offset[, bytes[, y]]])");
return -1;
}
//
// Load modules
//
INT_32 MainProcess::LoadModule(const STLW::string & sModuleType,
const STLW::string & sModuleName,
const STLW::string & sLibrary,
const STLW::string & sDriver,
const VariantNC & oModuleConfig,
const STLW::vector<STLW::string> & vLibexecDirs,
Logger & oLogger)
{
oLogger.Info("Opening `%s/%s` from library `%s`", sModuleType.c_str(), sModuleName.c_str(), sLibrary.c_str());
STLW::string sFullpath;
INT_32 iRC = FindFile(vLibexecDirs, sLibrary, sFullpath);
if (iRC == -1)
{
STLW::string sDirList;
STLW::vector<STLW::string>::const_iterator itvLibexecDirs = vLibexecDirs.begin();
for (;;)
{
sDirList += "`" + *itvLibexecDirs + "` ";
++itvLibexecDirs;
if (itvLibexecDirs == vLibexecDirs.end()) { break; }
sDirList += ", ";
}
oLogger.Emerg("Can't find library `%s` in LibexecDirs(%s) ", sLibrary.c_str(), sDirList.c_str());
return -1;
}
oLogger.Info("Library `%s` found here: `%s`", sLibrary.c_str(), sFullpath.c_str());
Object * pObject = oGlobalContext.loader.GetObject(sFullpath.c_str(), sDriver.c_str());
if (pObject == NULL)
{
oLogger.Emerg("Can't load object `%s` from file `%s`", sDriver.c_str(), sFullpath.c_str());
return -1;
}
// Check type of object
const STLW::string sObjectType = pObject -> GetObjectType();
if (Unicode::CompareIgnoreCase(sObjectType.data(), sObjectType.size(), sModuleType.data(), sModuleType.size()) != 0)
{
oLogger.Emerg("Need type `%s`, but object `%s` loaded from file `%s` has type `%s`", sModuleType.c_str(), pObject -> GetObjectName(), sFullpath.c_str(), pObject -> GetObjectType());
delete pObject;
return -1;
}
oLogger.Info("Object `%s` with type `%s` loaded from file `%s`", pObject -> GetObjectName(), pObject -> GetObjectType(), sFullpath.c_str());
// Initialize module
iRC = static_cast<Module *>(pObject) -> InitModule(oGlobalContext, oModuleConfig, oSigHandler, oLogger);
if (iRC != 0)
{
oLogger.Emerg("Can't initialize module `%s` from file `%s`", sModuleName.c_str(), sFullpath.c_str());
delete pObject;
return -1;
}
const STLW::string sFullName = sModuleType + '/' + sModuleName;
vModules.push_back(sFullName);
// Store object in factory
if(oGlobalContext.factory.AddObject(sFullName, pObject) == NULL)
{
oLogger.Emerg("Can't add module `%s` from file `%s`", sModuleName.c_str(), sFullpath.c_str());
static_cast<Module *>(pObject) -> DestroyModule(oGlobalContext, oSigHandler, oLogger);
delete pObject;
return -1;
}
return 0;
}
//
// Initialize module
//
INT_32 FileLogger::InitModule(IRIS::GlobalContext & oGlobalContext,
const IRIS::VariantNC & oConfig,
IRIS::SignalHandler & oSigHandler,
IRIS::Logger & oLogger)
{
using namespace IRIS;
// Re-open log files
oSigHandler.RegisterHandler(SIGHUP, &oLoggerSignalHandler);
oSigHandler.RegisterHandler(SIGUSR1, &oLoggerSignalHandler);
oSigHandler.RegisterHandler(SIGUSR2, &oLoggerSignalHandler);
STLW::string sTMP = oConfig["LogLevel"].Str();
static CCHAR_P aPriorities[] = { "emerg", "alert", "crit", "error", "warn", "notice", "info", "debug", NULL };
static LogPriority::LogPriorities oPriorities[] = { LogPriority::LOG_EMERG, LogPriority::LOG_ALERT,
LogPriority::LOG_CRIT, LogPriority::LOG_ERROR,
LogPriority::LOG_WARNING, LogPriority::LOG_NOTICE,
LogPriority::LOG_INFO, LogPriority::LOG_DEBUG };
oActualPriority = oBasePriority = LogPriority::LOG_DEBUG;
CCHAR_P * aPriority = aPriorities;
IRIS::LogPriority::LogPriorities * oPriority = oPriorities;
while (*aPriority != NULL)
{
if (Unicode::CompareIgnoreCase(sTMP.data(), sTMP.size(), *aPriority, strlen(*aPriority)) == 0)
{
oActualPriority = oBasePriority = *oPriority;
break;
}
++aPriority;
++oPriority;
}
iErrorLogBufferSize = iCustomLogBufferSize = -1;
sErrorLogFormat.assign(oConfig["ErrorLogFormat"]);
if (sErrorLogFormat.empty())
{
oLogger.Emerg("Configuration is broken: parameter %s/%s/ErrorLogFormat not set", GetObjectType(), GetObjectName());
return -1;
}
sErrorLogFile.assign(oConfig["ErrorLog"]);
if (sErrorLogFile.empty())
{
oLogger.Emerg("Configuration is broken: parameter %s/%s/ErrorLog not set", GetObjectType(), GetObjectName());
return -1;
}
sCustomLogFormat.assign(oConfig["CustomLogFormat"]);
if (sCustomLogFormat.empty())
{
oLogger.Emerg("Configuration is broken: parameter %s/%s/CustomLogFormat not set", GetObjectType(), GetObjectName());
return -1;
}
sCustomLogFile.assign(oConfig["CustomLog"]);
if (sCustomLogFile.empty())
{
oLogger.Emerg("Configuration is broken: parameter `%s/%s/CustomLog` not set", GetObjectType(), GetObjectName());
return -1;
}
// Error log permissions
char * pEnd = NULL;
iErrorLogPerms = strtol(oConfig["ErrorLogPerms"].Str().c_str(), &pEnd, 8);
if (iErrorLogPerms == 0) { oLogger.Info("Parameter `%s/%s/ErrorLogPerms` not set", GetObjectType(), GetObjectName()); }
// User and group
ConfigHelper::State oConfRC = ConfigHelper::ParseUserGroup(oConfig["ErrorLogOwner"],
sErrorLogUser,
iErrorLogUID,
sErrorLogGroup,
iErrorLogGID);
switch(oConfRC)
{
case ConfigHelper::NOT_NEED:
oLogger.Info("Parameter `%s/%s/ErrorLogOwner` is useful only if Iris starting from root user", GetObjectType(), GetObjectName());
break;
case ConfigHelper::CONFIG_ERROR:
oLogger.Info("Parameter `%s/%s/ErrorLogOwner` not set", GetObjectType(), GetObjectName());
break;
case ConfigHelper::NO_SUCH_USER:
oLogger.Emerg("Parameter `%s/%s/ErrorLogOwner`: no such user: `%s`", GetObjectType(), GetObjectName(), sErrorLogUser.c_str());
return -1;
case ConfigHelper::NO_SUCH_GROUP:
oLogger.Emerg("Parameter `%s/%s/ErrorLogOwner`: no such group: `%s`", GetObjectType(), GetObjectName(), sErrorLogGroup.c_str());
return -1;
default:
;;
}
// Buffer size for error log
iErrorLogBufferSize = ConfigHelper::ParseSize(oConfig["ErrorLogBufferSize"]);
if (iErrorLogBufferSize == 0) { oLogger.Info("Parameter `%s/%s/ErrorLogBufferSize` not set", GetObjectType(), GetObjectName()); }
// Error log permissions
iCustomLogPerms = strtol(oConfig["CustomLogPerms"].Str().c_str(), &pEnd, 8);
if (iCustomLogPerms == 0) { oLogger.Info("Parameter `%s/%s/CustomLogPerms` not set", GetObjectType(), GetObjectName()); }
// User and group
oConfRC = ConfigHelper::ParseUserGroup(oConfig["CustomLogOwner"],
sCustomLogUser,
iCustomLogUID,
sCustomLogGroup,
iCustomLogGID);
switch(oConfRC)
{
case ConfigHelper::NOT_NEED:
oLogger.Info("Parameter `%s/%s/CustomLogOwner` is useful only if Iris starting from root user", GetObjectType(), GetObjectName());
break;
case ConfigHelper::CONFIG_ERROR:
oLogger.Info("Parameter `%s/%s/CustomLogOwner` not set", GetObjectType(), GetObjectName());
break;
case ConfigHelper::NO_SUCH_USER:
oLogger.Emerg("Parameter `%s/%s/CustomLogOwner`: no such user: `%s`", GetObjectType(), GetObjectName(), sErrorLogUser.c_str());
return -1;
case ConfigHelper::NO_SUCH_GROUP:
oLogger.Emerg("Parameter `%s/%s/CustomLogOwner`: no such group: `%s`", GetObjectType(), GetObjectName(), sErrorLogGroup.c_str());
return -1;
default:
;;
}
// Buffer size for custom log
iCustomLogBufferSize = ConfigHelper::ParseSize(oConfig["CustomLogBufferSize"]);
if (iCustomLogBufferSize == 0) { oLogger.Info("Parameter `%s/%s/CustomLogBufferSize` not set", GetObjectType(), GetObjectName()); }
// Try to open log files
oLogger.Info("%s/%s: Try to open log file `%s`", GetObjectType(), GetObjectName(), sErrorLogFile.c_str());
iErrorLogFileHandle = File::Open(sErrorLogFile.c_str(), OpenMode::WRITE | OpenMode::CREATE | OpenMode::APPEND);
if (iErrorLogFileHandle == -1)
{
oLogger.Emerg("%s/%s: Can't open file `%s`: %s", GetObjectType(), GetObjectName(), sErrorLogFile.c_str(), Debug::PrintableError(SystemVars::ErrNo()).c_str());
return -1;
}
// Change permissions and owner
if (iErrorLogPerms != 0) { File::Chmod(iErrorLogFileHandle, iErrorLogPerms); }
if (iErrorLogUID != 0) { File::Chown(iErrorLogFileHandle, iErrorLogUID, iErrorLogGID); }
// Try to open log files
oLogger.Info("%s/%s: Try to open log file `%s`", GetObjectType(), GetObjectName(), sCustomLogFile.c_str());
iCustomLogFileHandle = File::Open(sCustomLogFile.c_str(), OpenMode::WRITE | OpenMode::CREATE | OpenMode::APPEND);
if (iCustomLogFileHandle == -1)
{
oLogger.Emerg("%s/%s: Can't open file `%s`: %s", GetObjectType(), GetObjectName(), sCustomLogFile.c_str(), Debug::PrintableError(SystemVars::ErrNo()).c_str());
File::Close(iErrorLogFileHandle);
iErrorLogFileHandle = iCustomLogFileHandle = -1;
return -1;
}
if (iCustomLogPerms != 0) { File::Chmod(iCustomLogFileHandle, iCustomLogPerms); }
if (iCustomLogUID != 0) { File::Chown(iCustomLogFileHandle, iCustomLogUID, iCustomLogGID); }
// Create writers
pErrorLogWriter = new LogWriter(iErrorLogFileHandle, iErrorLogBufferSize);
pCustomLogWriter = new LogWriter(iCustomLogFileHandle, iCustomLogBufferSize);
return 0;
}
//
// Compare two strings ingnore case
//
bool NoCaseCmp::operator()(const STLW::string oX, const STLW::string & oY) const
{
return Unicode::CompareIgnoreCase(oX.data(), oX.size(), oY.data(), oY.size()) < 0;
}