/*********************************************************************\
Function name : WriteString
Description : writes a string without length information into a file
bReplace == true : ä ö ü will be replaced
Created at : 30.08.01, @ 10:35:54
Created by : Thomas Kunert
Modified by :
\*********************************************************************/
Bool WriteString(BaseFile* pFile, String str, Bool bReplace)
{
Int32 lPos, lStart = 0;
Int32 lLen = str.GetLength();
if (bReplace)
{
while (str.FindFirst('\"', &lPos, lStart))
{
str = str.SubStr(0, lPos) + "$\"" + str.SubStr(lPos + 1, lLen - lPos - 1);
lStart = lPos + 2;
lLen++;
}
}
lLen = str.GetCStringLen(STRINGENCODING_7BITHEX);
char* pCh = bNewDeprecatedUseArraysInstead<char>(lLen + 2);
str.GetCString(pCh, lLen + 1, STRINGENCODING_7BITHEX);
for (Int32 l = 0; l < lLen; l++)
pFile->WriteChar(pCh[l]);
bDelete(pCh);
return true;
}
ApiUser::Ptr ApiUser::GetByAuthHeader(const String& auth_header)
{
String::SizeType pos = auth_header.FindFirstOf(" ");
String username, password;
if (pos != String::NPos && auth_header.SubStr(0, pos) == "Basic") {
String credentials_base64 = auth_header.SubStr(pos + 1);
String credentials = Base64::Decode(credentials_base64);
String::SizeType cpos = credentials.FindFirstOf(":");
if (cpos != String::NPos) {
username = credentials.SubStr(0, cpos);
password = credentials.SubStr(cpos + 1);
}
}
const ApiUser::Ptr& user = ApiUser::GetByName(username);
/* Deny authentication if:
* 1) user does not exist
* 2) given password is empty
* 2) configured password does not match.
*/
if (!user || password.IsEmpty())
return nullptr;
else if (user && user->GetPassword() != password)
return nullptr;
return user;
}
String Type::GetPluralName(void) const
{
String name = GetName();
if (name.GetLength() >= 2 && name[name.GetLength() - 1] == 'y' &&
name.SubStr(name.GetLength() - 2, 1).FindFirstOf("aeiou") == String::NPos)
return name.SubStr(0, name.GetLength() - 1) + "ies";
else
return name + "s";
}
void StringReplace::FindAndReplace(String &str, const String &strFind, const String &strReplace)
{
Int32 lStart = 0;
Int32 lPos;
while (str.FindFirst(strFind, &lPos, lStart))
{
str = str.SubStr(0, lPos) + strReplace + str.SubStr(lPos + strFind.GetLength(), str.GetLength() - lPos - strFind.GetLength());
lStart = lPos;
}
}
void HttpConnection::ProcessMessageAsync(HttpRequest& request)
{
Log(LogInformation, "HttpConnection", "Processing Http message");
String auth_header = request.Headers->Get("authorization");
String::SizeType pos = auth_header.FindFirstOf(" ");
String username, password;
if (pos != String::NPos && auth_header.SubStr(0, pos) == "Basic") {
String credentials_base64 = auth_header.SubStr(pos + 1);
String credentials = Base64::Decode(credentials_base64);
String::SizeType cpos = credentials.FindFirstOf(":");
if (cpos != String::NPos) {
username = credentials.SubStr(0, cpos);
password = credentials.SubStr(cpos + 1);
}
}
ApiUser::Ptr user;
if (m_ApiUser)
user = m_ApiUser;
else {
user = ApiUser::GetByName(username);
if (!user || !user->CheckPassword(password))
user.reset();
}
HttpResponse response(m_Stream, request);
if (!user) {
response.SetStatus(401, "Unauthorized");
response.AddHeader("Content-Type", "text/html");
response.AddHeader("WWW-Authenticate", "Basic realm=\"Icinga 2\"");
String msg = "<h1>Unauthorized</h1>";
response.WriteBody(msg.CStr(), msg.GetLength());
} else {
try {
HttpHandler::ProcessRequest(user, request, response);
} catch (const std::exception& ex) {
response.SetStatus(503, "Unhandled exception");
response.AddHeader("Content-Type", "text/plain");
String errorInfo = DiagnosticInformation(ex);
response.WriteBody(errorInfo.CStr(), errorInfo.GetLength());
}
}
response.Finish();
m_PendingRequests--;
}
Url::Url(const String& base_url)
{
String url = base_url;
if (url.GetLength() == 0)
BOOST_THROW_EXCEPTION(std::invalid_argument("Invalid URL Empty URL."));
size_t pHelper = url.Find(":");
if (pHelper != String::NPos) {
if (!ParseScheme(url.SubStr(0, pHelper)))
BOOST_THROW_EXCEPTION(std::invalid_argument("Invalid URL Scheme."));
url = url.SubStr(pHelper + 1);
}
if (*url.Begin() != '/')
BOOST_THROW_EXCEPTION(std::invalid_argument("Invalid URL: '/' expected after scheme."));
if (url.GetLength() == 1) {
return;
}
if (*(url.Begin() + 1) == '/') {
pHelper = url.Find("/", 2);
if (pHelper == String::NPos)
BOOST_THROW_EXCEPTION(std::invalid_argument("Invalid URL: Missing '/' after authority."));
if (!ParseAuthority(url.SubStr(0, pHelper)))
BOOST_THROW_EXCEPTION(std::invalid_argument("Invalid URL Authority"));
url = url.SubStr(pHelper);
}
if (*url.Begin() == '/') {
pHelper = url.FindFirstOf("#?");
if (!ParsePath(url.SubStr(1, pHelper - 1)))
BOOST_THROW_EXCEPTION(std::invalid_argument("Invalid URL Path"));
if (pHelper != String::NPos)
url = url.SubStr(pHelper);
} else
BOOST_THROW_EXCEPTION(std::invalid_argument("Invalid URL: Missing path."));
if (*url.Begin() == '?') {
pHelper = url.Find("#");
if (!ParseQuery(url.SubStr(1, pHelper - 1)))
BOOST_THROW_EXCEPTION(std::invalid_argument("Invalid URL Query"));
if (pHelper != String::NPos)
url = url.SubStr(pHelper);
}
if (*url.Begin() == '#') {
if (!ParseFragment(url.SubStr(1)))
BOOST_THROW_EXCEPTION(std::invalid_argument("Invalid URL Fragment"));
}
}
static String StringSubstr(const std::vector<Value>& args)
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
String self = vframe->Self;
if (args.empty())
BOOST_THROW_EXCEPTION(std::invalid_argument("Too few arguments"));
if (static_cast<double>(args[0]) < 0 || static_cast<double>(args[0]) >= self.GetLength())
BOOST_THROW_EXCEPTION(std::invalid_argument("String index is out of range"));
if (args.size() > 1)
return self.SubStr(args[0], args[1]);
else
return self.SubStr(args[0]);
}
static String LoadAppType(const String& typeSpec)
{
int index;
Log(LogInformation, "icinga-app", "Loading application type: " + typeSpec);
index = typeSpec.FindFirstOf('/');
if (index == String::NPos)
return typeSpec;
String library = typeSpec.SubStr(0, index);
(void) Utility::LoadExtensionLibrary(library);
return typeSpec.SubStr(index + 1);
}
bool Url::ParseUserinfo(const String& userinfo)
{
size_t pos = userinfo.Find(":");
m_Username = userinfo.SubStr(0, pos);
if (!ValidateToken(m_Username, ACUSERINFO))
return false;
m_Username = Utility::UnescapeString(m_Username);
if (pos != String::NPos && pos != userinfo.GetLength() - 1) {
m_Password = userinfo.SubStr(pos+1);
if (!ValidateToken(m_Username, ACUSERINFO))
return false;
m_Password = Utility::UnescapeString(m_Password);
} else
m_Password = "";
return true;
}
int VcfHelper::chromName2Num(const String & chr) {
int n = atoi(chr.c_str());
if ( n > 0 ) { return n; }
else {
String s = chr;
if ( s.Left(3).Compare("chr") == 0 ) {
n = atoi(s.SubStr(3).c_str());
if ( n > 0 ) { return n; }
s = s.SubStr(3);
}
for(int i=0; i < asChromNames.Length(); ++i) {
if ( s.Compare(asChromNames[i]) == 0 ) {
return vnChromNums[i];
}
}
}
throw VcfFileException("Cannot recognize chromosome %s",chr.c_str());
}
/*********************************************************************\
Function name : TrimNumbers
Description : deletes the numbers at the end of a string
Created at : 05.01.02, @ 10:33:17
Created by : Thomas Kunert
Modified by :
\*********************************************************************/
String TrimNumbers(String str)
{
String strRet;
String str1;
Int32 lLen = str.GetLength();
Int32 l;
for (l = lLen - 1; l >= 0; l--)
{
str1 = str.SubStr(l, lLen - l);
if (!IsInteger(str1)) break;
}
if (l == -1) strRet = str1;
else strRet = str.SubStr(0, l + 1);
return strRet;
}
bool Url::ParseAuthority(const String& authority)
{
String auth = authority.SubStr(2);
size_t pos = auth.Find("@");
if (pos != String::NPos && pos != 0) {
if (!Url::ParseUserinfo(auth.SubStr(0, pos)))
return false;
auth = auth.SubStr(pos+1);
}
pos = auth.Find(":");
if (pos != String::NPos) {
if (pos == 0 || pos == auth.GetLength() - 1 || !Url::ParsePort(auth.SubStr(pos+1)))
return false;
}
m_Host = auth.SubStr(0, pos);
return ValidateToken(m_Host, ACHOST);
}
FileSearch::Ref PosixFileSearch::New(
const String &path,
const String &prefix,
SearchOptions options
) {
String dir, pattern;
// split the pattern out of the directory
const char *sz = path.c_str;
for (int i = path.numBytes - 1; i >= 0; --i) {
if (sz[i] == '/') {
dir = String(sz, i, string::CopyTag);
pattern = path.SubStr(i+1); // no leading /
break;
}
}
if (dir.empty || pattern.empty)
return FileSearch::Ref();
PosixFileSearch *s = new (ZFile) PosixFileSearch(dir, prefix, pattern, options);
s->m_sdir = opendir(dir.c_str);
if (!s->m_sdir) {
delete s;
return FileSearch::Ref();
}
s->m_cur = new (ZFile) dirent;
s->m_cur->d_name[0] = 0;
// must see if a file exists that matches our pattern (prime the search).
for (;;) {
struct dirent *next;
if ((readdir_r((DIR*)s->m_sdir, s->m_cur, &next) != 0) || (next == 0)) {
::closedir((DIR*)s->m_sdir);
s->m_sdir = 0;
break;
}
if (next->d_type == DT_REG) {
if (fnmatch(pattern.c_str, &next->d_name[0], 0) != FNM_NOMATCH)
break;
}
}
if (!s->m_sdir) {
if (s->NextState() == kState_Done) {
delete s;
return FileSearch::Ref();
}
}
return FileSearch::Ref(s);
}
FileInfo FileSystem::GetFileInfo(const String& path) const
{
FileInfo res;
res.path = "invalid_file";
FILETIME creationTime, lastAccessTime, lastWriteTime;
HANDLE hFile = CreateFileA(path.Data(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
if (hFile == NULL || hFile == INVALID_HANDLE_VALUE)
{
auto err = GetLastError();
return res;
}
if (!GetFileTime(hFile, &creationTime, &lastAccessTime, &lastWriteTime))
{
CloseHandle(hFile);
return res;
}
SYSTEMTIME stUTC, stLocal;
FileTimeToSystemTime(&creationTime, &stUTC);
SystemTimeToTzSpecificLocalTime(NULL, &stUTC, &stLocal);
res.createdDate = TimeStamp(stLocal.wSecond, stLocal.wMinute, stLocal.wHour, stLocal.wDay, stLocal.wMonth, stLocal.wYear);
FileTimeToSystemTime(&lastAccessTime, &stUTC);
SystemTimeToTzSpecificLocalTime(NULL, &stUTC, &stLocal);
res.accessDate = TimeStamp(stLocal.wSecond, stLocal.wMinute, stLocal.wHour, stLocal.wDay, stLocal.wMonth, stLocal.wYear);
FileTimeToSystemTime(&lastWriteTime, &stUTC);
SystemTimeToTzSpecificLocalTime(NULL, &stUTC, &stLocal);
res.editDate = TimeStamp(stLocal.wSecond, stLocal.wMinute, stLocal.wHour, stLocal.wDay, stLocal.wMonth, stLocal.wYear);
res.path = path;
String extension = path.SubStr(path.FindLast(".") + 1);
res.fileType = FileType::File;
for (auto iext : mInstance->mExtensions)
{
if (iext.Value().Contains(extension))
{
res.fileType = iext.Key();
break;
}
}
DWORD dwSizeHigh = 0, dwSizeLow = 0;
dwSizeLow = GetFileSize(hFile, &dwSizeHigh);
res.size = (dwSizeHigh * (MAXDWORD+1)) + dwSizeLow;
CloseHandle(hFile);
return res;
}
void CServerBrowser::MasterListQueryHandler(std::vector<String> serverVector)
{
// Loop through all servers
for(std::vector<String>::iterator iter = serverVector.begin(); iter != serverVector.end(); iter++)
{
// Get the address
String strAddress = (*iter);
// Get the ip and port
size_t sSplit = strAddress.Find(':', 0);
String strIp = strAddress.SubStr(0, sSplit++);
String strPort = strAddress.SubStr(sSplit, (strAddress.GetLength() - sSplit));
// Do we have a valid ip and port?
if(strIp.IsEmpty() || strPort.IsEmpty())
continue;
// Query the server
CServerBrowser::GetSingleton()->m_pServerQuery->Query(strIp, strPort.ToInteger(), "i");
}
}
/**
* Prints a stacktrace to the specified stream.
*
* @param fp The stream.
* @param ignoreFrames The number of stackframes to ignore (in addition to
* the one this function is executing in).
* @returns true if the stacktrace was printed, false otherwise.
*/
void StackTrace::Print(std::ostream& fp, int ignoreFrames) const
{
fp << std::endl;
#ifndef _WIN32
# ifdef HAVE_BACKTRACE_SYMBOLS
char **messages = backtrace_symbols(m_Frames, m_Count);
for (int i = ignoreFrames + 1; i < m_Count && messages != NULL; ++i) {
String message = messages[i];
char *sym_begin = strchr(messages[i], '(');
if (sym_begin) {
char *sym_end = strchr(sym_begin, '+');
if (sym_end != NULL) {
String sym = String(sym_begin + 1, sym_end);
String sym_demangled = Utility::DemangleSymbolName(sym);
if (sym_demangled.IsEmpty())
sym_demangled = "<unknown function>";
String path = String(messages[i], sym_begin);
size_t slashp = path.RFind("/");
if (slashp != String::NPos)
path = path.SubStr(slashp + 1);
message = path + ": " + sym_demangled + " (" + String(sym_end);
}
}
fp << "\t(" << i - ignoreFrames - 1 << ") " << message << std::endl;
}
std::free(messages);
fp << std::endl;
# else /* HAVE_BACKTRACE_SYMBOLS */
fp << "(not available)" << std::endl;
# endif /* HAVE_BACKTRACE_SYMBOLS */
#else /* _WIN32 */
for (int i = ignoreFrames + 1; i < m_Count; i++) {
fp << "\t(" << i - ignoreFrames - 1 << "): "
<< Utility::GetSymbolName(m_Frames[i])
<< std::endl;
}
#endif /* _WIN32 */
}
void StringReplace::Replace(String &str)
{
// test for environment variables
Int32 lStart, lEnd, lStartSearch = 0;
Int32 lStringLen;
String strExpr;
char* pchEnvVar;
char pszVar[1000];
BaseContainer bc;
while (str.FindFirst("($", &lStart, lStartSearch))
{
if (!str.FindFirst("$)", &lEnd, lStart))
return;
lStartSearch = lStart + 1;
strExpr = str.SubStr(lStart + 2, lEnd - lStart - 2);
lStringLen = strExpr.GetCStringLen(STRINGENCODING_8BIT);
Char* pchString = NewMem(Char,lStringLen + 2);
if (!pchString)
return;
strExpr.GetCString(pchString, lStringLen + 1, STRINGENCODING_8BIT);
pchEnvVar = GetOSEnvironmentVariable(pchString, pszVar, 1000);
DeleteMem(pchString);
if (pchEnvVar)
str = str.SubStr(0, lStart) + String(pchEnvVar) + str.SubStr(lEnd + 2, str.GetLength() - lEnd - 2);
}
FindAndReplace(str, String("($CINEMA_4D_ROOT$)"), m_strStartupPath);
FindAndReplace(str, String("($CINEMA_4D_PLUGIN$)"), m_strPluginPath);
FindAndReplace(str, String("($CINEMA_4D_VERSION$)"), m_strCurrentVersion);
FindAndReplace(str, String("($CURRENT_DATE$)"), m_strDate);
FindAndReplace(str, String("($CURRENT_TIME$)"), m_strTime);
FindAndReplace(str, String("($CURRENT_DATE_TIME$)"), m_strDateTime);
FindAndReplace(str, String("($BUILD_VERSION$)"), m_strBuildVersion);
FindAndReplace(str, String("($RELEASE_LINE$)"), m_strReleaseLine);
FindAndReplace(str, String("($BUILD_ID$)"), m_strBuildID);
}
void ApiListener::ConfigGlobHandler(Dictionary::Ptr& config, const String& path, const String& file)
{
CONTEXT("Creating config update for file '" + file + "'");
Log(LogNotice, "ApiListener")
<< "Creating config update for file '" << file << "'";
std::ifstream fp(file.CStr(), std::ifstream::binary);
if (!fp)
return;
String content((std::istreambuf_iterator<char>(fp)), std::istreambuf_iterator<char>());
config->Set(file.SubStr(path.GetLength()), content);
}
bool Url::ParseQuery(const String& query)
{
/* Tokenizer does not like String AT ALL */
std::string queryStr = query;
boost::char_separator<char> sep("&");
boost::tokenizer<boost::char_separator<char> > tokens(queryStr, sep);
for (const String& token : tokens) {
size_t pHelper = token.Find("=");
if (pHelper == 0)
// /?foo=bar&=bar == invalid
return false;
String key = token.SubStr(0, pHelper);
String value = Empty;
if (pHelper != String::NPos && pHelper != token.GetLength() - 1)
value = token.SubStr(pHelper+1);
if (!ValidateToken(value, ACQUERY))
return false;
value = Utility::UnescapeString(value);
pHelper = key.Find("[]");
if (pHelper == 0 || (pHelper != String::NPos && pHelper != key.GetLength()-2))
return false;
key = key.SubStr(0, pHelper);
if (!ValidateToken(key, ACQUERY))
return false;
key = Utility::UnescapeString(key);
auto it = m_Query.find(key);
if (it == m_Query.end()) {
m_Query[key] = std::vector<String>();
m_Query[key].push_back(value);
} else
m_Query[key].push_back(value);
}
return true;
}
Column Table::GetColumn(const String& name) const
{
String dname = name;
String prefix = GetPrefix() + "_";
if (dname.Find(prefix) == 0)
dname = dname.SubStr(prefix.GetLength());
auto it = m_Columns.find(dname);
if (it == m_Columns.end())
BOOST_THROW_EXCEPTION(std::invalid_argument("Column '" + dname + "' does not exist in table '" + GetName() + "'."));
return it->second;
}
bool VcfHelper::isAutosome(const String & chr)
{
// Return true for numeric chromosome number (1-22 or chr1-chr22),
// false for anything else
int n = atoi(chr.c_str());
if ( n > 0 ) { return true; }
else {
String s = chr;
if ( s.Left(3).Compare("chr") == 0 ) {
n = atoi(s.SubStr(3).c_str());
if ( n > 0 ) { return true; }
}
return false;
}
}
std::vector<String> ConsoleHandler::GetAutocompletionSuggestions(const String& word, ScriptFrame& frame)
{
std::vector<String> matches;
for (const String& keyword : ConfigWriter::GetKeywords()) {
AddSuggestion(matches, word, keyword);
}
{
ObjectLock olock(frame.Locals);
for (const Dictionary::Pair& kv : frame.Locals) {
AddSuggestion(matches, word, kv.first);
}
}
{
ObjectLock olock(ScriptGlobal::GetGlobals());
for (const Namespace::Pair& kv : ScriptGlobal::GetGlobals()) {
AddSuggestion(matches, word, kv.first);
}
}
Namespace::Ptr systemNS = ScriptGlobal::Get("System");
AddSuggestions(matches, word, "", false, systemNS);
AddSuggestions(matches, word, "", true, systemNS->Get("Configuration"));
AddSuggestions(matches, word, "", false, ScriptGlobal::Get("Types"));
AddSuggestions(matches, word, "", false, ScriptGlobal::Get("Icinga"));
String::SizeType cperiod = word.RFind(".");
if (cperiod != String::NPos) {
String pword = word.SubStr(0, cperiod);
Value value;
try {
std::unique_ptr<Expression> expr = ConfigCompiler::CompileText("temp", pword);
if (expr)
value = expr->Evaluate(frame);
AddSuggestions(matches, word, pword, true, value);
} catch (...) { /* Ignore the exception */ }
}
return matches;
}
void LegacyTimePeriod::ParseTimeRange(const String& timerange, tm *begin, tm *end, int *stride, tm *reference)
{
String def = timerange;
/* Figure out the stride. */
size_t pos = def.FindFirstOf('/');
if (pos != String::NPos) {
String strStride = def.SubStr(pos + 1).Trim();
*stride = Convert::ToLong(strStride);
/* Remove the stride parameter from the definition. */
def = def.SubStr(0, pos);
} else {
*stride = 1; /* User didn't specify anything, assume default. */
}
/* Figure out whether the user has specified two dates. */
pos = def.Find("- ");
if (pos != String::NPos) {
String first = def.SubStr(0, pos).Trim();
String second = def.SubStr(pos + 1).Trim();
ParseTimeSpec(first, begin, NULL, reference);
/* If the second definition starts with a number we need
* to add the first word from the first definition, e.g.:
* day 1 - 15 --> "day 15" */
bool is_number = true;
size_t xpos = second.FindFirstOf(' ');
String fword = second.SubStr(0, xpos);
try {
Convert::ToLong(fword);
} catch (...) {
is_number = false;
}
if (is_number) {
xpos = first.FindFirstOf(' ');
ASSERT(xpos != String::NPos);
second = first.SubStr(0, xpos + 1) + second;
}
ParseTimeSpec(second, NULL, end, reference);
} else {
ParseTimeSpec(def, begin, end, reference);
}
}
void ApiListener::ConfigGlobHandler(ConfigDirInformation& config, const String& path, const String& file)
{
CONTEXT("Creating config update for file '" + file + "'");
Log(LogNotice, "ApiListener")
<< "Creating config update for file '" << file << "'.";
std::ifstream fp(file.CStr(), std::ifstream::binary);
if (!fp)
return;
String content((std::istreambuf_iterator<char>(fp)), std::istreambuf_iterator<char>());
Dictionary::Ptr update;
if (Utility::Match("*.conf", file))
update = config.UpdateV1;
else
update = config.UpdateV2;
update->Set(file.SubStr(path.GetLength()), content);
}
bool HttpRequest::Parse(StreamReadContext& src, bool may_wait)
{
if (m_State != HttpRequestBody) {
String line;
StreamReadStatus srs = m_Stream->ReadLine(&line, src, may_wait);
if (srs != StatusNewItem)
return false;
if (m_State == HttpRequestStart) {
/* ignore trailing new-lines */
if (line == "")
return true;
std::vector<String> tokens;
boost::algorithm::split(tokens, line, boost::is_any_of(" "));
Log(LogDebug, "HttpRequest")
<< "line: " << line << ", tokens: " << tokens.size();
if (tokens.size() != 3)
BOOST_THROW_EXCEPTION(std::invalid_argument("Invalid HTTP request"));
RequestMethod = tokens[0];
RequestUrl = new class Url(tokens[1]);
if (tokens[2] == "HTTP/1.0")
ProtocolVersion = HttpVersion10;
else if (tokens[2] == "HTTP/1.1") {
ProtocolVersion = HttpVersion11;
} else
BOOST_THROW_EXCEPTION(std::invalid_argument("Unsupported HTTP version"));
m_State = HttpRequestHeaders;
} else if (m_State == HttpRequestHeaders) {
if (line == "") {
m_State = HttpRequestBody;
/* we're done if the request doesn't contain a message body */
if (!Headers->Contains("content-length") && !Headers->Contains("transfer-encoding"))
Complete = true;
else
m_Body = new FIFO();
return true;
} else {
String::SizeType pos = line.FindFirstOf(":");
if (pos == String::NPos)
BOOST_THROW_EXCEPTION(std::invalid_argument("Invalid HTTP request"));
String key = line.SubStr(0, pos).ToLower().Trim();
String value = line.SubStr(pos + 1).Trim();
Headers->Set(key, value);
if (key == "x-http-method-override")
RequestMethod = value;
}
} else {
VERIFY(!"Invalid HTTP request state.");
}
} else if (m_State == HttpRequestBody) {
if (Headers->Get("transfer-encoding") == "chunked") {
if (!m_ChunkContext)
m_ChunkContext = boost::make_shared<ChunkReadContext>(src);
char *data;
size_t size;
StreamReadStatus srs = HttpChunkedEncoding::ReadChunkFromStream(m_Stream, &data, &size, *m_ChunkContext.get(), may_wait);
if (srs != StatusNewItem)
return false;
Log(LogInformation, "HttpRequest")
<< "Read " << size << " bytes";
m_Body->Write(data, size);
delete [] data;
if (size == 0) {
Complete = true;
return true;
}
} else {
if (src.Eof)
BOOST_THROW_EXCEPTION(std::invalid_argument("Unexpected EOF in HTTP body"));
if (src.MustRead) {
if (!src.FillFromStream(m_Stream, false)) {
src.Eof = true;
BOOST_THROW_EXCEPTION(std::invalid_argument("Unexpected EOF in HTTP body"));
}
src.MustRead = false;
}
size_t length_indicator = Convert::ToLong(Headers->Get("content-length"));
if (src.Size < length_indicator) {
src.MustRead = true;
return false;
}
m_Body->Write(src.Buffer, length_indicator);
src.DropData(length_indicator);
Complete = true;
return true;
}
}
return true;
}
/**
* Prints a stacktrace to the specified stream.
*
* @param fp The stream.
* @param ignoreFrames The number of stackframes to ignore (in addition to
* the one this function is executing in).
* @returns true if the stacktrace was printed, false otherwise.
*/
void StackTrace::Print(std::ostream& fp, int ignoreFrames) const
{
fp << std::endl;
#ifndef _WIN32
# ifdef HAVE_BACKTRACE_SYMBOLS
char **messages = backtrace_symbols(m_Frames, m_Count);
for (int i = ignoreFrames + 1; i < m_Count && messages != NULL; ++i) {
String message = messages[i];
char *sym_begin = strchr(messages[i], '(');
if (sym_begin) {
char *sym_end = strchr(sym_begin, '+');
if (sym_end != NULL) {
String sym = String(sym_begin + 1, sym_end);
String sym_demangled = Utility::DemangleSymbolName(sym);
if (sym_demangled.IsEmpty())
sym_demangled = "<unknown function>";
String path = String(messages[i], sym_begin);
size_t slashp = path.RFind("/");
if (slashp != String::NPos)
path = path.SubStr(slashp + 1);
message = path + ": " + sym_demangled + " (" + String(sym_end);
#ifdef HAVE_DLADDR
Dl_info dli;
if (dladdr(m_Frames[i], &dli) > 0) {
uintptr_t rva = reinterpret_cast<uintptr_t>(m_Frames[i]) - reinterpret_cast<uintptr_t>(dli.dli_fbase);
message += " (" + Addr2Line(dli.dli_fname, rva) + ")";
}
#endif /* HAVE_DLADDR */
}
}
fp << "\t(" << i - ignoreFrames - 1 << ") " << message << std::endl;
}
free(messages);
fp << std::endl;
# else /* HAVE_BACKTRACE_SYMBOLS */
fp << "(not available)" << std::endl;
# endif /* HAVE_BACKTRACE_SYMBOLS */
#else /* _WIN32 */
for (int i = ignoreFrames + 1; i < m_Count; i++) {
char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME * sizeof(TCHAR)];
PSYMBOL_INFO pSymbol = (PSYMBOL_INFO)buffer;
pSymbol->SizeOfStruct = sizeof(SYMBOL_INFO);
pSymbol->MaxNameLen = MAX_SYM_NAME;
DWORD64 dwAddress = (DWORD64)m_Frames[i];
DWORD dwDisplacement;
DWORD64 dwDisplacement64;
IMAGEHLP_LINE64 line;
line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
fp << "\t(" << i - ignoreFrames - 1 << ") ";
if (SymGetLineFromAddr64(GetCurrentProcess(), dwAddress, &dwDisplacement, &line))
fp << line.FileName << ":" << line.LineNumber;
else
fp << "(unknown file/line)";
fp << ": ";
if (SymFromAddr(GetCurrentProcess(), dwAddress, &dwDisplacement64, pSymbol))
fp << pSymbol->Name << "+" << dwDisplacement64;
else
fp << "(unknown function)";
fp << std::endl;
}
#endif /* _WIN32 */
}
Dictionary::Ptr LivestatusLogUtility::GetAttributes(const String& text)
{
Dictionary::Ptr bag = new Dictionary();
/*
* [1379025342] SERVICE NOTIFICATION: contactname;hostname;servicedesc;WARNING;true;foo output
*/
unsigned long time = atoi(text.SubStr(1, 11).CStr());
Log(LogDebug, "LivestatusLogUtility")
<< "Processing log line: '" << text << "'.";
bag->Set("time", time);
size_t colon = text.FindFirstOf(':');
size_t colon_offset = colon - 13;
String type = String(text.SubStr(13, colon_offset)).Trim();
String options = String(text.SubStr(colon + 1)).Trim();
bag->Set("type", type);
bag->Set("options", options);
std::vector<String> tokens = options.Split(";");
/* set default values */
bag->Set("class", LogEntryClassInfo);
bag->Set("log_type", 0);
bag->Set("state", 0);
bag->Set("attempt", 0);
bag->Set("message", text); /* used as 'message' in log table, and 'log_output' in statehist table */
if (type.Contains("INITIAL HOST STATE") ||
type.Contains("CURRENT HOST STATE") ||
type.Contains("HOST ALERT")) {
if (tokens.size() < 5)
return bag;
bag->Set("host_name", tokens[0]);
bag->Set("state", Host::StateFromString(tokens[1]));
bag->Set("state_type", tokens[2]);
bag->Set("attempt", atoi(tokens[3].CStr()));
bag->Set("plugin_output", tokens[4]);
if (type.Contains("INITIAL HOST STATE")) {
bag->Set("class", LogEntryClassState);
bag->Set("log_type", LogEntryTypeHostInitialState);
}
else if (type.Contains("CURRENT HOST STATE")) {
bag->Set("class", LogEntryClassState);
bag->Set("log_type", LogEntryTypeHostCurrentState);
}
else {
bag->Set("class", LogEntryClassAlert);
bag->Set("log_type", LogEntryTypeHostAlert);
}
return bag;
} else if (type.Contains("HOST DOWNTIME ALERT") || type.Contains("HOST FLAPPING ALERT")) {
if (tokens.size() < 3)
return bag;
bag->Set("host_name", tokens[0]);
bag->Set("state_type", tokens[1]);
bag->Set("comment", tokens[2]);
if (type.Contains("HOST FLAPPING ALERT")) {
bag->Set("class", LogEntryClassAlert);
bag->Set("log_type", LogEntryTypeHostFlapping);
} else {
bag->Set("class", LogEntryClassAlert);
bag->Set("log_type", LogEntryTypeHostDowntimeAlert);
}
return bag;
} else if (type.Contains("INITIAL SERVICE STATE") ||
type.Contains("CURRENT SERVICE STATE") ||
type.Contains("SERVICE ALERT")) {
if (tokens.size() < 6)
return bag;
bag->Set("host_name", tokens[0]);
bag->Set("service_description", tokens[1]);
bag->Set("state", Service::StateFromString(tokens[2]));
bag->Set("state_type", tokens[3]);
bag->Set("attempt", atoi(tokens[4].CStr()));
bag->Set("plugin_output", tokens[5]);
if (type.Contains("INITIAL SERVICE STATE")) {
bag->Set("class", LogEntryClassState);
bag->Set("log_type", LogEntryTypeServiceInitialState);
}
else if (type.Contains("CURRENT SERVICE STATE")) {
bag->Set("class", LogEntryClassState);
bag->Set("log_type", LogEntryTypeServiceCurrentState);
}
else {
bag->Set("class", LogEntryClassAlert);
bag->Set("log_type", LogEntryTypeServiceAlert);
}
return bag;
} else if (type.Contains("SERVICE DOWNTIME ALERT") ||
type.Contains("SERVICE FLAPPING ALERT")) {
if (tokens.size() < 4)
return bag;
bag->Set("host_name", tokens[0]);
bag->Set("service_description", tokens[1]);
bag->Set("state_type", tokens[2]);
bag->Set("comment", tokens[3]);
if (type.Contains("SERVICE FLAPPING ALERT")) {
bag->Set("class", LogEntryClassAlert);
bag->Set("log_type", LogEntryTypeServiceFlapping);
} else {
bag->Set("class", LogEntryClassAlert);
bag->Set("log_type", LogEntryTypeServiceDowntimeAlert);
}
return bag;
} else if (type.Contains("TIMEPERIOD TRANSITION")) {
if (tokens.size() < 4)
return bag;
bag->Set("class", LogEntryClassState);
bag->Set("log_type", LogEntryTypeTimeperiodTransition);
bag->Set("host_name", tokens[0]);
bag->Set("service_description", tokens[1]);
bag->Set("state_type", tokens[2]);
bag->Set("comment", tokens[3]);
} else if (type.Contains("HOST NOTIFICATION")) {
if (tokens.size() < 6)
return bag;
bag->Set("contact_name", tokens[0]);
bag->Set("host_name", tokens[1]);
bag->Set("state_type", tokens[2].CStr());
bag->Set("state", Service::StateFromString(tokens[3]));
bag->Set("command_name", tokens[4]);
bag->Set("plugin_output", tokens[5]);
bag->Set("class", LogEntryClassNotification);
bag->Set("log_type", LogEntryTypeHostNotification);
return bag;
} else if (type.Contains("SERVICE NOTIFICATION")) {
if (tokens.size() < 7)
return bag;
bag->Set("contact_name", tokens[0]);
bag->Set("host_name", tokens[1]);
bag->Set("service_description", tokens[2]);
bag->Set("state_type", tokens[3].CStr());
bag->Set("state", Service::StateFromString(tokens[4]));
bag->Set("command_name", tokens[5]);
bag->Set("plugin_output", tokens[6]);
bag->Set("class", LogEntryClassNotification);
bag->Set("log_type", LogEntryTypeServiceNotification);
return bag;
} else if (type.Contains("PASSIVE HOST CHECK")) {
if (tokens.size() < 3)
return bag;
bag->Set("host_name", tokens[0]);
bag->Set("state", Host::StateFromString(tokens[1]));
bag->Set("plugin_output", tokens[2]);
bag->Set("class", LogEntryClassPassive);
return bag;
} else if (type.Contains("PASSIVE SERVICE CHECK")) {
if (tokens.size() < 4)
return bag;
bag->Set("host_name", tokens[0]);
bag->Set("service_description", tokens[1]);
bag->Set("state", Host::StateFromString(tokens[2]));
bag->Set("plugin_output", tokens[3]);
bag->Set("class", LogEntryClassPassive);
return bag;
} else if (type.Contains("EXTERNAL COMMAND")) {
bag->Set("class", LogEntryClassCommand);
/* string processing not implemented in 1.x */
return bag;
} else if (type.Contains("LOG VERSION")) {
bag->Set("class", LogEntryClassProgram);
bag->Set("log_type", LogEntryTypeVersion);
return bag;
} else if (type.Contains("logging initial states")) {
bag->Set("class", LogEntryClassProgram);
bag->Set("log_type", LogEntryTypeInitialStates);
return bag;
} else if (type.Contains("starting... (PID=")) {
bag->Set("class", LogEntryClassProgram);
bag->Set("log_type", LogEntryTypeProgramStarting);
return bag;
}
/* program */
else if (type.Contains("restarting...") ||
type.Contains("shutting down...") ||
type.Contains("Bailing out") ||
type.Contains("active mode...") ||
type.Contains("standby mode...")) {
bag->Set("class", LogEntryClassProgram);
return bag;
}
return bag;
}
void CLICommand::ShowCommands(int argc, char **argv, po::options_description *visibleDesc,
po::options_description *hiddenDesc,
ArgumentCompletionCallback globalArgCompletionCallback,
bool autocomplete, int autoindex)
{
boost::mutex::scoped_lock lock(GetRegistryMutex());
typedef std::map<std::vector<String>, CLICommand::Ptr>::value_type CLIKeyValue;
std::vector<String> best_match;
int arg_begin = 0;
CLICommand::Ptr command;
BOOST_FOREACH(const CLIKeyValue& kv, GetRegistry()) {
const std::vector<String>& vname = kv.first;
arg_begin = 0;
for (int i = 0, k = 1; i < vname.size() && k < argc; i++, k++) {
if (strcmp(argv[k], "--no-stack-rlimit") == 0 || strcmp(argv[k], "--autocomplete") == 0 || strcmp(argv[k], "--scm") == 0) {
i--;
arg_begin++;
continue;
}
if (autocomplete && i >= autoindex - 1)
break;
if (vname[i] != argv[k])
break;
if (i >= best_match.size()) {
best_match.push_back(vname[i]);
}
if (i == vname.size() - 1) {
command = kv.second;
break;
}
}
}
String aword;
if (autocomplete) {
if (autoindex < argc)
aword = argv[autoindex];
if (autoindex - 1 > best_match.size() && !command)
return;
} else
std::cout << "Supported commands: " << std::endl;
BOOST_FOREACH(const CLIKeyValue& kv, GetRegistry()) {
const std::vector<String>& vname = kv.first;
if (vname.size() < best_match.size())
continue;
bool match = true;
for (int i = 0; i < best_match.size(); i++) {
if (vname[i] != best_match[i]) {
match = false;
break;
}
}
if (!match)
continue;
if (autocomplete) {
String cname;
if (autoindex - 1 < vname.size()) {
cname = vname[autoindex - 1];
if (cname.Find(aword) == 0)
std::cout << cname << "\n";
}
} else
std::cout << " * " << boost::algorithm::join(vname, " ") << " (" << kv.second->GetShortDescription() << ")" << std::endl;
}
if (!autocomplete)
std::cout << std::endl;
if (command && autocomplete) {
String aname, prefix, pword;
const po::option_description *odesc;
if (autoindex - 2 >= 0 && strcmp(argv[autoindex - 1], "=") == 0 && strstr(argv[autoindex - 2], "--") == argv[autoindex - 2]) {
aname = argv[autoindex - 2] + 2;
pword = aword;
} else if (autoindex - 1 >= 0 && argv[autoindex - 1][0] == '-' && argv[autoindex - 1][1] == '-') {
aname = argv[autoindex - 1] + 2;
pword = aword;
if (pword == "=")
pword = "";
} else if (aword.GetLength() > 1 && aword[0] == '-' && aword[1] != '-') {
aname = aword.SubStr(1, 1);
prefix = aword.SubStr(0, 2);
pword = aword.SubStr(2);
} else {
goto complete_option;
}
odesc = visibleDesc->find_nothrow(aname, false);
if (!odesc)
return;
if (odesc->semantic()->min_tokens() == 0)
goto complete_option;
BOOST_FOREACH(const String& suggestion, globalArgCompletionCallback(aname, pword)) {
std::cout << prefix << suggestion << "\n";
}
int TroubleshootCommand::Run(const boost::program_options::variables_map& vm, const std::vector<std::string>& ap) const
{
#ifdef _WIN32 //Dislikes ':' in filenames
String path = Application::GetLocalStateDir() + "/log/icinga2/troubleshooting-"
+ Utility::FormatDateTime("%Y-%m-%d_%H-%M-%S", Utility::GetTime()) + ".log";
#else
String path = Application::GetLocalStateDir() + "/log/icinga2/troubleshooting-"
+ Utility::FormatDateTime("%Y-%m-%d_%H:%M:%S", Utility::GetTime()) + ".log";
#endif /*_WIN32*/
InfoLog *log;
Logger::SetConsoleLogSeverity(LogWarning);
if (vm.count("output"))
path = vm["output"].as<std::string>();
if (vm.count("console")) {
log = new InfoLog("", true);
} else {
log = new InfoLog(path, false);
if (!log->GetStreamHealth()) {
Log(LogCritical, "troubleshoot", "Failed to open file to write: " + path);
delete log;
return 3;
}
}
String appName = Utility::BaseName(Application::GetArgV()[0]);
double goTime = Utility::GetTime();
InfoLogLine(*log)
<< appName << " -- Troubleshooting help:\n"
<< "Should you run into problems with Icinga please add this file to your help request\n"
<< "Started collection at " << Utility::FormatDateTime("%Y-%m-%d %H:%M:%S", goTime) << "\n";
InfoLogLine(*log, Console_ForegroundMagenta)
<< std::string(52, '=') << "\n\n";
if (appName.GetLength() > 3 && appName.SubStr(0, 3) == "lt-")
appName = appName.SubStr(3, appName.GetLength() - 3);
Dictionary::Ptr logs = new Dictionary;
if (!GeneralInfo(*log, vm) ||
!FeatureInfo(*log, vm) ||
!ObjectInfo(*log, vm, logs, path) ||
!ReportInfo(*log, vm, logs) ||
!ConfigInfo(*log, vm)) {
InfoLogLine(*log, 0, LogCritical)
<< "Could not recover from critical failure, exiting.\n";
delete log;
return 3;
}
double endTime = Utility::GetTime();
InfoLogLine(*log, Console_ForegroundMagenta)
<< std::string(52, '=') << '\n';
InfoLogLine(*log, Console_ForegroundGreen)
<< "Finished collection at " << Utility::FormatDateTime("%Y-%m-%d %H:%M:%S", endTime)
<< "\nTook " << Convert::ToString(endTime - goTime) << " seconds\n";
if (!vm.count("console")) {
std::cout << "Started collection at " << Utility::FormatDateTime("%Y-%m-%d %H:%M:%S", goTime) << "\n"
<< "Finished collection at " << Utility::FormatDateTime("%Y-%m-%d %H:%M:%S", endTime)
<< "\nTook " << Convert::ToString(endTime - goTime) << " seconds\n\n";
std::cout << "General log file: '" << path << "'\n";
if (vm.count("include-vars"))
std::cout << "Vars log file: '" << path << "-vars'\n";
if (vm.count("include-objects"))
std::cout << "Objects log file: '" << path << "-objects'\n";
std::cout << "\nPlease compress the files before uploading them,, for example:\n"
<< " # tar czf troubleshoot.tar.gz " << path << "*\n";
}
delete log;
return 0;
}
String Texture2D::Reload(const String& filePath, SupportedFileTypes fileType)
{
if (fileType == UNKNOWN)
{
if (filePath.GetSize() < 4)
return "File-name was too short to infer a type";
String extension = filePath.SubStr(filePath.GetSize() - 4, 4);
if (extension == ".png")
fileType = PNG;
else if (extension == ".bmp")
fileType = BMP;
else
return "Couldn't infer type from file name";
}
switch (fileType)
{
case BMP: {
unsigned long width;
long height;
unsigned char *reds,
*greens,
*blues;
if (bmp_read(filePath.CStr(), &width, &height, &reds, &greens, &blues))
{
return "Error reading the BMP file";
}
Resize(width, height);
//Convert to texture data.
float invMaxVal = 1.0f / (float)std::numeric_limits<unsigned char>::max();
for (long y = 0; y < height; ++y)
{
for (unsigned long x = 0; x < width; ++x)
{
long i = x + (y * width);
Vector3f col((float)reds[i] * invMaxVal,
(float)greens[i] * invMaxVal,
(float)blues[i] * invMaxVal);
SetColor(x, y, col);
}
}
} break;
case PNG: {
std::vector<unsigned char> bytes;
unsigned width, height;
unsigned errCode = lodepng::decode(bytes, width, height, filePath.CStr());
if (errCode != 0)
{
return String("Error reading the PNG file: ") + lodepng_error_text(errCode);
}
Resize(width, height);
//Convert to texture data.
float invMaxVal = 1.0f / (float)std::numeric_limits<unsigned char>::max();
for (size_t y = 0; y < height; ++y)
{
size_t indexOffset = y * width * 4;
for (size_t x = 0; x < width; ++x)
{
size_t indexOffset2 = indexOffset + (x * 4);
SetColor(x, height - y - 1,
Vector3f((float)bytes[indexOffset2] * invMaxVal,
(float)bytes[indexOffset2 + 1] * invMaxVal,
(float)bytes[indexOffset2 + 2] * invMaxVal));
}
}
} break;
default:
return String("Unexpected file type enum value: ") + String(fileType);
}
return "";
}
