1
0
Fork 0
flightgear/src/Main/logger.cxx

189 lines
4.8 KiB
C++
Raw Normal View History

2002-03-12 16:29:00 +00:00
// logger.cxx - log properties.
// Written by David Megginson, started 2002.
//
// This file is in the Public Domain, and comes with no warranty.
2008-07-31 12:04:32 +00:00
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
2002-03-12 16:29:00 +00:00
#include "logger.hxx"
#include <ios>
#include <string>
#include <cstdlib>
2002-03-12 16:29:00 +00:00
#include <simgear/debug/logstream.hxx>
#include <simgear/io/iostreams/sgstream.hxx>
#include <simgear/misc/sg_path.hxx>
2002-03-12 16:29:00 +00:00
#include "fg_props.hxx"
#include "globals.hxx"
#include "util.hxx"
2002-03-12 16:29:00 +00:00
2008-07-31 12:04:32 +00:00
using std::string;
using std::endl;
2002-03-12 16:29:00 +00:00
////////////////////////////////////////////////////////////////////////
// Implementation of FGLogger
////////////////////////////////////////////////////////////////////////
FGLogger::FGLogger ()
{
}
FGLogger::~FGLogger ()
{
for (unsigned int i = 0; i < _logs.size(); i++) {
delete _logs[i];
}
_logs.clear();
2002-03-12 16:29:00 +00:00
}
void
FGLogger::init ()
{
SGPropertyNode * logging = fgGetNode("/logging");
if (logging == 0)
return;
std::vector<SGPropertyNode_ptr> children = logging->getChildren("log");
for (unsigned int i = 0; i < children.size(); i++) {
SGPropertyNode * child = children[i];
if (!child->getBoolValue("enabled", false))
continue;
_logs.push_back(new Log());
Log &log = *_logs[_logs.size()-1];
string filename = child->getStringValue("filename");
if (filename.empty()) {
filename = "fg_log.csv";
child->setStringValue("filename", filename.c_str());
}
// Security: the path comes from the global Property Tree; it *must* be
// validated before we overwrite the file.
const SGPath authorizedPath = fgValidatePath(SGPath::fromUtf8(filename),
/* write */ true);
if (authorizedPath.isNull()) {
const string propertyPath = child->getChild("filename")
->getPath(/* simplify */ true);
const string msg =
"The FGLogger logging system, via the '" + propertyPath + "' property, "
"was asked to write to '" + filename + "', however this path is not "
"authorized for writing anymore for security reasons. " +
"Please choose another location, for instance in the $FG_HOME/Export "
"folder (" + (globals->get_fg_home() / "Export").utf8Str() + ").";
SG_LOG(SG_GENERAL, SG_ALERT, msg);
exit(EXIT_FAILURE);
}
string delimiter = child->getStringValue("delimiter");
if (delimiter.empty()) {
delimiter = ",";
child->setStringValue("delimiter", delimiter.c_str());
}
log.interval_ms = child->getLongValue("interval-ms");
log.last_time_ms = globals->get_sim_time_sec() * 1000;
log.delimiter = delimiter.c_str()[0];
// Security: use the return value of fgValidatePath()
log.output = new sg_ofstream(authorizedPath, std::ios_base::out);
2002-03-12 16:29:00 +00:00
if (!log.output) {
SG_LOG(SG_GENERAL, SG_ALERT, "Cannot write log to " << filename);
2002-03-12 16:29:00 +00:00
continue;
}
//
// Process the individual entries (Time is automatic).
//
2008-07-31 12:04:32 +00:00
std::vector<SGPropertyNode_ptr> entries = child->getChildren("entry");
2002-03-12 16:29:00 +00:00
(*log.output) << "Time";
for (unsigned int j = 0; j < entries.size(); j++) {
2002-03-12 16:29:00 +00:00
SGPropertyNode * entry = entries[j];
//
// Set up defaults.
//
if (!entry->hasValue("property")) {
entry->setBoolValue("enabled", false);
continue;
}
if (!entry->getBoolValue("enabled"))
continue;
2002-03-12 16:29:00 +00:00
SGPropertyNode * node =
fgGetNode(entry->getStringValue("property"), true);
log.nodes.push_back(node);
(*log.output) << log.delimiter
<< entry->getStringValue("title", node->getPath().c_str());
2002-03-12 16:29:00 +00:00
}
(*log.output) << endl;
}
}
void
FGLogger::reinit ()
{
for (unsigned int i = 0; i < _logs.size(); i++) {
delete _logs[i];
}
_logs.clear();
init();
}
2002-03-12 16:29:00 +00:00
void
FGLogger::bind ()
{
}
void
FGLogger::unbind ()
{
}
void
FGLogger::update (double dt)
2002-03-12 16:29:00 +00:00
{
double sim_time_sec = globals->get_sim_time_sec();
double sim_time_ms = sim_time_sec * 1000;
for (unsigned int i = 0; i < _logs.size(); i++) {
while ((sim_time_ms - _logs[i]->last_time_ms) >= _logs[i]->interval_ms) {
_logs[i]->last_time_ms += _logs[i]->interval_ms;
(*_logs[i]->output) << sim_time_sec;
for (unsigned int j = 0; j < _logs[i]->nodes.size(); j++) {
(*_logs[i]->output) << _logs[i]->delimiter
<< _logs[i]->nodes[j]->getStringValue();
}
(*_logs[i]->output) << endl;
}
2002-03-12 16:29:00 +00:00
}
}
////////////////////////////////////////////////////////////////////////
// Implementation of FGLogger::Log
////////////////////////////////////////////////////////////////////////
FGLogger::Log::Log ()
: output(0),
interval_ms(0),
last_time_ms(-999999.0),
delimiter(',')
2002-03-12 16:29:00 +00:00
{
}
FGLogger::Log::~Log ()
{
delete output;
}
// end of logger.cxx