X-Git-Url: https://git.teslayout.com/public/public/public/?a=blobdiff_plain;f=source%2Fdiameter%2Fcodec%2FEngineImpl.cpp;h=9d06706ec01ffba6f763b86098b9ef36e24bb3d3;hb=5a6cba5fde2b2f538a7515f8293cc0a8d9589dfa;hp=d9a614620c1f883b74a03d05832abb868e0fef3c;hpb=93366a0bda79e6fd6e7dad6316bfcf8cc82f5731;p=anna.git

diff --git a/source/diameter/codec/EngineImpl.cpp b/source/diameter/codec/EngineImpl.cpp
index d9a6146..9d06706 100644
--- a/source/diameter/codec/EngineImpl.cpp
+++ b/source/diameter/codec/EngineImpl.cpp
@@ -23,127 +23,38 @@
 #include <anna/core/mt/Guard.hpp>
 
 
-
-namespace anna {
-namespace diameter {
-namespace codec {
-
-const char *MessageDTD = "\
-<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\
-<!-- Diameter message DTD -->\n\
-\n\
-<!ELEMENT message (avp*)>\n\
-<!ELEMENT avp (avp*)>\n\
-\n\
-<!ATTLIST message version CDATA #IMPLIED name CDATA #IMPLIED code CDATA #IMPLIED flags CDATA #IMPLIED p-bit (yes | no) #IMPLIED e-bit (yes | no) #IMPLIED t-bit (yes | no) #IMPLIED application-id CDATA #REQUIRED hop-by-hop-id CDATA #IMPLIED end-by-end-id CDATA #IMPLIED>\n\
-<!--\n\
-   version: Diameter version. Sets '1' by default\n\
-   name:    Command name within working stack (dictionary identifier)\n\
-   p-bit:   (P)roxiable bit flag (yes, no). By default is 'no'\n\
-   e-bit:   (E)rror bit flag (yes, no). By default is 'no'\n\
-   t-bit:   Potentially re-(T)ransmitted bit flag (yes, no). By default is 'no'\n\
-\n\
-   In order to get more coding capabilities, command code and flags could be established instead of former fields,\n\
-    but neither of them are allowed if the other are present (and vice versa):\n\
-\n\
-   code:    Command code\n\
-   flags:   Command flags byte value (0-255) where standard bit set for flags is 'RPET rrrr': (R)equest, (P)roxiable, (E)rror, Potentially re-(T)ransmitted message and (r)eserved\n\
-\n\
-\n\
-   application-id:   Message application id\n\
-   hop-by-hop-id:    Message hop by hop id. Sets '0' by default\n\
-   end-by-end-id:    Message end by end id. Sets '0' by default\n\
--->\n\
-\n\
-<!ATTLIST avp name CDATA #IMPLIED code CDATA #IMPLIED vendor-code CDATA #IMPLIED flags CDATA #IMPLIED data CDATA #IMPLIED hex-data CDATA #IMPLIED alias CDATA #IMPLIED>\n\
-<!--\n\
-   name:   Avp name within working stack (dictionary identifier)\n\
-\n\
-   In order to get more coding capabilities, avp code, vendor-id and flags could be established instead of former avp name,\n\
-    but neither of them are allowed if 'name' is provided (and vice versa):\n\
-\n\
-   code:          Avp code\n\
-   vendor-code:   Avp vendor code\n\
-   flags:         Avp flags byte value (0-255) where standard bit set for flags is 'VMPr rrrr': (V)endor-specific, (M)andatory, end to end encry(P)tion and r(eserved)\n\
-   alias:         Descriptive/helper field for certain numeric data values. Aliases are defined at diameter dictionary, but are ignored (not checked) at xml message parsing\n\
-                  The reason to include it in dtd definition, is because xml messages traced by the diameter codec could add alias field for some Avps\n\
-\n\
-\n\
-   data:          Natural string representation for avp data. Specially applicable with numbers and printable strings, but also\n\
-                   useful for certain formats which could be easily understandable in such friendly/smart representation. We will\n\
-                   achieve different human-readable strings depending on data format:\n\
-\n\
-                     [ OctetString ] (if printable, but not recommended)\n\
-                     [ Integer32, Integer64, Unsigned32, Unsigned64, Float32, Float64 ] (normal number representation)\n\
-                     [ Time ] (NTP timestamp, normal number representation)\n\
-                     [ Address ] ('<type (IANA Address Family Number)>|<value>' representation; i.e. '1|192.168.0.1'(IPv4), '8|34616279266'(E164), etc.\n\
-                                 Type (and pipe) field could be avoided for IPv4 and IPv6 address types (a light parse checking is done: one colon for\n\
-                                 IPv6, one dot for IPv4). Internal engine always includes type on data field, which is also recommended for inputs.\n\
-                                 Currently, only IPv4, IPv6 and E164 address types have a known printable presentation, anyway using printable format\n\
-                                 for another types will encode the address value directly as E164 does)\n\
-                     [ UTF8String, DiameterIdentity, DiameterURI ] (printable)\n\
-                     [ IPFilterRule, QoSFilterRule ] (uses ASCII charset, printable)\n\
-\n\
-                     New application formats must define specific natural representation for internal raw data\n\
-\n\
-   hex-data:      Hexadecimal octet sequence representation (i.e. 'af012fb3', with even number of digits). Suitable for whatever kind\n\
-                   of diameter format, but mandatory for non printable information. OctetString usually transport non human-readable\n\
-                   data and should better be encoded within this field although being printable. Unknown avps (which fails identifying\n\
-                   provided name or code/vendor-code) must always use this representation.\n\
-\n\
-   Xml representation for decoded messages shows natural content except for 'OctetString' format and unknown avps. Anyway, when printable,\n\
-    OctetString could show such information at data field apart from hex-data, because many implementations use this format to transport\n\
-    readable-string data. In general, one of the data fields is mandatory except for 'Grouped' type (its data is another level of avps).\n\
-   Application-specific formats must decide the way to represent its contents, being recommended to use a natural representation if possible,\n\
-    because xml is read by humans with testing and monitoring purposes.\n\
--->\n\
-\n\
-";
-
-
-}
-}
-}
-
 using namespace anna::diameter::codec;
 
 
 //------------------------------------------------------------------------------
 //----------------------------------------------------- EngineImpl::EngineImpl()
 //------------------------------------------------------------------------------
