int MetaConfig::flushNodeSrvs(TiXmlHandle *meta)
{
std::vector<NodeService> tmp;
TiXmlHandle srvs = meta->FirstChildElement("services");
if(srvs.Element()){
TiXmlHandle srv = srvs.FirstChildElement("service");
while(srv.Element()){
NodeService ns;
loadInt(&srv, "gid", ns.gid, -1);
loadString(&srv, "name", ns.service, "");
loadString(&srv, "ip", ns.ip, "");
loadInt(&srv, "port", ns.port, -1);
if(!(ns.gid != -1 && !ns.service.empty() && !ns.ip.empty() && ns.port != -1)){
std::cerr << "load service error name:" << ns.service << " ip:" << ns.ip << " port:" << ns.port << " node:" << ns.gid<< std::endl;
return -1;
}
tmp.push_back(ns);
srv = srv.Element()->NextSibling("service");
}
std::sort(tmp.begin(), tmp.end());
std::unique(tmp.begin(), tmp.end());
}
boost::mutex::scoped_lock lock(mtx);
ndSrvs.swap(tmp);
return 0;
}
void TinyXmlServerConfigImp::loadServer(TiXmlHandle &serverH){
TiXmlElement *portE = serverH.FirstChildElement("port").Element();
if(portE){
port = atoi(portE->GetText());
}
if(port == 0){
log(Fatal, "config port first");
exit(-1);
}
TiXmlElement *nameE = serverH.FirstChildElement("name").Element();
if(nameE){
//null to die;
name = nameE->GetText();
}
TiXmlElement *fportE = serverH.FirstChildElement("front_port").Element();
while(fportE){
uint16_t p = atoi(fportE->GetText());
if(p != 0)
frontPorts.push_back(p);
fportE = fportE->NextSiblingElement("front_port");
}
TiXmlElement *groupE = serverH.FirstChildElement("group").Element();
if(groupE){
groupId = atoi(groupE->GetText());
}else{
groupId = 0;
}
}
void TinyXmlConfigKdc::loadServer(TiXmlHandle &serverH)
{
TiXmlElement *confDb = serverH.FirstChildElement("kerberos_db").Element();
if(confDb){
dbName = confDb->GetText();
}
TiXmlElement *confTable = serverH.FirstChildElement("service_table").Element();
if(confTable){
tableName = confTable->GetText();
}
TiXmlElement *confDbPwd = serverH.FirstChildElement("secret").Element();
if(confDbPwd){
dbPwd = confDbPwd->GetText();
}
TiXmlElement *confProxyIp = serverH.FirstChildElement("uhs_proxy_ip").Element();
if(confProxyIp){
proxyIp = confProxyIp->GetText();
}
TiXmlElement *confProxyPort = serverH.FirstChildElement("uhs_proxy_port").Element();
if(confProxyPort){
proxyPort = atoi(confProxyPort->GetText());
}else{
proxyPort = 0;
}
TinyXmlServerConfigImp::loadServer(serverH);
}
void TinyXmlConfigSession::loadServer(TiXmlHandle &serverH){
TiXmlElement *ctlProxyE = serverH.FirstChildElement("min_ctl_proxy").Element();
if(ctlProxyE){
minCtlProxy = atoi(ctlProxyE->GetText());
}else{
minCtlProxy = 0;
}
TiXmlElement *cncProxyE = serverH.FirstChildElement("min_cnc_proxy").Element();
if(cncProxyE){
minCncProxy = atoi(cncProxyE->GetText());
}else{
minCncProxy = 0;
}
TiXmlElement *proxyUserE = serverH.FirstChildElement("max_proxy_user").Element();
if(proxyUserE){
maxProxyUser = atoi(proxyUserE->GetText());
}else{
maxProxyUser = 0;
}
TinyXmlServerConfigImp::loadServer(serverH);
}
void TinyXmlConfigUhsProxy::loadServer(TiXmlHandle &serverH)
{
TiXmlElement *confProxyIp = serverH.FirstChildElement("uhs_proxy_ip").Element();
if(confProxyIp){
proxyIp = confProxyIp->GetText();
}
TiXmlElement *confProxyPort = serverH.FirstChildElement("uhs_proxy_port").Element();
if(confProxyPort){
proxyPort = atoi(confProxyPort->GetText());
}else{
proxyPort = 0;
}
TinyXmlConfigDbd::loadServer(serverH);
}
void Animation::ReadXml(const char* filename)
{
m_animationParts.clear(); // clear our parts list first
// create a new xml document
XmlDocument doc;
doc.Load(filename);
TiXmlHandle * hdoc = doc.Handle();
TiXmlElement * root = hdoc->FirstChildElement().Element();
if(root != 0)
{
TiXmlElement * child = root->FirstChildElement();
// loop through children
while(child)
{
// whats the name of this part
string partName = (string)child->Value();
// add this part to the part map
m_animationParts[partName] = new AnimationPart(child);
// move to the next game object
child = child->NextSiblingElement();
}
}
}
//---------------------------------------------------------
bool ofXMLSettings::readTag(string tag, char * valueString, int which){
vector<string> tokens = tokenize(tag,":");
TiXmlHandle tagHandle = *storedHandle;
for(int x=0;x<tokens.size();x++){
if(x == 0)tagHandle = tagHandle.ChildElement(tokens.at(x), which);
else tagHandle = tagHandle.FirstChildElement( tokens.at(x) );
}
// once we've walked, let's get that value...
TiXmlHandle valHandle = tagHandle.Child( 0 );
//now, clear that vector!
tokens.clear();
// if that value is really text, let's get the value out of it !
if (valHandle.Text()){
int maxLen = MIN(MAX_TAG_VALUE_LENGTH_IN_CHARS, strlen(valHandle.Text()->Value()));
memcpy(valueString, valHandle.Text()->Value(), maxLen);
return true;
} else {
return false;
}
}
//---------------------------------------------------------
int ofxXmlSettings::writeAttribute(const string& tag, const string& attribute, const string& valueString, int which){
vector<string> tokens = tokenize(tag,":");
TiXmlHandle tagHandle = storedHandle;
for (int x = 0; x < (int)tokens.size(); x++) {
if (x == 0)
tagHandle = tagHandle.ChildElement(tokens.at(x), which);
else
tagHandle = tagHandle.FirstChildElement(tokens.at(x));
}
int ret = 0;
if (tagHandle.ToElement()) {
TiXmlElement* elem = tagHandle.ToElement();
elem->SetAttribute(attribute, valueString);
// Do we really need this? We could just ignore this and remove the 'addAttribute' functions...
// Now, just get the ID.
int numSameTags;
TiXmlElement* child = ( storedHandle.FirstChildElement( tokens.at(0) ) ).ToElement();
for (numSameTags = 0; child; child = child->NextSiblingElement( tokens.at(0) ), ++numSameTags) {
// nothing
}
ret = numSameTags;
}
return ret;
}
void MaterialManager::Initialise(char *materialXMLFile)
{
// read through the xml file and load all materials
XmlDocument doc;
doc.Load(materialXMLFile);
TiXmlHandle * hdoc = doc.Handle();
TiXmlElement * root = hdoc->FirstChildElement().Element();
TiXmlElement * child = root->FirstChildElement();
// loop through our materials
while(child)
{
// get the name of the material
const char * matName = XmlUtilities::ReadAttributeAsString(child, "", "name");
// create the new material
Material* mat = new Material(matName);
mat->ReadXml(child); // read the properties
m_materialMap[matName] = mat; // add to the material map
// move to the next material
child = child->NextSiblingElement();
}
}
void TinyXmlConfigDbd::loadServer(TiXmlHandle &serverH){
TiXmlElement *db = serverH.FirstChildElement("default-db").Element();
if(db){
std::string master = db->Attribute("master");
std::string slave = db->Attribute("slave");
defaultNames = make_pair(master, slave);
}
TiXmlElement *id = serverH.FirstChildElement("default-db-id").Element();
if(id){
defaultId = atoi(id->GetText());
}
TinyXmlServerConfigImp::loadServer(serverH);
}
void TinyXmlConfigUhsProxyNew::loadServer(TiXmlHandle &serverH)
{
TiXmlElement *confProxyMode = serverH.FirstChildElement("proxy_mode").Element();
if(confProxyMode){
proxyMode = confProxyMode->GetText();
}
TinyXmlConfigDbd::loadServer(serverH);
}
//---------------------------------------------------------
TiXmlElement* ofxXmlSettings::getElementForAttribute(const string& tag, int which){
vector<string> tokens = tokenize(tag,":");
TiXmlHandle tagHandle = storedHandle;
for (int x = 0; x < (int)tokens.size(); x++) {
if (x == 0)
tagHandle = tagHandle.ChildElement(tokens.at(x), which);
else
tagHandle = tagHandle.FirstChildElement(tokens.at(x));
}
return tagHandle.ToElement();
}
void TinyXmlConfigOraDbd::loadServer(TiXmlHandle &serverH){
//提取进程所需的数据库id配置
TiXmlElement *id = serverH.FirstChildElement("default-ora-db-id").Element();
if(id){
defaultId = atoi(id->GetText());
log(Info, "get Oracle-dbid[%d]\n", defaultId);
}
memcaches.clear();
TiXmlElement *mc = serverH.FirstChildElement("memcache").Element();
while(mc){
std::string host = getStr(mc->FirstChildElement("host"));
int port = atoi(getStr(mc->FirstChildElement("port")).data());
memcaches.push_back(make_pair(host, port));
mc = mc->NextSiblingElement("memcache");
}
TinyXmlServerConfigImp::loadServer(serverH);
}
bool CppCheck::DoCppCheckParseXMLv2(TiXmlHandle& Handle)
{
bool ErrorsPresent = false;
const TiXmlHandle& Errors = Handle.FirstChildElement("errors");
for (const TiXmlElement* Error = Errors.FirstChildElement("error").ToElement();
Error;
Error = Error->NextSiblingElement("error"))
{
wxString Id;
if (const char* IdValue = Error->Attribute("id"))
Id = wxString::FromAscii(IdValue);
wxString Severity;
if (const char* SeverityValue = Error->Attribute("severity"))
Severity = wxString::FromAscii(SeverityValue);
wxString Message;
if (const char* MessageValue = Error->Attribute("msg"))
Message = wxString::FromAscii(MessageValue);
wxString CWE;
if (const char* CWEValue = Error->Attribute("cwe"))
CWE = wxString::FromAscii(CWEValue);
wxString Verbose;
if (const char* VerboseValue = Error->Attribute("verbose"))
Verbose = wxString::FromAscii(VerboseValue);
const wxString FullMessage = Id + _T(" : ") + Severity + _T(" : ") + Verbose;
wxString File;
wxString Line;
const TiXmlElement* Location = Error->FirstChildElement("location");
if (nullptr!=Location)
{
if (const char* FileValue = Location->Attribute("file"))
File = wxString::FromAscii(FileValue);
if (const char* LineValue = Location->Attribute("line"))
Line = wxString::FromAscii(LineValue);
}
if (!FullMessage.IsEmpty() && !File.IsEmpty() && !Line.IsEmpty())
{
wxArrayString Arr;
Arr.Add(File);
Arr.Add(Line);
Arr.Add(FullMessage);
m_ListLog->Append(Arr);
ErrorsPresent = true;
}
else if (!Message.IsEmpty())
AppendToLog(Message); // might be something important like config not found...
}
return ErrorsPresent;
}
//---------------------------------------------------------
bool ofxXmlSettings::readTag(const string& tag, TiXmlHandle& valHandle, int which){
vector<string> tokens = tokenize(tag,":");
TiXmlHandle tagHandle = storedHandle;
for(int x=0;x<(int)tokens.size();x++){
if(x == 0)tagHandle = tagHandle.ChildElement(tokens.at(x), which);
else tagHandle = tagHandle.FirstChildElement( tokens.at(x) );
}
// once we've walked, let's get that value...
valHandle = tagHandle.Child( 0 );
return (valHandle.ToText() != NULL);
}
bool Recordings::LoadLocations()
{
std::string url;
if (Settings::GetInstance().GetRecordingsFromCurrentLocationOnly())
url = StringUtils::Format("%s%s", Settings::GetInstance().GetConnectionURL().c_str(), "web/getcurrlocation");
else
url = StringUtils::Format("%s%s", Settings::GetInstance().GetConnectionURL().c_str(), "web/getlocations");
const std::string strXML = WebUtils::GetHttpXML(url);
TiXmlDocument xmlDoc;
if (!xmlDoc.Parse(strXML.c_str()))
{
Logger::Log(LEVEL_ERROR, "%s Unable to parse XML: %s at line %d", __FUNCTION__, xmlDoc.ErrorDesc(), xmlDoc.ErrorRow());
return false;
}
TiXmlHandle hDoc(&xmlDoc);
TiXmlElement* pElem = hDoc.FirstChildElement("e2locations").Element();
if (!pElem)
{
Logger::Log(LEVEL_ERROR, "%s Could not find <e2locations> element", __FUNCTION__);
return false;
}
TiXmlHandle hRoot = TiXmlHandle(pElem);
TiXmlElement* pNode = hRoot.FirstChildElement("e2location").Element();
if (!pNode)
{
Logger::Log(LEVEL_ERROR, "%s Could not find <e2location> element", __FUNCTION__);
return false;
}
for (; pNode != nullptr; pNode = pNode->NextSiblingElement("e2location"))
{
const std::string strTmp = pNode->GetText();
m_locations.emplace_back(strTmp);
Logger::Log(LEVEL_DEBUG, "%s Added '%s' as a recording location", __FUNCTION__, strTmp.c_str());
}
Logger::Log(LEVEL_INFO, "%s Loaded '%d' recording locations", __FUNCTION__, m_locations.size());
return true;
}
void TinyXmlConfigHADbd::loadServer(TiXmlHandle &serverH){
//提取进程所需的数据库id配置
TiXmlElement *id = serverH.FirstChildElement("default-ora-db-id").Element();
if(id){
defaultId = atoi(id->GetText());
log(Info, "get Oracle-dbid[%d]\n", defaultId);
}
id = serverH.FirstChildElement("dbnode_max_connect").Element();
if(id){
dbnode_max_connect = atoi(id->GetText());
log(Info, "get Oracle-dbnode_max_connect[%d]\n", dbnode_max_connect);
}
else
{
dbnode_max_connect=100;
}
id = serverH.FirstChildElement("dbnode_time_out_mill").Element();
if(id){
dbnode_time_out_mill = atoi(id->GetText());
log(Info, "get Oracle-dbnode_time_out_mill[%d]\n", dbnode_time_out_mill);
}
else
{
dbnode_time_out_mill=5000;
}
id = serverH.FirstChildElement("broker_uri").Element();
if(id){
_brokerURI = id->GetText();
log(Info, "get Oracle-broker_uri[%s]\n", _brokerURI.c_str());
}
else
{
_brokerURI.clear();
}
memcaches.clear();
TiXmlElement *mc = serverH.FirstChildElement("memcache").Element();
while(mc){
std::string host = getStr(mc->FirstChildElement("host"));
int port = atoi(getStr(mc->FirstChildElement("port")).data());
memcaches.push_back(make_pair(host, port));
mc = mc->NextSiblingElement("memcache");
}
TiXmlElement *webdbAllow = serverH.FirstChildElement("webdbAllows").FirstChildElement("webdbAllow").Element();
webdbAllowIps.clear();
while(webdbAllow){
const char *ip = webdbAllow->Attribute("ip");
webdbAllowIps.insert(ip);
webdbAllow = webdbAllow->NextSiblingElement("webdbAllow");
}
TinyXmlServerConfigImp::loadServer(serverH);
}
//---------------------------------------------------------
void ofxXmlSettings::removeAttribute(const string& tag, const string& attribute, int which){
vector<string> tokens = tokenize(tag,":");
TiXmlHandle tagHandle = storedHandle;
for (int x = 0; x < (int)tokens.size(); x++) {
if (x == 0)
tagHandle = tagHandle.ChildElement(tokens.at(x), which);
else
tagHandle = tagHandle.FirstChildElement(tokens.at(x));
}
if (tagHandle.ToElement()) {
TiXmlElement* elem = tagHandle.ToElement();
elem->RemoveAttribute(attribute);
}
}
bool wxTreeMultiXmlMapper::DoInitWizard(const wxString &start_tag)
{
bool allok = false;
// clean up the control first
m_ctrl->DeleteAllItems();
// reset the ID counter
m_currentId = XMLMAP_BASE_ID;
// obtain handle to document
TiXmlHandle h(m_tiDoc);
// find our first wizard declaration
TiXmlHandle wizard = h.FirstChildElement(start_tag.c_str());
// we expect it to be an element, and we should go from there with
// parsing categories and other stuff..
if(wizard.Element())
{
// we skip all and look for the first category element
TiXmlElement *cat = wizard.FirstChildElement(XMLMAP_TAG_CATEGORY).Element();
// go through the loop of creating all categories
allok = (cat != 0);
while(cat && allok)
{
// ok create a category root name, but only when we
// have a name to give it
if(cat->Attribute(XMLMAP_ATTR_CAPTION))
{
wxTreeMultiItem item = AddCategory(cat, wxTreeMultiItem(0));
allok = DoCreateControls(cat, item, 0, 0);
}
// find a next one
if(allok)
cat = cat->NextSiblingElement(XMLMAP_TAG_CATEGORY);
}
}
return allok;
}
//---------------------------------------------------------
bool ofxXmlSettings::getAttributeNames(const string& tag, vector<string>& outNames, int which){
vector<string> tokens = tokenize(tag,":");
TiXmlHandle tagHandle = storedHandle;
for (int x = 0; x < (int)tokens.size(); x++) {
if (x == 0)
tagHandle = tagHandle.ChildElement(tokens.at(x), which);
else
tagHandle = tagHandle.FirstChildElement(tokens.at(x));
}
if (tagHandle.ToElement()) {
TiXmlElement* elem = tagHandle.ToElement();
// Do stuff with the element here
for (TiXmlAttribute* a = elem->FirstAttribute(); a; a = a->Next())
outNames.push_back( string(a->Name()) );
}
return !outNames.empty();
}
//---------------------------------------------------------
bool ofxXmlSettings::attributeExists(const string& tag, const string& attribute, int which){
vector<string> tokens = tokenize(tag,":");
TiXmlHandle tagHandle = storedHandle;
for (int x = 0; x < (int)tokens.size(); x++) {
if (x == 0)
tagHandle = tagHandle.ChildElement(tokens.at(x), which);
else
tagHandle = tagHandle.FirstChildElement(tokens.at(x));
}
if (tagHandle.ToElement()) {
TiXmlElement* elem = tagHandle.ToElement();
// Do stuff with the element here
for (TiXmlAttribute* a = elem->FirstAttribute(); a; a = a->Next()) {
if (a->Name() == attribute)
return true;
}
}
return false;
}
void TinyXmlServerConfigImp::load(FILE *fp){
loaded = true;
TiXmlDocument doc;
doc.LoadFile(fp);
TiXmlHandle docH( &doc );
TiXmlHandle servers = docH.FirstChildElement( "conf" ).FirstChildElement( "servers" );
if(servers.Element()){
TiXmlHandle server = servers.FirstChildElement(serverElem.data());
if(server.Element()){
loadServer(server);
}else{
log(Fatal, "%s config not found", serverElem.data());
exit(-1);
}
}else{
log(Error, "servers element is NULL");
}
forEachWatcher0(&IServerConfigWatcher::onConfigRefresh);
}
int MetaConfig::reload()
{
FILE *fp = fopen(fname.c_str(), "r");
if(!fp){
log(Warn, "reload file %s error", fname.c_str());
return -1;
}
TiXmlDocument doc;
doc.LoadFile(fp);
TiXmlHandle docH( &doc );
TiXmlHandle meta = docH.FirstChildElement( "conf" ).FirstChildElement( "servers" ).FirstChildElement("meta");
if(meta.Element()){
loadBool(&meta, "sync", bsync, false);
TiXmlHandle daemon = meta.FirstChildElement("daemon");
int ret = flushNodeSrvs(&daemon);
return ret;
}else{
fclose(fp);
return -1;
}
}
//---------------------------------------------------------
int ofxXmlSettings::getNumAttributes(const string& tag, int which){
vector<string> tokens = tokenize(tag,":");
TiXmlHandle tagHandle = storedHandle;
for (int x = 0; x < (int)tokens.size(); x++) {
if (x == 0)
tagHandle = tagHandle.ChildElement(tokens.at(x), which);
else
tagHandle = tagHandle.FirstChildElement(tokens.at(x));
}
if (tagHandle.ToElement()) {
TiXmlElement* elem = tagHandle.ToElement();
// Do stuff with the element here
TiXmlAttribute* first = elem->FirstAttribute();
if (first) {
int count = 1;
for (TiXmlAttribute* curr = first; curr != elem->LastAttribute(); curr = curr->Next())
count++;
return count;
}
}
return 0;
}
// ================================================
// Read Configuration
// vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
void ReadConfig(void)
{
TiXmlNode *bnode = NULL; // base node
TiXmlText *CfgDta = NULL;
TiXmlHandle *hConfig = NULL; // pointer to a Config handle
TiXmlElement *Config = NULL;
TiXmlText *DbDta = NULL;
TiXmlDocument doc("CigiDummyIG.def");
bool stat = doc.LoadFile();
//set default values
Port_H2IG = 8000;
Port_IG2H = 8001;
HostAddr = "127.0.0.1";
MajorVer = 3;
MinorVer = 3;
PrtIgCtrl = false;
if(stat)
{
bnode = doc.FirstChild("MiniHostInitialization");
if(bnode == NULL)
stat = false; // The file is not a Mission Function Initialization file
}
if(stat)
{
// get base configuration
Config = bnode->FirstChildElement("Config");
if(Config != NULL)
{
hConfig = new TiXmlHandle(Config);
CfgDta = hConfig->FirstChildElement("Host_Addr").Child(0).Text();
if(CfgDta)
HostAddr = CfgDta->Value();
CfgDta = hConfig->FirstChildElement("Port_To_IG").Child(0).Text();
Port_H2IG = (CfgDta) ? atoi(CfgDta->Value()) : 8000;
CfgDta = hConfig->FirstChildElement("Port_To_Host").Child(0).Text();
Port_IG2H = (CfgDta) ? atoi(CfgDta->Value()) : 8001;
CfgDta = hConfig->FirstChildElement("Hertz_rate").Child(0).Text();
Hz = (CfgDta) ? atoi(CfgDta->Value()) : 60;
timeDelayLimit = 1.0f/((float)Hz);
CfgDta = hConfig->FirstChildElement("Major_Version_Cigi").Child(0).Text();
MajorVer = (CfgDta) ? atoi(CfgDta->Value()) : 0;
if((MajorVer == 1) || (MajorVer == 2))
MinorVer = 0;
else if(MajorVer == 3)
{
CfgDta = hConfig->FirstChildElement("Minor_Version_Cigi").Child(0).Text();
MinorVer = (CfgDta) ? atoi(CfgDta->Value()) : 3;
if(MinorVer < 2)
MinorVer = 0;
else if(MinorVer > 3)
MinorVer = 3;
}
else
{
MajorVer = 3;
MinorVer = 3;
}
CfgDta = hConfig->FirstChildElement("Print_IGCtrl").Child(0).Text();
PrtIgCtrl = (memcmp((void *)CfgDta->Value(),"true",4) == 0) ? true : false;
delete hConfig;
}
}
}
bool cxProjectInfo::Load(const wxFileName& rootPath, const wxString& path, bool onlyFilters) {
wxFileName projectPath(path, wxEmptyString);
this->path = path;
this->isRoot = (projectPath == rootPath);
projectPath.SetFullName(wxT(".eprj"));
if (!projectPath.FileExists()) return false;
// Load plist file
TiXmlDocument doc;
wxFFile docffile(projectPath.GetFullPath(), _T("rb"));
wxCHECK(docffile.IsOpened() && doc.LoadFile(docffile.fp()), false);
// Get top dict
const TiXmlHandle docHandle(&doc);
const TiXmlElement* topDict = docHandle.FirstChildElement("plist").FirstChildElement().Element();
if (!topDict || strcmp(topDict->Value(), "dict") != 0) return false; // empty plist
// Parse entries
const TiXmlElement* entry = topDict->FirstChildElement();
for(; entry; entry = entry->NextSiblingElement() ) {
if (strcmp(entry->Value(), "key") != 0) return false; // invalid dict
const TiXmlElement* const value = entry->NextSiblingElement();
if (strcmp(entry->GetText(), "filters") == 0) {
// Load all filters
const TiXmlElement* filter = value->FirstChildElement();
for(; filter; filter = filter->NextSiblingElement() ) {
if (strcmp(filter->Value(), "key") != 0) return false; // invalid dict
// Set target array
wxArrayString* filterArray = NULL;
const char* filterName = filter->GetText();
if (strcmp(filterName, "includeDirs") == 0) filterArray = &this->includeDirs;
else if (strcmp(filterName, "excludeDirs") == 0) filterArray = &this->excludeDirs;
else if (strcmp(filterName, "includeFiles") == 0) filterArray = &this->includeFiles;
else if (strcmp(filterName, "excludeFiles") == 0) filterArray = &this->excludeFiles;
else {
wxASSERT(false);
break;
}
const TiXmlElement* const array = filter->NextSiblingElement();
if (strcmp(array->Value(), "array") != 0) return false; // invalid dict
const TiXmlElement* child = array->FirstChildElement();
for(; child; child = child->NextSiblingElement() ) {
const char* valType = child->Value();
if (strcmp(valType, "string") == 0) {
const char* pattern = child->GetText();
if (pattern) filterArray->Add(wxString(pattern, wxConvUTF8));
}
else {
wxASSERT(false);
}
}
filter = array; // jump over value
}
this->hasFilters = true;
if (onlyFilters) return true;
}
else if (strcmp(entry->GetText(), "environment") == 0) {
// Load all env variables
const TiXmlElement* env = value->FirstChildElement();
for(; env; env = env->NextSiblingElement() ) {
// Get Key
if (strcmp(env->Value(), "key") != 0) return false; // invalid dict
const char* key = env->GetText();
const TiXmlElement* const val = env->NextSiblingElement();
if (strcmp(val->Value(), "string") != 0) return false; // invalid dict
const char* value = val->GetText();
if (key) {
this->env[wxString(key, wxConvUTF8)] = value ? wxString(value, wxConvUTF8) : *wxEmptyString;
}
env = val; // jump over value
}
}
else if (strcmp(entry->GetText(), "fileTriggers") == 0) {
// Load all env variables
const TiXmlElement* trigger = value->FirstChildElement();
for(; trigger; trigger = trigger->NextSiblingElement() ) {
// Get Key
if (strcmp(trigger->Value(), "key") != 0) return false; // invalid dict
const char* key = trigger->GetText();
const TiXmlElement* const val = trigger->NextSiblingElement();
if (strcmp(val->Value(), "string") != 0) return false; // invalid dict
const char* value = val->GetText();
if (key && value) {
wxFileName path(wxString(value, wxConvUTF8));
path.MakeAbsolute(rootPath.GetPath());
this->triggers[wxString(key, wxConvUTF8)] = path.GetFullPath();
}
trigger = val; // jump over value
}
}
entry = value; // jump over value
}
if (onlyFilters && !this->hasFilters) return false;
return true;
}
bool cAlarmServer::loadAlarmStringsFile(const UtlString& stringsFile)
{
OsSysLog::add(FAC_ALARM, PRI_DEBUG, " load alarm strings file %s", stringsFile.data());
TiXmlDocument doc(stringsFile);
TiXmlHandle docHandle( &doc );
if (!doc.LoadFile())
{
UtlString errorMsg;
XmlErrorMsg( doc, errorMsg );
OsSysLog::add(FAC_ALARM, PRI_ERR, "failed to load alarm strings file: %s", errorMsg.data());
return false;
}
TiXmlHandle docH( &doc );
TiXmlHandle alarmServerHandle = docH.FirstChildElement("alarm_server");
TiXmlElement* settingsElement = alarmServerHandle.FirstChildElement("settings").Element();
if (settingsElement)
{
//load alarm action strings
TiXmlElement* alarmActionsElement = settingsElement->FirstChildElement("actions");
if (alarmActionsElement)
{
TiXmlElement* element = alarmActionsElement->FirstChildElement("log");
if (mpNotifiers[cAlarmData::eActionLog])
{
mpNotifiers[cAlarmData::eActionLog]->initStrings(element);
}
element = alarmActionsElement->FirstChildElement("email");
if (mpNotifiers[cAlarmData::eActionEmail])
{
mpNotifiers[cAlarmData::eActionEmail]->initStrings(element);
}
element = alarmActionsElement->FirstChildElement("sms");
if (mpNotifiers[cAlarmData::eActionSms])
{
mpNotifiers[cAlarmData::eActionSms]->initStrings(element);
}
/* Not implemented as Strings are not needed for TrapNotifier.
element = alarmActionsElement->FirstChildElement("trap");
if (mpNotifiers[cAlarmData::eActionTrap])
{
mpNotifiers[cAlarmData::eActionTrap]->initStrings(element);
}
*/
}
}
else
{
OsSysLog::add(FAC_ALARM, PRI_DEBUG,
"no <settings> element in alarm config file '%s'",
stringsFile.data());
}
//load alarm description strings
TiXmlElement* alarmDefElement = alarmServerHandle.
FirstChildElement("definitions").Element();
if (alarmDefElement)
{
TiXmlElement* element = alarmDefElement->FirstChildElement();
UtlString idStr;
UtlString descStr;
UtlString resStr;
for (; element; element=element->NextSiblingElement() )
{
idStr = element->Attribute("id");
if (idStr.isNull())
{
OsSysLog::add(FAC_ALARM, PRI_ERR,"Parsing alarm strings file %s: alarm ID is required", stringsFile.data());
continue;
}
cAlarmData* alarmData = lookupAlarm(idStr);
if (!alarmData)
{
OsSysLog::add(FAC_ALARM, PRI_ERR,"unknown alarm ID %s", idStr.data());
continue;
}
TiXmlElement* codeElement = element->FirstChildElement("shorttitle");
if (codeElement)
{
textContentShallow(descStr, codeElement);
if (!descStr.isNull())
{
UtlString tempStr;
XmlUnEscape(tempStr, descStr);
alarmData->setShortTitle(tempStr);
}
}
codeElement = element->FirstChildElement("description");
if (codeElement)
{
textContentShallow(descStr, codeElement);
if (!descStr.isNull())
{
UtlString tempStr;
XmlUnEscape(tempStr, descStr);
alarmData->setDescription(tempStr);
}
}
codeElement = element->FirstChildElement("resolution");
if (codeElement)
{
textContentShallow(resStr, codeElement);
if (!resStr.isNull())
{
UtlString tempStr;
XmlUnEscape(tempStr, resStr);
alarmData->setResolution(tempStr);
}
}
}
}
return true;
}
bool NetworkSystem::create( const string& config ){
TiXmlDocument doc( config.c_str() );
if ( !doc.LoadFile() ){
return false;
}
//create PEER
mPeer = RakNetworkFactory::GetRakPeerInterface();
//create RPC3
mRPC3 = new RakNet::RPC3();
//create Network ID manager
mNetworkIDManager = new NetworkIDManager();
TiXmlDocument * document = doc.GetDocument();
TiXmlHandle docHandle ( document );
//check if server
TiXmlElement * server = docHandle.FirstChildElement("server").Element();
if ( server ){
mType = NetworkSystem::Server;
int mMaxConnections;
if ( !server->Attribute("connections",&mMaxConnections) ){
cerr << "missing 'connections' attribute in 'server' tag" << endl;
destroy();
return false;
}
vector<SocketDescriptor> interfaces;
//loop over interfaces
for( TiXmlElement * child = docHandle.FirstChildElement("server").FirstChildElement("interface").Element(); child; child = child->NextSiblingElement("interface") )
{
if ( child ){
TiXmlHandle ifacehandle ( child );
TiXmlText * ip = ifacehandle.FirstChild("ip").FirstChild().Text();
TiXmlText * port = ifacehandle.FirstChild("port").FirstChild().Text();
if ( ip && port ){
SocketDescriptor sd;
memcpy(sd.hostAddress,ip->Value(), sizeof(char) * 32);
sd.port = atoi(port->Value());
interfaces.push_back(sd);
}
}
}
if ( interfaces.empty() ){
cerr << "no 'interfaces' specified in 'server' tag" << endl;
destroy();
return false;
}
//copy
SocketDescriptor * mSocketDescriptions = new SocketDescriptor[interfaces.size()];
for ( unsigned int i = 0; i < interfaces.size(); i++ ){
mSocketDescriptions[i] = interfaces[i];
}
mNetworkIDManager->SetIsNetworkIDAuthority(true);
mRPC3->SetNetworkIDManager(mNetworkIDManager);
//start server
mPeer->Startup(mMaxConnections,30, mSocketDescriptions, interfaces.size());
delete [] mSocketDescriptions;
}
else {
//check for client tag (should be there)
TiXmlElement * client = docHandle.FirstChildElement("client").Element();
if ( client ){
mType = NetworkSystem::Client;
mRPC3->SetNetworkIDManager(mNetworkIDManager);
//mPeer->Connect("",0,0,0);
} else {
cerr << "no 'server' or 'client' tag" << endl;
destroy();
return false;
}
}
//attach RPC
mPeer->AttachPlugin(mRPC3);
return true;
}
bool CDVDStateSerializer::XMLToDVDState( dvd_state_t *state, const std::string &xmlstate )
{
TiXmlDocument xmlDoc;
xmlDoc.Parse(xmlstate.c_str());
if( xmlDoc.Error() )
return false;
TiXmlHandle hRoot( xmlDoc.RootElement() );
if( strcmp( hRoot.Element()->Value(), "navstate" ) != 0 ) return false;
TiXmlElement *element = NULL;
TiXmlText *text = NULL;
int index = 0;
element = hRoot.FirstChildElement("registers").FirstChildElement("sprm").Element();
while( element )
{
element->Attribute("index", &index);
text = TiXmlHandle( element ).FirstChildElement("value").FirstChild().Text();
if( text && index >= 0 && index < 24 )
sscanf(text->Value(), "0x%hx", &state->registers.SPRM[index]);
element = element->NextSiblingElement("sprm");
}
element = hRoot.FirstChildElement("registers").FirstChildElement("gprm").Element();
while( element )
{
element->Attribute("index", &index);
if( index >= 0 && index < 16 )
{
text = TiXmlHandle( element ).FirstChildElement("value").FirstChild().Text();
if( text )
sscanf(text->Value(), "0x%hx", &state->registers.GPRM[index]);
text = TiXmlHandle( element ).FirstChildElement("mode").FirstChild().Text();
if( text )
sscanf(text->Value(), "0x%c", &state->registers.GPRM_mode[index]);
text = TiXmlHandle( element ).FirstChildElement("time").FirstChildElement("tv_sec").FirstChild().Text();
if( text )
sscanf(text->Value(), "%ld", &state->registers.GPRM_time[index].tv_sec);
text = TiXmlHandle( element ).FirstChildElement("time").FirstChildElement("tv_usec").FirstChild().Text();
if( text )
sscanf(text->Value(), "%ld", (long int*)&state->registers.GPRM_time[index].tv_usec);
}
element = element->NextSiblingElement("gprm");
}
if( (text = hRoot.FirstChildElement("domain").FirstChild().Text()) )
sscanf(text->Value(), "%d", (int*) &state->domain);
if( (text = hRoot.FirstChildElement("vtsn").FirstChild().Text()) )
sscanf(text->Value(), "%d", &state->vtsN);
if( (text = hRoot.FirstChildElement("pgcn").FirstChild().Text()) )
sscanf(text->Value(), "%d", &state->pgcN);
if( (text = hRoot.FirstChildElement("pgn").FirstChild().Text()) )
sscanf(text->Value(), "%d", &state->pgN);
if( (text = hRoot.FirstChildElement("celln").FirstChild().Text()) )
sscanf(text->Value(), "%d", &state->cellN);
if( (text = hRoot.FirstChildElement("cell_restart").FirstChild().Text()) )
sscanf(text->Value(), "%d", &state->cell_restart);
if( (text = hRoot.FirstChildElement("blockn").FirstChild().Text()) )
sscanf(text->Value(), "%d", &state->blockN);
{ TiXmlHandle hrsm = hRoot.FirstChildElement("rsm");
if( (text = hrsm.FirstChildElement("vtsn").FirstChild().Text()) )
sscanf(text->Value(), "%d", &state->rsm_vtsN);
if( (text = hrsm.FirstChildElement("blockn").FirstChild().Text()) )
sscanf(text->Value(), "%d", &state->rsm_blockN);
if( (text = hrsm.FirstChildElement("pgcn").FirstChild().Text()) )
sscanf(text->Value(), "%d", &state->rsm_pgcN);
if( (text = hrsm.FirstChildElement("celln").FirstChild().Text()) )
sscanf(text->Value(), "%d", &state->rsm_cellN);
element = hrsm.FirstChildElement("registers").FirstChildElement("sprm").Element();
while( element )
{
element->Attribute("index", &index);
text = TiXmlHandle(element).FirstChildElement("value").FirstChild().Text();
if( text && index >= 0 && index < 5 )
sscanf(text->Value(), "0x%hx", &state->rsm_regs[index]);
element = element->NextSiblingElement("sprm");
}
}
return true;
}
bool cAlarmServer::loadAlarmConfig(const UtlString& alarmFile, const UtlString& groupFile)
{
// load global alarm config from alarm-config.xml
OsSysLog::add(FAC_ALARM, PRI_DEBUG, "Loading alarm config files '%s' '%s'",
alarmFile.data(), groupFile.data());
// Load the alarm configuration file
TiXmlDocument alarmDoc(alarmFile);
TiXmlHandle alarmDocHandle( &alarmDoc );
if (!alarmDoc.LoadFile())
{
UtlString errorMsg;
XmlErrorMsg( alarmDoc, errorMsg );
OsSysLog::add(FAC_ALARM, PRI_ERR, "Failed to load alarm config file: %s", errorMsg.data());
return false;
}
TiXmlHandle alarmDocH( &alarmDoc );
TiXmlHandle alarmServerHandle = alarmDocH.FirstChildElement("alarm_server");
// Load the alarm group configuration file
TiXmlDocument groupDoc(groupFile);
TiXmlHandle groupDocHandle( &groupDoc );
if (!groupDoc.LoadFile())
{
UtlString errorMsg;
XmlErrorMsg( groupDoc, errorMsg );
OsSysLog::add(FAC_ALARM, PRI_ERR, "Failed to load alarm group config file: %s", errorMsg.data());
return false;
}
TiXmlHandle groupDocH( &groupDoc );
TiXmlHandle groupServerHandle = groupDocH.FirstChildElement("alarm_groups");
// Continue to process the alarm configuration file
TiXmlElement* settingsElement = alarmServerHandle.FirstChildElement("settings").Element();
if (!settingsElement)
{
OsSysLog::add(FAC_ALARM, PRI_ERR,
"No <settings> element in alarm config file '%s'",
alarmFile.data());
return false;
}
TiXmlElement* langElement = settingsElement->FirstChildElement("language");
if (langElement)
{
textContentShallow(mLanguage, langElement);
OsSysLog::add(FAC_ALARM, PRI_INFO, "Language for alarm notifications: %s", mLanguage.data());
}
//load alarm action settings
TiXmlElement* alarmActionsElement = settingsElement->FirstChildElement("actions");
if (alarmActionsElement)
{
TiXmlElement* element = alarmActionsElement->FirstChildElement("log");
if (getBoolAttribute(element, "enabled"))
{
LogNotifier* pLogNotifier = new LogNotifier();
if (mpNotifiers[cAlarmData::eActionLog])
{
delete mpNotifiers[cAlarmData::eActionLog];
}
mpNotifiers[cAlarmData::eActionLog] = pLogNotifier;
if (pLogNotifier)
{
pLogNotifier->init(element, NULL);
gbActions[cAlarmData::eActionLog] = true;
}
}
// Alarm email notifications
element = alarmActionsElement->FirstChildElement("email");
if (getBoolAttribute(element, "enabled"))
{
EmailNotifier* pEmailNotifier = new EmailNotifier();
if (mpNotifiers[cAlarmData::eActionEmail])
{
delete mpNotifiers[cAlarmData::eActionEmail];
}
mpNotifiers[cAlarmData::eActionEmail] = pEmailNotifier;
if (pEmailNotifier)
{
TiXmlElement* groupElement = groupServerHandle.FirstChildElement("definitions").Element();
pEmailNotifier->init(element, groupElement);
gbActions[cAlarmData::eActionEmail] = true;
}
}
element = alarmActionsElement->FirstChildElement("sms");
if (getBoolAttribute(element, "enabled"))
{
SmsNotifier* pSmsNotifier = new SmsNotifier();
if (mpNotifiers[cAlarmData::eActionSms])
{
delete mpNotifiers[cAlarmData::eActionSms];
}
mpNotifiers[cAlarmData::eActionSms] = pSmsNotifier;
if (pSmsNotifier)
{
TiXmlElement* groupElement = groupServerHandle.FirstChildElement("definitions").Element();
pSmsNotifier->init(element, groupElement);
gbActions[cAlarmData::eActionSms] = true;
}
}
// Alarm SNMPv2 trap notifications
element = alarmActionsElement->FirstChildElement("trap");
if (getBoolAttribute(element, "enabled"))
{
TrapNotifier* pTrapNotifier = new TrapNotifier();
if (mpNotifiers[cAlarmData::eActionTrap])
{
delete mpNotifiers[cAlarmData::eActionTrap];
}
mpNotifiers[cAlarmData::eActionTrap] = pTrapNotifier;
if (pTrapNotifier)
{
TiXmlElement* groupElement = groupServerHandle.FirstChildElement("definitions").Element();
pTrapNotifier->init(element, groupElement);
gbActions[cAlarmData::eActionTrap] = true;
}
}
else
{
// The trap notification of alarms is disabled.
// So, delete the notifier
if (mpNotifiers[cAlarmData::eActionTrap])
{
delete mpNotifiers[cAlarmData::eActionTrap];
mpNotifiers[cAlarmData::eActionTrap] = 0;
}
gbActions[cAlarmData::eActionTrap] = false;
}
}
return true;
}
