X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=src%2Ffreenet%2Ftrustlistxml.cpp;h=91324274a3716d44d4ea8bc40b8c291520d4b4e6;hb=047cea32f848d605c549ec123c12c1c400dd7ec1;hp=c3e71db319c248d67d42f479c19382524e9fab38;hpb=f60495a029c54358f82956482fe203fe2b7b5b23;p=fms.git

diff --git a/src/freenet/trustlistxml.cpp b/src/freenet/trustlistxml.cpp
index c3e71db..9132427 100644
--- a/src/freenet/trustlistxml.cpp
+++ b/src/freenet/trustlistxml.cpp
@@ -12,9 +12,9 @@ TrustListXML::TrustListXML()
 	Initialize();
 }
 
-void TrustListXML::AddTrust(const std::string &identity, const long messagetrust, const long trustlisttrust)
+void TrustListXML::AddTrust(const std::string &identity, const long messagetrust, const long trustlisttrust, const std::string &messagetrustcomment, const std::string &trustlisttrustcomment)
 {
-	m_trust.push_back(trust(identity,messagetrust,trustlisttrust));
+	m_trust.push_back(trust(identity,messagetrust,trustlisttrust,messagetrustcomment,trustlisttrustcomment));
 }
 
 std::string TrustListXML::GetIdentity(const long index)
@@ -41,6 +41,18 @@ long TrustListXML::GetMessageTrust(const long index)
 	}	
 }
 
+std::string TrustListXML::GetMessageTrustComment(const long index)
+{
+	if(index>=0 && index<m_trust.size())
+	{
+		return m_trust[index].m_messagetrustcomment;
+	}
+	else
+	{
+		return "";
+	}	
+}
+
 long TrustListXML::GetTrustListTrust(const long index)
 {
 	if(index>=0 && index<m_trust.size())
@@ -53,16 +65,31 @@ long TrustListXML::GetTrustListTrust(const long index)
 	}
 }
 
+std::string TrustListXML::GetTrustListTrustComment(const long index)
+{
+	if(index>=0 && index<m_trust.size())
+	{
+		return m_trust[index].m_trustlisttrustcomment;
+	}
+	else
+	{
+		return "";
+	}
+}
+
 std::string TrustListXML::GetXML()
 {
-	TiXmlDocument td;
-	TiXmlDeclaration *tdec=new TiXmlDeclaration("1.0","UTF-8","");
-	TiXmlElement *tid;
-	TiXmlPrinter tp;
+	Poco::AutoPtr<Poco::XML::Document> doc=new Poco::XML::Document;
+	//TiXmlDocument td;
+	//TiXmlDeclaration *tdec=new TiXmlDeclaration("1.0","UTF-8","");
+	Poco::XML::Element *root=doc->createElement("TrustList");
+	//TiXmlElement *tid;
+	//TiXmlPrinter tp;
 
-	td.LinkEndChild(tdec);
-	tid=new TiXmlElement("TrustList");
-	td.LinkEndChild(tid);
+	doc->appendChild(root);
+	//td.LinkEndChild(tdec);
+	//tid=new TiXmlElement("TrustList");
+	//td.LinkEndChild(tid);
 
 	for(std::vector<trust>::iterator i=m_trust.begin(); i!=m_trust.end(); i++)
 	{
@@ -70,15 +97,37 @@ std::string TrustListXML::GetXML()
 		std::string trustlisttrust;
 		StringFunctions::Convert((*i).m_messagetrust,messagetrust);
 		StringFunctions::Convert((*i).m_trustlisttrust,trustlisttrust);
-		TiXmlElement *tr=new TiXmlElement("Trust");
-		tid->LinkEndChild(tr);
-		tr->LinkEndChild(XMLCreateCDATAElement("Identity",(*i).m_identity));
-		tr->LinkEndChild(XMLCreateTextElement("MessageTrustLevel",messagetrust));
-		tr->LinkEndChild(XMLCreateTextElement("TrustListTrustLevel",trustlisttrust));
+		Poco::XML::Element *tr=doc->createElement("Trust");
+		//TiXmlElement *tr=new TiXmlElement("Trust");
+		root->appendChild(tr);
+		//tid->LinkEndChild(tr);
+		tr->appendChild(XMLCreateCDATAElement(doc,"Identity",(*i).m_identity));
+		//tr->LinkEndChild(XMLCreateCDATAElement("Identity",(*i).m_identity));
+		if((*i).m_messagetrust>=0)
+		{
+			tr->appendChild(XMLCreateTextElement(doc,"MessageTrustLevel",messagetrust));
+			//tr->LinkEndChild(XMLCreateTextElement("MessageTrustLevel",messagetrust));
+		}
+		if((*i).m_trustlisttrust>=0)
+		{
+			tr->appendChild(XMLCreateTextElement(doc,"TrustListTrustLevel",trustlisttrust));
+			//tr->LinkEndChild(XMLCreateTextElement("TrustListTrustLevel",trustlisttrust));
+		}
+		if((*i).m_messagetrustcomment!="")
+		{
+			tr->appendChild(XMLCreateTextElement(doc,"MessageTrustComment",(*i).m_messagetrustcomment));
+			//tr->LinkEndChild(XMLCreateCDATAElement("MessageTrustComment",(*i).m_messagetrustcomment));
+		}
+		if((*i).m_trustlisttrustcomment!="")
+		{
+			tr->appendChild(XMLCreateTextElement(doc,"TrustListTrustComment",(*i).m_trustlisttrustcomment));
+			//tr->LinkEndChild(XMLCreateCDATAElement("TrustListTrustComment",(*i).m_trustlisttrustcomment));
+		}
 	}
 
-	td.Accept(&tp);
-	return std::string(tp.CStr());
+	//td.Accept(&tp);
+	//return std::string(tp.CStr());
+	return GenerateXML(doc);
 }
 
 void TrustListXML::Initialize()
