void XplDevice::SaveConfig()
{
Poco::Path p = GetConfigFileLocation();
poco_debug ( devLog, "saving config for " + GetCompleteId() + " to " + p.toString());
m_configStore->setString("vendorId", GetVendorId());
m_configStore->setString("deviceId", GetDeviceId());
m_configStore->setString("instanceId", GetInstanceId());
if(m_configItems.size()) {
m_configStore->setInt("configItems",m_configItems.size());
for ( vector<AutoPtr<XplConfigItem> >::iterator iter = m_configItems.begin(); iter != m_configItems.end(); ++iter )
{
poco_debug ( devLog, "saving config item " + (*iter)->GetName());
m_configStore->setString("configItems." + (*iter)->GetName(), "" );
m_configStore->setString("configItems." + (*iter)->GetName() + ".numValues" , NumberFormatter::format((*iter)->GetNumValues()) );
for (int vindex=0; vindex<(*iter)->GetNumValues(); vindex++) {
m_configStore->setString("configItems." + (*iter)->GetName() + ".value" + NumberFormatter::format(vindex) , (*iter)->GetValue(vindex) );
}
}
}
m_configStore->save(p.toString());
poco_debug ( devLog, "saved to " + p.toString());
}
// recusively delete the path given. we do this manually to set the permissions to writable,
// so that windows doesn't cause permission denied errors.
cResult deltree(Poco::Path s)
{
drunner_assert(s.isDirectory(), "deltree: asked to delete a file: "+s.toString());
cResult rval = kRNoChange;
try
{
Poco::DirectoryIterator end;
for (Poco::DirectoryIterator it(s); it != end; ++it)
if (it->isFile())
rval += delfile(it->path());
else
{
Poco::Path subdir(it->path());
subdir.makeDirectory();
rval += deltree(subdir);
}
Poco::File f(s);
f.setWriteable(true);
f.remove();
logmsg(kLDEBUG, "Deleted " + f.path());
}
catch (const Poco::Exception & e) {
return cError("Couldn't delete " + s.toString() + " - " + e.what());
}
return kRSuccess;
}
// ---
bool VSWAEImportContentWindow::validateDir (const QString& d)
{
bool result = false;
// Calculates the paths for everything: the basic dir, the definition file...
// ...and the basic path received as parameter during the initialization.
Poco::Path defPath;
Poco::File defFile;
Poco::File defDir (d.toStdString ());
Poco::Path bPath (_basicPath.toStdString ());
bool isDefDirADir = defDir.isDirectory (); // The directory has to be a dir (this is guarantte by the window, but just in case)
if (isDefDirADir)
{
defPath = Poco::Path (d.toStdString ());
defFile = Poco::File ((d + QString (__PATH_SEPARATOR__) +
_name -> text () + QString (".xml")).toStdString ());
}
// If the directory is a directory, then it is needed to test whether the
// directory is or not contained in the basic path received as parameter.
bool isDefDirInBPath = false;
if (isDefDirADir)
isDefDirInBPath = ((defPath.toString () + std::string (__PATH_SEPARATOR__)).
find (bPath.toString () + std::string (__PATH_SEPARATOR__)) != -1);
// To determinate whether the dir is or not valid...
result = !isDefDirADir || (isDefDirADir && isDefDirInBPath);
return (result);
}
int CStatsUtil::DoImportGameStrings()
{
Poco::Path inpath(m_inputPath);
Poco::Path outpath;
if( m_outputPath.empty() )
throw runtime_error("Output path unspecified!");
if( utils::isFolder( m_outputPath ) )
{
outpath = Poco::Path(m_outputPath).makeAbsolute().makeDirectory();
GameStats gstats( outpath.toString(), m_langconf );
gstats.AnalyzeGameDir();
gstats.ImportStrings( m_inputPath );
gstats.WriteStrings();
}
else
{
outpath = Poco::Path(m_outputPath).makeAbsolute();
if( ! m_flocalestr.empty() )
{
auto myloc = std::locale( m_flocalestr );
pmd2::filetypes::WriteTextStrFile( outpath.toString(), utils::io::ReadTextFileLineByLine( m_inputPath, myloc ), myloc );
}
else
{
pmd2::filetypes::WriteTextStrFile( outpath.toString(), utils::io::ReadTextFileLineByLine(m_inputPath) );
}
}
return 0;
}
/**
* Sets the location of the module given an absolute or relative location.
* For relative paths we look for the
* module first in PROG_DIR, then MODULE_DIR, then the
* current directory, and
* finally the system path. Will throw an exception if the module cannot
* be found.
* @param location Absolute or relative path string for module.
*/
void TskModule::setPath(const std::string& location)
{
if (location.empty())
{
throw TskException("TskModule::setPath: location is empty or missing.");
}
Poco::Path tempPath = location;
if (!tempPath.isAbsolute())
{
// If this is a relative path, then see if we can find the
// executable either in PROG_DIR, in MODULE_DIR, in the current directory,
// or on the system path.
std::string pathsToSearch = GetSystemProperty(TskSystemProperties::PROG_DIR);
if (!pathsToSearch.empty())
pathsToSearch += Poco::Path::pathSeparator();
pathsToSearch += GetSystemProperty(TskSystemProperties::MODULE_DIR);
if (!pathsToSearch.empty())
pathsToSearch += Poco::Path::pathSeparator();
pathsToSearch += ".";
if (!Poco::Path::find(pathsToSearch, location, tempPath))
{
// if we didn't find them in the above paths, check on the path.
if (Poco::Environment::has("Path"))
{
std::string systemPath = Poco::Environment::get("Path");
if (!systemPath.empty())
{
Poco::Path::find(systemPath, location, tempPath);
}
}
}
}
// Confirm existence of file at location.
Poco::File moduleFile(tempPath);
if (!moduleFile.exists())
{
std::stringstream msg;
msg << "TskModule::setPath - Module not found: "
<< tempPath.toString().c_str();
throw TskException(msg.str());
}
else {
std::wstringstream msg;
msg << L"TskModule::setPath - Module found at: "
<< tempPath.toString().c_str();
LOGINFO(msg.str());
}
m_modulePath = tempPath.toString();
}
void CWidget::update(CWorkerTools::WorkerProgressFunc progressCallback, const std::string & widgetName, const std::string & downloadUrl)
{
YADOMS_LOG(information) << "Updating widget " << widgetName << " from " << downloadUrl;
shared::CDataContainer callbackData;
callbackData.set("widgetName", widgetName);
callbackData.set("downloadUrl", downloadUrl);
progressCallback(true, 0.0f, i18n::CClientStrings::UpdateWidgetUpdate, shared::CStringExtension::EmptyString, callbackData);
/////////////////////////////////////////////
//1. download package
/////////////////////////////////////////////
try
{
YADOMS_LOG(information) << "Downloading widget package";
progressCallback(true, 0.0f, i18n::CClientStrings::UpdateWidgetDownload, shared::CStringExtension::EmptyString, callbackData);
Poco::Path downloadedPackage = CWorkerTools::downloadPackage(downloadUrl, progressCallback, i18n::CClientStrings::UpdateWidgetDownload, 0.0, 90.0);
YADOMS_LOG(information) << "Downloading widget package with sucess";
/////////////////////////////////////////////
//2. deploy package
/////////////////////////////////////////////
try
{
YADOMS_LOG(information) << "Deploy widget package " << downloadedPackage.toString();
progressCallback(true, 90.0f, i18n::CClientStrings::UpdateWidgetDeploy, shared::CStringExtension::EmptyString, callbackData);
Poco::Path widgetPath = CWorkerTools::deployWidgetPackage(downloadedPackage);
YADOMS_LOG(information) << "Widget installed with success";
progressCallback(true, 100.0f, i18n::CClientStrings::UpdateWidgetSuccess, shared::CStringExtension::EmptyString, callbackData);
}
catch (std::exception & ex)
{
//fail to extract package file
YADOMS_LOG(error) << "Fail to deploy widget package : " << ex.what();
progressCallback(false, 100.0f, i18n::CClientStrings::UpdateWidgetDeployFailed, ex.what(), callbackData);
}
//delete downloaded zip file
Poco::File toDelete(downloadedPackage.toString());
if (toDelete.exists())
toDelete.remove();
}
catch (std::exception & ex)
{
//fail to download package
YADOMS_LOG(error) << "Fail to download pwidget ackage : " << ex.what();
progressCallback(false, 100.0f, i18n::CClientStrings::UpdateWidgetDownloadFailed, ex.what(), callbackData);
}
}
/**
* Creates a set of files that match the given pathPattern.
*
* The path may be give in either Unix, Windows or VMS syntax and
* is automatically expanded by calling Path::expand().
*
* The pattern may contain wildcard expressions even in intermediate
* directory names (e.g. /usr/include/<I>*</I> /<I>*</I>*.h).
*
* Note that, for obvious reasons, escaping characters in a pattern
* with a backslash does not work in Windows-style paths.
*
* Directories that for whatever reason cannot be traversed are
* ignored.
*
* It seems that whatever bug Poco had is fixed now.
* So calling Poco::Glob::glob(pathPattern,files,options) inside.
*
* @param pathPattern :: The search pattern
* @param files :: The names of the files that match the pattern
* @param options :: Options
*/
void Glob::glob(const Poco::Path& pathPattern, std::set<std::string>& files, int options)
{
#ifdef _WIN32
// There appears to be a bug in the glob for windows.
// Putting case sensitive on then with reference to test testFindFileCaseSensitive()
// in FileFinderTest on Windows it is able to find "CSp78173.Raw" as it should even
// the case is wrong, but for some strange reason it then cannot find IDF_for_UNiT_TESTiNG.xMl!!!!
// Hence the reason to circumvent this by this #ifdef
Poco::Glob::glob(Poco::Path(pathPattern.toString()),files, Poco::Glob::GLOB_CASELESS);
#else
Poco::Glob::glob(Poco::Path(pathPattern.toString()),files,options);
#endif
}
tempfolder::tempfolder(Poco::Path d) : mPath(d)
{ // http://stackoverflow.com/a/10232761
Poco::File f(d);
if (f.exists() && kRSuccess != utils::deltree(d))
die("Couldn't delete old stuff in temp directory: " + d.toString());
f.createDirectories();
logmsg(kLDEBUG, "Created " + d.toString());
#ifndef _WIN32
if (chmod(d.toString().c_str(), S_777) != 0)
die("Unable to change permissions on " + d.toString());
#endif
}
void AsyncCopy::Copy(Poco::Path &src, Poco::Path &dest)
{
Logger* logger = Logger::Get("Filesystem.AsyncCopy");
std::string srcString = src.toString();
std::string destString = dest.toString();
Poco::File from(srcString);
bool isLink = from.isLink();
logger->Debug("file=%s dest=%s link=%i", srcString.c_str(), destString.c_str(), isLink);
#ifndef OS_WIN32
if (isLink)
{
char linkPath[PATH_MAX];
ssize_t length = readlink(from.path().c_str(), linkPath, PATH_MAX);
linkPath[length] = '\0';
std::string newPath (dest.toString());
const char *destPath = newPath.c_str();
unlink(destPath); // unlink it first, fails in some OS if already there
int result = symlink(linkPath, destPath);
if (result == -1)
{
std::string err = "Copy failed: Could not make symlink (";
err.append(destPath);
err.append(") from ");
err.append(linkPath);
err.append(" : ");
err.append(strerror(errno));
throw kroll::ValueException::FromString(err);
}
}
#endif
if (!isLink && from.isDirectory())
{
Poco::File d(dest.toString());
if (!d.exists())
{
d.createDirectories();
}
std::vector<std::string> files;
from.list(files);
std::vector<std::string>::iterator i = files.begin();
while(i!=files.end())
{
std::string fn = (*i++);
Poco::Path sp(kroll::FileUtils::Join(src.toString().c_str(),fn.c_str(),NULL));
Poco::Path dp(kroll::FileUtils::Join(dest.toString().c_str(),fn.c_str(),NULL));
this->Copy(sp,dp);
}
}
else if (!isLink)
{
// in this case it's a regular file
Poco::File s(src.toString());
s.copyTo(dest.toString().c_str());
}
}
int CStatsUtil::DoExportAll()
{
Poco::Path inpath(m_inputPath);
Poco::Path outpath;
if( m_outputPath.empty() )
{
outpath = inpath.absolute().makeParent().append(DefExportAllDir);
}
else
{
outpath = Poco::Path(m_outputPath).makeAbsolute();
}
GameStats gstats( m_inputPath, m_langconf );
gstats.Load();
//Test output path
Poco::File fTestOut = outpath;
if( ! fTestOut.exists() )
{
cout << "Created output directory \"" << fTestOut.path() <<"\"!\n";
fTestOut.createDirectory();
}
gstats.ExportAll(outpath.toString());
return 0;
}
int CStatsUtil::DoExportGameScripts()
{
//Validate output + input paths
Poco::Path inpath(m_inputPath);
Poco::Path outpath;
if( m_outputPath.empty() )
outpath = inpath.absolute().makeParent().append(DefExportScriptsDir);
else
outpath = Poco::Path(m_outputPath).makeAbsolute();
Poco::File fTestOut = outpath;
if( ! fTestOut.exists() )
{
cout << "Created output directory \"" << fTestOut.path() <<"\"!\n";
fTestOut.createDirectory();
}
else if( ! fTestOut.isDirectory() )
throw runtime_error("CStatsUtil::DoExportGameScripts(): Output path is not a directory!");
//Setup the script handler
GameScripts scripts( inpath.absolute().toString() );
//Convert to XML
scripts.ExportScriptsToXML( outpath.toString() );
return 0;
}
std::string mui::Helpers::muiPath( std::string path ){
// pretty much copy&pasted from OF
Poco::Path outputPath;
Poco::Path inputPath(path);
string strippedDataPath = mui::MuiConfig::dataPath.toString();
strippedDataPath = ofFilePath::removeTrailingSlash(strippedDataPath);
if (inputPath.toString().find(strippedDataPath) != 0) {
outputPath = mui::MuiConfig::dataPath;
outputPath.resolve(inputPath);
} else {
outputPath = inputPath;
}
if( !ofFile(outputPath.absolute().toString(), ofFile::Reference).exists() ){
// maybe in the data dir?
string dataFile = ofToDataPath(path, true);
if( ofFile(dataFile,ofFile::Reference).exists() ){
outputPath = Poco::Path(dataFile);
}
}
if( mui::MuiConfig::logLevel <= OF_LOG_NOTICE ){
cout << "loading path: " << outputPath.toString() << " || " << outputPath.absolute().toString() << " || " << path << endl;
}
return outputPath.absolute().toString();
}
QStringList QtAssistantUtil::ExtractQCHFiles(const std::vector<IBundle::Pointer>& bundles)
{
QStringList result;
for (std::size_t i = 0; i < bundles.size(); ++i)
{
std::vector<std::string> resourceFiles;
bundles[i]->GetStorage().List("resources", resourceFiles);
bool qchFileFound = false;
for (std::size_t j = 0; j < resourceFiles.size(); ++j)
{
QString resource = QString::fromStdString(resourceFiles[j]);
if (resource.endsWith(".qch"))
{
qchFileFound = true;
Poco::Path qchPath = bundles[i]->GetPath();
qchPath.pushDirectory("resources");
qchPath.setFileName(resourceFiles[j]);
result << QString::fromStdString(qchPath.toString());
}
}
if (qchFileFound)
{
registeredBundles.insert(QString::fromStdString(bundles[i]->GetSymbolicName()));
}
}
return result;
}
IBundleActivator*
BundleLoader::LoadActivator(BundleInfo& bundleInfo)
{
Poco::Mutex::ScopedLock lock(m_Mutex);
std::string activator = bundleInfo.m_Bundle->GetActivatorClass();
if (activator == "") return new DefaultActivator();
Poco::Path libPath = this->GetLibraryPathFor(bundleInfo.m_Bundle);
std::string strLibPath(libPath.toString());
BERRY_INFO(m_ConsoleLog) << "Loading activator library: " << strLibPath;
try
{
/* retrieves only an empty string and its not required
#ifdef BERRY_OS_FAMILY_WINDOWS
char cDllPath[512];
GetDllDirectory(512, cDllPath);
BERRY_INFO << "Dll Path: " << cDllPath << std::endl;
#endif
*/
bundleInfo.m_ClassLoader->loadLibrary(strLibPath);
return bundleInfo.m_ClassLoader->create(activator);
}
catch (Poco::LibraryLoadException exc)
{
BERRY_ERROR << "Could not create Plugin activator. Did you export the class \"" << activator << "\" ?\n"
<< " Exception displayText(): " << exc.displayText();
exc.rethrow();
}
return 0;
}
string getOFRelPath(string from){
Poco::Path base(true);
base.parse(from);
Poco::Path path;
path.parse( getOFRoot() );
path.makeAbsolute();
cout << "getOFRelPath " << base.toString() << " " << path.toString() << endl;
string relPath;
if (path.toString() == base.toString()){
// do something.
}
int maxx = MAX(base.depth(), path.depth());
for (int i = 0; i <= maxx; i++){
bool bRunOut = false;
bool bChanged = false;
if (i <= base.depth() && i <= path.depth()){
if (base.directory(i) == path.directory(i)){
} else {
bChanged = true;
}
} else {
bRunOut = true;
}
if (bRunOut == true || bChanged == true){
for (int j = i; j <= base.depth(); j++){
relPath += "../";
}
for (int j = i; j <= path.depth(); j++){
relPath += path.directory(j) + "/";
}
break;
}
}
cout << relPath << " ---- " << endl;
return relPath;
}
cResult makedirectory(Poco::Path d, mode_t mode)
{
Poco::File f(d);
if (!f.exists())
{
if (!utils::fileexists(d.parent()))
return cError("Parent directoy doesn't exist: " + d.parent().toString());
f.createDirectory();
logdbg("Created " + d.toString());
}
#ifndef _WIN32
if (chmod(d.toString().c_str(), mode) != 0)
return cError("Unable to change permissions on " + d.toString());
#endif
return kRSuccess;
}
/**
Common method used by all constructors. Creates a file containing the ASCII file
contents and 'remembers' the location of that file.
*/
void ScopedFile::doCreateFile(const std::string &fileContents,
const Poco::Path &fileNameAndPath) {
m_filename = fileNameAndPath.toString();
m_file.open(m_filename.c_str(), std::ios_base::out);
if (!m_file.is_open()) {
throw std::runtime_error("Cannot open " + m_filename);
}
m_file << fileContents;
m_file.close();
}
Poco::Path SharedMemoryTest::findDataFile(const std::string& afile)
{
Poco::Path root;
root.makeAbsolute();
Poco::Path result;
while (!Poco::Path::find(root.toString(), "data", result))
{
root.makeParent();
if (root.toString().empty() || root.toString() == "/")
throw Poco::FileNotFoundException("Didn't find data subdir");
}
result.makeDirectory();
result.setFileName(afile);
Poco::File aFile(result.toString());
if (!aFile.exists() || (aFile.exists() && !aFile.isFile()))
throw Poco::FileNotFoundException("Didn't find file " + afile);
return result;
}
void Host::ReadModuleManifest(std::string& modulePath)
{
Poco::Path manifestPath(modulePath);
Poco::Path moduleTopDir = manifestPath.parent();
manifestPath = Poco::Path(FileUtils::Join(moduleTopDir.toString().c_str(), "manifest", NULL));
Poco::File manifestFile(manifestPath);
if (manifestFile.exists())
{
this->logger->Trace("Reading manifest for module: %s", manifestPath.toString().c_str());
Poco::AutoPtr<Poco::Util::PropertyFileConfiguration> manifest = new Poco::Util::PropertyFileConfiguration(manifestFile.path());
if (manifest->hasProperty("libpath"))
{
std::string libPath = manifest->getString("libpath");
Poco::StringTokenizer t(libPath, ",", Poco::StringTokenizer::TOK_TRIM);
#if defined(OS_WIN32)
std::string libPathEnv = "PATH";
#elif defined(OS_OSX)
std::string libPathEnv = "DYLD_LIBRARY_PATH";
#elif defined(OS_LINUX)
std::string libPathEnv = "LD_LIBRARY_PATH";
#endif
std::string newLibPath;
if (Environment::has(libPathEnv))
{
newLibPath = Environment::get(libPathEnv);
}
for (size_t i = 0; i < t.count(); i++)
{
std::string lib = t[i];
newLibPath = FileUtils::Join(moduleTopDir.toString().c_str(), lib.c_str(), NULL) +
KR_LIB_SEP + newLibPath;
}
this->logger->Debug("%s=%s", libPathEnv.c_str(), newLibPath.c_str());
Environment::set(libPathEnv, newLibPath);
}
}
}
/**
* Module initialization function. Optionally receives an output folder
* path as the location for saving the files corresponding to interesting
* file set hits. The default output folder path is a folder named for the
* module in #MODULE_OUT_DIR#.
*
* @param args Optional output folder path.
* @return TskModule::OK if an output folder is created, TskModule::FAIL
* otherwise.
*/
TSK_MODULE_EXPORT TskModule::Status initialize(const char* arguments)
{
TskModule::Status status = TskModule::OK;
const std::string MSG_PREFIX = "SaveInterestingFilesModule::initialize : ";
try
{
Poco::Path outputDirPath;
if (strlen(arguments) != 0)
{
outputDirPath = Poco::Path::forDirectory(arguments);
}
else
{
outputDirPath = Poco::Path::forDirectory(GetSystemProperty(TskSystemProperties::MODULE_OUT_DIR));
outputDirPath.pushDirectory(name());
}
outputFolderPath = outputDirPath.toString();
Poco::File(outputDirPath).createDirectory();
}
catch (TskException &ex)
{
status = TskModule::FAIL;
outputFolderPath.clear();
std::stringstream msg;
msg << MSG_PREFIX << "TskException: " << ex.message();
LOGERROR(msg.str());
}
catch (Poco::Exception &ex)
{
status = TskModule::FAIL;
outputFolderPath.clear();
std::stringstream msg;
msg << MSG_PREFIX << "Poco::Exception: " << ex.displayText();
LOGERROR(msg.str());
}
catch (std::exception &ex)
{
status = TskModule::FAIL;
outputFolderPath.clear();
std::stringstream msg;
msg << MSG_PREFIX << "std::exception: " << ex.what();
LOGERROR(msg.str());
}
catch (...)
{
status = TskModule::FAIL;
outputFolderPath.clear();
LOGERROR(MSG_PREFIX + "unrecognized exception");
}
return status;
}
std::string EnggDiffractionViewQtGUI::guessGSASTemplatePath() const {
// Inside the mantid installation target directory:
// scripts/Engineering/template_ENGINX_241391_236516_North_and_South_banks.par
Poco::Path templ =
Mantid::Kernel::ConfigService::Instance().getInstrumentDirectory();
templ = templ.makeParent();
templ.append("scripts");
templ.append("Engineering");
templ.append("template_ENGINX_241391_236516_North_and_South_banks.par");
return templ.toString();
}
void ComputeApp::initialize(Application& self)
{
Application::initialize(self);
Poco::Path appPath = commandPath();
appPath.setExtension("");
appPath.setFileName("");
exeDirectory = appPath.toString();
loadConfiguration();
}
void Converter::initialize(
const string_t& inputFolder,
const string_t& outputFolder,
const string_t& mappingFolder )
{
inputFolder_ = Poco::Path(inputFolder)
.makeAbsolute()
.makeDirectory()
.toString();
outputFolder_ = Poco::Path(outputFolder)
.makeAbsolute()
.makeDirectory()
.toString();
mappingFolder_ = Poco::Path(mappingFolder)
.makeAbsolute()
.makeDirectory()
.toString();
/// load font names which support all languages. these are generic unicode
loadFontList(mappingFolder_ + "font-generic-unicode.txt", fontsAllCharSupport_);
/// load fonts that should be ignore as they are discovered
loadFontList(mappingFolder_ + "font-ignore-list.txt", fontsToIgnore_);
/// characters mapping for each available language
FileFinder ff(true, mappingFolder_);
auto files = ff.getFiles();
auto dirs = ff.getDirs();
for (auto itd = dirs.begin(); itd != dirs.end(); ++itd) {
Poco::Path langDir = Poco::Path(ff.getRootPath())
.pushDirectory(*itd)
.makeDirectory();
loadKnownAsciiFonts(langDir.toString(), *itd);
loadNamesMapping(langDir.toString() + "font-mapping-default.txt", *itd, false);
loadNamesMapping(langDir.toString() + "font-mapping-user.txt", *itd, true);
}
}
std::string EnggDiffractionViewQtGUI::guessDefaultFullCalibrationPath() const {
// Inside the mantid installation target directory:
// scripts/Engineering/ENGINX_full_pixel_calibration_vana194547_ceria193749.csv
Poco::Path templ =
Mantid::Kernel::ConfigService::Instance().getInstrumentDirectory();
templ = templ.makeParent();
templ.append("scripts");
templ.append("Engineering");
templ.append("calib");
templ.append("ENGINX_full_pixel_calibration_vana194547_ceria193749.csv");
return templ.toString();
}
int countLoolKitProcesses()
{
// Give polls in the lool processes time to time out etc
Poco::Thread::sleep(POLL_TIMEOUT_MS*5);
int result = 0;
for (auto i = Poco::DirectoryIterator(std::string("/proc")); i != Poco::DirectoryIterator(); ++i)
{
try
{
Poco::Path procEntry = i.path();
const std::string& fileName = procEntry.getFileName();
int pid;
std::size_t endPos = 0;
try
{
pid = std::stoi(fileName, &endPos);
}
catch (const std::invalid_argument&)
{
pid = 0;
}
if (pid > 1 && endPos == fileName.length())
{
Poco::FileInputStream stat(procEntry.toString() + "/stat");
std::string statString;
Poco::StreamCopier::copyToString(stat, statString);
Poco::StringTokenizer tokens(statString, " ");
if (tokens.count() > 3 && tokens[1] == "(loolkit)")
{
switch (tokens[2].c_str()[0])
{
case 'x':
case 'X': // Kinds of dead-ness.
case 'Z': // zombies
break; // ignore
default:
result++;
break;
}
// std::cout << "Process:" << pid << ", '" << tokens[1] << "'" << " state: " << tokens[2] << std::endl;
}
}
}
catch (const Poco::Exception&)
{
}
}
// std::cout << "Number of loolkit processes: " << result << std::endl;
return result;
}
Poco::Path XplDevice::GetConfigFileLocation() {
Poco::Path p ( Poco::Path::home() );
p.pushDirectory ( ".xPL" );
File test = File(p);
if (!test.exists()){
poco_debug ( devLog, "dir doesn't exist: " + p.toString() );
test.createDirectory();
}
p.pushDirectory ( "xPLSDK_configs" );
test = File(p);
if (!test.exists()){
poco_debug ( devLog, "dir doesn't exist: " + p.toString() );
test.createDirectory();
}
p.setFileName ( GetCompleteId() + ".conf" );
test = File(p);
if (!test.exists()){
poco_debug ( devLog, "file doesn't exist: " + p.toString() );
test.createFile();
}
return p;
}
void DebugBreakpointManager::SaveState(const Poco::Path& path) const
{
Poco::XML::Document* doc = new Poco::XML::Document();
Poco::XML::Element* breakpoints = doc->createElement(BREAKPOINTS_TAG);
doc->appendChild(breakpoints)->release();
for (std::set<unsigned long>::const_iterator i = m_ObjectBreakpoints.begin(); i
!= m_ObjectBreakpoints.end(); ++i)
{
Poco::XML::Element* objectBreakpoint = doc->createElement(OBJECT_TAG);
breakpoints->appendChild(objectBreakpoint)->release();
std::stringstream ss;
ss << *i;
objectBreakpoint->setAttribute(ID_ATTR, ss.str());
const Object* obj = DebugUtil::GetObject(*i);
if (obj)
{
objectBreakpoint->setAttribute(CLASSNAME_ATTR, obj->GetClassName());
}
}
for (Poco::HashMap<int, const Object*>::ConstIterator i =
m_SmartPointerBreakpoints.begin(); i != m_SmartPointerBreakpoints.end(); ++i)
{
Poco::XML::Element* spBreakpoint = doc->createElement(SMARTPOINTER_TAG);
breakpoints->appendChild(spBreakpoint)->release();
std::stringstream ss;
ss << i->first;
spBreakpoint->setAttribute(ID_ATTR, ss.str());
const Object* obj = i->second;
if (i->second)
{
spBreakpoint->setAttribute(CLASSNAME_ATTR, obj->GetClassName());
ss.clear();
ss << obj->GetTraceId();
spBreakpoint->setAttribute(OBJECTID_ATTR, ss.str());
}
}
Poco::FileOutputStream writer(path.toString());
Poco::XML::DOMWriter out;
out.setOptions(3); //write declaration and pretty print
out.writeNode(writer, doc);
doc->release();
}
const std::string OptionsPage::GenerateContent(const std::string &method, const std::map<std::string,QueryVar> &queryvars)
{
std::string content("");
std::string sql("");
if(queryvars.find("formaction")!=queryvars.end() && (*queryvars.find("formaction")).second=="save" && ValidateFormPassword(queryvars))
{
Option option(m_db);
option.ClearCache();
std::vector<std::string> options;
std::vector<std::string> oldvalues;
std::vector<std::string> newvalues;
CreateArgArray(queryvars,"option",options);
CreateArgArray(queryvars,"oldvalue",oldvalues);
CreateArgArray(queryvars,"value",newvalues);
for(int i=0; i<options.size(); i++)
{
if(oldvalues[i]!=newvalues[i])
{
option.Set(options[i],newvalues[i]);
// load new language immediately
if(options[i]=="Language")
{
Poco::Path tdir;
tdir.pushDirectory(global::basepath+"translations");
tdir=tdir.makeAbsolute();
tdir.setFileName(newvalues[i]);
m_trans->LoadLocalizedTranslation(tdir.toString());
}
if(options[i]=="MessageDownloadMaxDaysBackward")
{
m_db->Execute("INSERT OR IGNORE\
INTO tblMessageRequests (IdentityID, Day, RequestIndex, Found)\
SELECT M.IdentityID, M.InsertDate, M.MessageIndex, 'true'\
FROM tblMessage M\
LEFT JOIN tblMessageRequests R\
ON M.IdentityID=R.IdentityID\
AND M.MessageIndex=R.RequestIndex\
AND M.InsertDate=R.Day\
WHERE R.IdentityID IS NULL\
AND M.IdentityID IS NOT NULL\
AND M.InsertDate >= date('now',(SELECT -MAX(OptionValue,0) FROM tblOption \
WHERE Option='MessageDownloadMaxDaysBackward')||' days');");
}
}
/**
* Confirm that an executable file exists at location.
*/
void TskExecutableModule::setPath(const std::string& location)
{
try
{
// Autogenerate filename extension if needed
Poco::Path tempPath = location;
if (tempPath.getExtension().empty())
{
std::string os = Poco::Environment::osName();
if (os.find("Windows") != std::string::npos ||
os.find("CYGWIN") != std::string::npos ||
os.find("MINGW") != std::string::npos )
{
tempPath.setExtension("exe");
}
// Else we assume the user is on a platform that doesn't use executable extensions.
}
// Call our parent to validate the location.
TskModule::setPath(tempPath.toString());
m_name = Poco::Path(m_modulePath).getBaseName();
// Verify that the file is executable.
Poco::File exeFile(m_modulePath);
if (!exeFile.canExecute())
{
std::wstringstream msg;
msg << L"TskExecutableModule::setPath - File is not executable: "
<< m_modulePath.c_str();
LOGERROR(msg.str());
throw TskException("File is not executable.");
}
}
catch (TskException& tskEx)
{
throw tskEx;
}
catch(std::exception& ex)
{
// Log a message and throw a framework exception.
std::wstringstream msg;
msg << "TskExecutableModule::setPath : " << ex.what();
LOGERROR(msg.str());
throw TskException("Failed to set location: " + m_modulePath);
}
}
/// Loads and registers plugin libraries
bool LoadPlugins (pI::BaseApplication& app) {
std::string baseDir = app.FindPIBaseDir();
if (baseDir.empty()) {
return false;
}
Poco::Path pluginDir (baseDir);
#ifdef _DEBUG
pluginDir.pushDirectory ("DistDebug");
#else
pluginDir.pushDirectory ("DistRelease");
#endif
app.LoadPluginLibrary (pluginDir.toString().c_str(), "CImg_pIns");
app.LoadPluginLibrary (pluginDir.toString().c_str(), "FLLL_pIns");
app.LoadPluginLibrary (pluginDir.toString().c_str(), "OpenCV_pIns");
app.LoadPluginLibrary (pluginDir.toString().c_str(), "Freenect_pIns");
app.RegisterPlugins();
return true;
}