-EngineImpl::EngineImpl(const char* className) :
+EngineImpl::EngineImpl(const char* className, const stack::Dictionary * dictionary) :
   anna::Component(className),
-  a_dictionary(NULL),
+  a_dictionary(dictionary),
   a_validationDepth(ValidationDepth::FirstError),
   a_validationMode(ValidationMode::AfterDecoding),
+  a_singleFailedAVP(true),
   a_ignoreFlags(false),
-  a_selectStackWithApplicationId(false),
   a_fixMode(FixMode::BeforeEncoding) {
   anna::diameter::sccs::activate();
   anna::xml::functions::initialize();
-  a_dtd.initialize(MessageDTD);
-}
-
-
-//------------------------------------------------------------------------------
-//-------------------------------------------------- EngineImpl::setDictionary()
-//------------------------------------------------------------------------------
-const anna::diameter::stack::Dictionary *EngineImpl::setDictionary(unsigned int stackId) throw() {
-  a_dictionary = (stack::Engine::instantiate()).getDictionary(stackId);
-  return a_dictionary;
 }
 
 
 //------------------------------------------------------------------------------
 //------------------------------------------------------ EngineImpl::createAvp()
 //------------------------------------------------------------------------------
-Avp* EngineImpl::createAvp(const AvpId *id) throw(anna::RuntimeException) {
+Avp* EngineImpl::createAvp(const AvpId *id) noexcept(false) {
   Avp *result(NULL);
   anna::Guard guard(this, "diameter::codec::EngineImpl::createAvp");
 
   if((result = allocateAvp()) == NULL)
     throw anna::RuntimeException("diameter::codec::EngineImpl::allocateAvp returns NULL", ANNA_FILE_LOCATION);
 
+  // Sets engine
+  result->setEngine((Engine*)this);
+
   //result->clear(); better clear this at releaseAvp(), see class-help implementation example
   if(id) result->setId(*id);
 
@@ -154,13 +65,16 @@ Avp* EngineImpl::createAvp(const AvpId *id) throw(anna::RuntimeException) {
 //------------------------------------------------------------------------------
 //-------------------------------------------------- EngineImpl::createMessage()
 //------------------------------------------------------------------------------
-Message* EngineImpl::createMessage(const CommandId *id) throw(anna::RuntimeException) {
+Message* EngineImpl::createMessage(const CommandId *id) noexcept(false) {
   Message *result(NULL);
   anna::Guard guard(this, "diameter::codec::EngineImpl::createMessage");
 
   if((result = allocateMessage()) == NULL)
     throw anna::RuntimeException("diameter::codec::EngineImpl::allocateMessage returns NULL", ANNA_FILE_LOCATION);
 
+  // Sets engine
+  result->setEngine((Engine*)this);
+
   //result->clear(); better clear this at releaseMessage(), see class-help implementation example
   if(id) result->setId(*id);
 
@@ -171,26 +85,32 @@ Message* EngineImpl::createMessage(const CommandId *id) throw(anna::RuntimeExcep
 //------------------------------------------------------------------------------
 //-------------------------------------------------- EngineImpl::createMessage()
 //------------------------------------------------------------------------------
-Message *EngineImpl::createMessage(const std::string & xmlPathFile) throw(anna::RuntimeException) {
+Message *EngineImpl::createMessage(const std::string & xmlPathFile_or_string, bool pathfile_or_string) noexcept(false) {
   Message *result = createMessage();
-  result->loadXML(xmlPathFile);
+  if (pathfile_or_string)
+    result->loadXMLFile(xmlPathFile_or_string);
+  else
+    result->loadXMLString(xmlPathFile_or_string);
+
   return result;
 }
 
 
 
-std::string EngineImpl::asString(void) const throw() {
+std::string EngineImpl::asString(void) const {
   std::string result = anna::Component::asString();
   result += "\nValidationDepth: ";
   result += asText(a_validationDepth);
   result += "\nValidationMode: ";
   result += asText(a_validationMode);
+  result += "\nSingle Failed-AVP: ";
+  result += a_singleFailedAVP ? "yes" : "no";
   result += "\nIgnore flags: ";
   result += a_ignoreFlags ? "yes" : "no";
   result += "\nFixMode: ";
   result += asText(a_fixMode);
   result += "\nActivated Dictionary: ";
-  result += a_dictionary ? (a_dictionary->getName()) : "<null>";
+  result += a_dictionary ? (a_dictionary->getName()) : "[null]";
   return result;
 }
 
@@ -198,14 +118,15 @@ std::string EngineImpl::asString(void) const throw() {
 //---------------------------------------------------------- EngineImpl::asXML()
 //------------------------------------------------------------------------------
 anna::xml::Node* EngineImpl::asXML(anna::xml::Node* parent) const
-throw() {
+{
   parent = anna::Component::asXML(parent);
   anna::xml::Node* result = parent->createChild("diameter.codec.EngineImpl");
   result->createAttribute("ValidationDepth", asText(a_validationDepth));
   result->createAttribute("ValidationMode", asText(a_validationMode));
+  result->createAttribute("SingleFailedAVP", a_singleFailedAVP ? "yes" : "no");
   result->createAttribute("IgnoreFlags", a_ignoreFlags ? "yes" : "no");
   result->createAttribute("FixMode", asText(a_fixMode));
-  anna::xml::Node* dictionary = result->createChild("EngineImpl.ActivatedDictionary");
+  result->createChild("EngineImpl.ActivatedDictionary");
 
   if(a_dictionary) a_dictionary->asXML(result);
 
@@ -216,7 +137,7 @@ throw() {
 //--------------------------------------------------------- EngineImpl::asText()
 //------------------------------------------------------------------------------
 const char* EngineImpl::asText(const ValidationDepth::_v vd)
-throw() {
+{
   static const char* text [] = { "Complete", "FirstError" };
   return text [vd];
 }
@@ -225,7 +146,7 @@ throw() {
 //--------------------------------------------------------- EngineImpl::asText()
 //------------------------------------------------------------------------------
 const char* EngineImpl::asText(const ValidationMode::_v vm)
-throw() {
+{
   static const char* text [] = { "BeforeEncoding", "AfterDecoding", "Always", "Never" };
   return text [vm];
 }
@@ -234,7 +155,7 @@ throw() {
 //--------------------------------------------------------- EngineImpl::asText()
 //------------------------------------------------------------------------------
 const char* EngineImpl::asText(const FixMode::_v fm)
-throw() {
+{
   static const char* text [] = { "BeforeEncoding", "AfterDecoding", "Always", "Never" };
   return text [fm];
 }
@@ -242,7 +163,7 @@ throw() {
 //------------------------------------------------------------------------------
 //---------------------------------------------- EngineImpl::validationAnomaly()
 //------------------------------------------------------------------------------
-void EngineImpl::validationAnomaly(const std::string & description) const throw(anna::RuntimeException) {
+void EngineImpl::validationAnomaly(const std::string & description) const noexcept(false) {
   std::string msg = "Validation error: ";
 
   if(a_validationDepth == ValidationDepth::FirstError)
@@ -255,7 +176,7 @@ void EngineImpl::validationAnomaly(const std::string & description) const throw(
 //------------------------------------------------------------------------------
 //--------------------------------------------------- EngineImpl::avpIdForName()
 //------------------------------------------------------------------------------
-anna::diameter::AvpId EngineImpl::avpIdForName(const char * name) throw(anna::RuntimeException) {
+anna::diameter::AvpId EngineImpl::avpIdForName(const char * name) noexcept(false) {
   if(!name)
     throw anna::RuntimeException("Provided NULL Avp Logical Name", ANNA_FILE_LOCATION);
 
@@ -280,7 +201,7 @@ anna::diameter::AvpId EngineImpl::avpIdForName(const char * name) throw(anna::Ru
 //------------------------------------------------------------------------------
 //----------------------------------------------- EngineImpl::commandIdForName()
 //------------------------------------------------------------------------------
-anna::diameter::CommandId EngineImpl::commandIdForName(const char * name) throw(anna::RuntimeException) {
+anna::diameter::CommandId EngineImpl::commandIdForName(const char * name) noexcept(false) {
   if(!name)
     throw anna::RuntimeException("Provided NULL Command Logical Name", ANNA_FILE_LOCATION);