@@ -88,6 +137,99 @@ void TrustListXML::Initialize()
 
 const bool TrustListXML::ParseXML(const std::string &xml)
 {
+
+	bool parsed=false;
+	Poco::XML::DOMParser dp;
+
+	Initialize();
+
+	try
+	{
+		Poco::AutoPtr<Poco::XML::Document> doc=dp.parseString(FixCDATA(xml));
+		Poco::XML::Element *root=XMLGetFirstChild(doc,"TrustList");
+		Poco::XML::Element *trustel=NULL;
+		Poco::XML::Element *txt=NULL;
+
+		std::vector<std::string> foundkeys;
+
+		trustel=XMLGetFirstChild(root,"Trust");
+		while(trustel)
+		{
+			std::string identity="";
+			int messagetrust=-1;
+			int trustlisttrust=-1;
+			std::string messagetrustcomment="";
+			std::string trustlisttrustcomment="";
+
+			txt=XMLGetFirstChild(trustel,"Identity");
+			if(txt)
+			{
+				if(txt->firstChild())
+				{
+					identity=SanitizeSingleString(txt->firstChild()->getNodeValue());
+				}
+			}
+			txt=XMLGetFirstChild(trustel,"MessageTrustLevel");
+			if(txt)
+			{
+				if(txt->firstChild())
+				{
+					std::string mtl=txt->firstChild()->getNodeValue();
+					StringFunctions::Convert(mtl,messagetrust);
+				}
+			}
+			txt=XMLGetFirstChild(trustel,"TrustListTrustLevel");
+			if(txt)
+			{
+				if(txt->firstChild())
+				{
+					std::string tltl=txt->firstChild()->getNodeValue();
+					StringFunctions::Convert(tltl,trustlisttrust);
+				}
+			}
+			txt=XMLGetFirstChild(trustel,"MessageTrustComment");
+			if(txt)
+			{
+				if(txt->firstChild())
+				{
+					messagetrustcomment=SanitizeSingleString(txt->firstChild()->getNodeValue());
+				}
+			}
+			txt=XMLGetFirstChild(trustel,"TrustListTrustComment");
+			if(txt)
+			{
+				if(txt->firstChild())
+				{
+					trustlisttrustcomment=SanitizeSingleString(txt->firstChild()->getNodeValue());
+				}
+			}
+
+			if(identity!="" && messagetrust>=-1 && messagetrust<=100 && trustlisttrust>=-1 && trustlisttrust<=100)
+			{
+				// check so we don't add the same identity multiple times from a trust list
+				if(std::find(foundkeys.begin(),foundkeys.end(),identity)==foundkeys.end())
+				{
+					foundkeys.push_back(identity);
+					m_trust.push_back(trust(identity,messagetrust,trustlisttrust,messagetrustcomment,trustlisttrustcomment));
+				}
+			}
+			else
+			{
+				m_log->error("TrustListXML::ParseXML malformed Trust in TrustList.xml");
+			}
+
+			trustel=XMLGetNextSibling(trustel,"Trust");
+		}
+
+		parsed=true;
+	}
+	catch(...)
+	{
+	}
+
+	return parsed;
+
+	/*
 	TiXmlDocument td;
 	td.Parse(xml.c_str());
 
@@ -96,6 +238,8 @@ const bool TrustListXML::ParseXML(const std::string &xml)
 		std::string identity;
 		std::string messagetruststr;
 		std::string trustlisttruststr;
+		std::string messagetrustcomment="";
+		std::string trustlisttrustcomment="";
 		long messagetrust;
 		long trustlisttrust;
 		TiXmlText *txt;
@@ -111,33 +255,51 @@ const bool TrustListXML::ParseXML(const std::string &xml)
 			identity="";
 			messagetrust=-1;
 			trustlisttrust=-1;
+			messagetrustcomment="";
+			trustlisttrustcomment="";
 
 			TiXmlHandle hnd2(node);
 			txt=hnd2.FirstChild("Identity").FirstChild().ToText();
 			if(txt)
 			{
-				identity=txt->ValueStr();
+				identity=SanitizeSingleString(txt->ValueStr());
 			}
 			txt=hnd2.FirstChild("MessageTrustLevel").FirstChild().ToText();
 			if(txt)
 			{
-				messagetruststr=txt->ValueStr();
-				StringFunctions::Convert(messagetruststr,messagetrust);
+				messagetruststr=SanitizeSingleString(txt->ValueStr());
+				if(messagetruststr!="")
+				{
+					StringFunctions::Convert(messagetruststr,messagetrust);
+				}
 			}
 			txt=hnd2.FirstChild("TrustListTrustLevel").FirstChild().ToText();
 			if(txt)
 			{
-				trustlisttruststr=txt->ValueStr();
-				StringFunctions::Convert(trustlisttruststr,trustlisttrust);
+				trustlisttruststr=SanitizeSingleString(txt->ValueStr());
+				if(trustlisttruststr!="")
+				{
+					StringFunctions::Convert(trustlisttruststr,trustlisttrust);
+				}
+			}
+			txt=hnd2.FirstChild("MessageTrustComment").FirstChild().ToText();
+			if(txt)
+			{
+				messagetrustcomment=txt->ValueStr();
+			}
+			txt=hnd2.FirstChild("TrustListTrustComment").FirstChild().ToText();
+			if(txt)
+			{
+				trustlisttrustcomment=txt->ValueStr();
 			}
 
-			if(identity!="" && messagetrust>=0 && messagetrust<=100 && trustlisttrust>=0 && trustlisttrust<=100)
+			if(identity!="" && messagetrust>=-1 && messagetrust<=100 && trustlisttrust>=-1 && trustlisttrust<=100)
 			{
 				// check so we don't add the same identity multiple times from a trust list
 				if(std::find(m_foundkeys.begin(),m_foundkeys.end(),identity)==m_foundkeys.end())
 				{
 					m_foundkeys.push_back(identity);
-					m_trust.push_back(trust(identity,messagetrust,trustlisttrust));
+					m_trust.push_back(trust(identity,messagetrust,trustlisttrust,messagetrustcomment,trustlisttrustcomment));
 				}
 			}
 			else
@@ -154,4 +316,5 @@ const bool TrustListXML::ParseXML(const std::string &xml)
 	{
 		return false;
 	}
+	*/
 }