// // Handler // INT_32 FnTruncate::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(); if (sData.size() > iMaxLen) { oCDTRetVal = STLW::string(sData, 0, iMaxLen); } else { oCDTRetVal = sData; } return 0; } else if (iArgNum == 3) { const UINT_32 iMaxLen = UINT_32(aArguments[1].GetInt()); STLW::string sData = aArguments[2].GetString(); if (sData.size() > iMaxLen) { sData = STLW::string(sData, 0, iMaxLen); sData.append(aArguments[0].GetString()); } oCDTRetVal = sData; return 0; } oLogger.Emerg("Usage: TRUNCATE(x, offest[, addon])"); return -1; }
// CTPP2 CTPP2::CTPP2(unsigned int arg_stack_size, unsigned int code_stack_size, unsigned int steps_limit, unsigned int max_functions, STLW::string src_charset, STLW::string dst_charset) { try { params = new CDT(CDT::HASH_VAL); syscalls = new SyscallFactory(max_functions); STDLibInitializer::InitLibrary(*syscalls); vm = new VM(syscalls, arg_stack_size, code_stack_size, steps_limit); int i = 0; while (functions[i]) bind(functions[i++]()); if (src_charset.size() && dst_charset.size()) { charset.src = src_charset; charset.dst = dst_charset; charset.convert = true; } else { // Конвертирование не требуется charset.convert = false; } } catch (...) { cpp_free(params); if (syscalls) { STDLibInitializer::DestroyLibrary(*syscalls); cpp_free(syscalls); } cpp_free(vm); } }
int main(void) { CDT oArgs; oArgs.PushBack(101.5); oArgs.PushBack(101.4); STLW::string sResult; FormatString("_%0.2f_", sResult, oArgs); fwrite(sResult.c_str(), sResult.size(), 1, stdout); // make valgrind happy fclose(stdin); fclose(stdout); fclose(stderr); return EX_OK; }
// // 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); } }
int main(int argc, char ** argv) { const char * szConfigFile = NULL; if (argc == 1) { fprintf(stderr, "Global config not given, "); szConfigFile = getenv("CAS_GLOBAL_CONFIG"); if (szConfigFile != NULL) { fprintf(stderr, " using %s from ENVIRONMENT", szConfigFile); } else { szConfigFile = CAS_GLOBAL_CONFIG_FILE; fprintf(stderr, " using %s as DEFAULT\n", szConfigFile); } } else if (argc == 2) { szConfigFile = argv[1]; } else { fprintf(stderr, "usage: %s [global-config.xml]\n", argv[0]); return EX_USAGE; } FILE * F = fopen(szConfigFile, "rb"); if (F == NULL) { fprintf(stderr, "ERROR: Cannot open `%s` for reading: %s\n", szConfigFile, strerror(errno)); return EX_SOFTWARE; } // Store path to file as include directory CCHAR_P szTMP = szConfigFile + strlen(szConfigFile); while (szTMP != szConfigFile && *szTMP != '/' && *szTMP != '\\') { --szTMP; } STLW::vector<STLW::string> vIncludeDirs; if (szTMP != szConfigFile) { vIncludeDirs.push_back(STLW::string(szConfigFile, (szTMP - szConfigFile))); } try { ASGlobalConfig oGlobalConfig; ASGlobalConfigHandler oHandler(oGlobalConfig, vIncludeDirs); ASXMLParser oParser(&oHandler); if (oParser.ParseFile(F) == -1) { fprintf(stderr, "ERROR: In file %s: %s\n", szConfigFile, oHandler.GetError().c_str()); return EX_CONFIG; } fclose(F); fprintf(stdout, " Libexec dirs:\n"); UINT_32 iI = 0; for(; iI < oGlobalConfig.libexec_dirs.size(); ++iI) { fprintf(stdout, " %s\n", oGlobalConfig.libexec_dirs[iI].c_str()); } fprintf(stdout, "\n Modules:\n"); for(iI = 0; iI < oGlobalConfig.modules_list.size(); ++iI) { fprintf(stdout, " Name: %s\n" " Type: %s\n", oGlobalConfig.modules_list[iI].name.c_str(), oGlobalConfig.modules_list[iI].moduletype.c_str()); STLW::string sTMP = CheckFile(oGlobalConfig.libexec_dirs, oGlobalConfig.modules_list[iI].library); if (sTMP.size() == 0) { fprintf(stdout, " *** ERROR: Cannot find Library file: %s\n", oGlobalConfig.modules_list[iI].library.c_str()); } else { fprintf(stdout, " Library file: %s\n", CheckFile(oGlobalConfig.libexec_dirs, oGlobalConfig.modules_list[iI].library).c_str()); } STLW::string sData = Dump(oGlobalConfig.modules_list[iI].configuration); if (!sData.empty() && sData != "\"\"\n") { fprintf(stdout, " Configuration: %s\n", sData.c_str()); } // TBD fprintf(stdout, "\n"); } } catch(STLW::exception &e) { fprintf(stderr, "ERROR: %s\n", e.what()); return EX_SOFTWARE; } catch(...) { fprintf(stderr, "ERROR: Ouch!\n"); return EX_SOFTWARE; } fclose(stdin); fclose(stdout); fclose(stderr); return EX_OK; }
// Thread function static void * ThreadFunction(void * pContext) { ThreadContext * pThreadContext = (ThreadContext *)pContext; pthread_mutex_lock(&(pThreadContext -> output_mutex)); fprintf(stderr, "Initilalizing...\n"); pthread_mutex_unlock(&(pThreadContext -> output_mutex)); // Create per-thread VM instance // Syscall factory SyscallFactory * pSyscallFactory = new SyscallFactory(pThreadContext -> max_handlers); // Init standard library STDLibInitializer::InitLibrary(*pSyscallFactory); // Virtual machine VM * pVM = new VM(pSyscallFactory); // Okay, all done with thread-specific // Fill data CDT oData; oData["hello"] = "Hello, World!"; pthread_mutex_lock(&(pThreadContext -> output_mutex)); fprintf(stderr, "Okay, ready to work\n"); pthread_mutex_unlock(&(pThreadContext -> output_mutex)); FileLogger oLogger(stderr); // Perform some work const VMMemoryCore * pVMMemoryCore = NULL; for (UINT_32 iCount = 0; iCount < MAX_ITERATIONS; ++iCount) { STLW::string sResult; StringOutputCollector oDataCollector(sResult); // Get template, thread-safe pthread_mutex_lock(&(pThreadContext -> template_mutex)); STLW::map<STLW::string, VMFileLoader *>::iterator itLoader = pThreadContext -> templates.find("hello.ct2"); if (itLoader == pThreadContext -> templates.end()) { continue; } pVMMemoryCore = itLoader -> second -> GetCore(); pthread_mutex_unlock(&(pThreadContext -> template_mutex)); // Run VM pVM -> Init(pVMMemoryCore, &oDataCollector, &oLogger); UINT_32 iIP = 0; pVM -> Run(pVMMemoryCore, &oDataCollector, iIP, oData, &oLogger); // All done, print results pthread_mutex_lock(&(pThreadContext -> output_mutex)); fwrite(sResult.c_str(), sResult.size(), 1, stdout); pthread_mutex_unlock(&(pThreadContext -> output_mutex)); } delete pVM; delete pSyscallFactory; return NULL; }
// // 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; }
// // 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; }