projects / anna.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fixed Failed-AVP bug (feature). Now wrong avps inside grouped are correctly tracked
[anna.git] / source / diameter / codec / Avp.cpp
diff --git a/source/diameter/codec/Avp.cpp b/source/diameter/codec/Avp.cpp
index 7f33851..aa52c5f 100644 (file)
--- a/source/diameter/codec/Avp.cpp
+++ b/source/diameter/codec/Avp.cpp
@@ -632,7 +632,7 @@ U24 Avp::getLength() const throw() {
 //------------------------------------------------------------------------------
 //-------------------------------------------- Avp::unknownAvpWithMandatoryBit()
 //------------------------------------------------------------------------------
-void Avp::unknownAvpWithMandatoryBit(Message *answer) const throw(anna::RuntimeException) {
+void Avp::unknownAvpWithMandatoryBit() const throw(anna::RuntimeException) {
   OamModule &oamModule = OamModule::instantiate();
   const char *c_aid = STRING_WITH_QUOTATION_MARKS__C_STR(anna::diameter::functions::avpIdAsPairString(a_id));
   oamModule.activateAlarm(OamModule::Alarm::AvpDecode__UnknownAvp__s__WithMandatoryBit, c_aid);
@@ -641,17 +641,12 @@ void Avp::unknownAvpWithMandatoryBit(Message *answer) const throw(anna::RuntimeE
     std::string msg = anna::functions::asString("Detected unknown Avp %s with mandatory bit activated", c_aid);
     anna::Logger::warning(msg, ANNA_FILE_LOCATION);
   );
-
-  if(answer) {
-    answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_AVP_UNSUPPORTED);
-    answer->setFailedAvp((Avp*)this);
-  }
 }
 
 //------------------------------------------------------------------------------
 //-------------------------------------------------------- Avp::decodeDataPart()
 //------------------------------------------------------------------------------
-void Avp::decodeDataPart(const char * buffer, int size, Message *answer) throw(anna::RuntimeException) {
+void Avp::decodeDataPart(const char * buffer, int size, const parent_t & parent, Message *answer) throw(anna::RuntimeException) {
   // OAM
   OamModule &oamModule = OamModule::instantiate();
   // Dictionary stack avp and format:
@@ -682,7 +677,7 @@ void Avp::decodeDataPart(const char * buffer, int size, Message *answer) throw(a
 
       if(answer) {
         answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_INVALID_AVP_LENGTH);
-        //answer->setFailedAvp(a_id);
+        answer->setFailedAvp(parent, a_id);
       }
 
       throw anna::RuntimeException("Avp format error, the avp length is incorrect (must be multiple of 4 on grouped type)", ANNA_FILE_LOCATION);
@@ -692,11 +687,15 @@ void Avp::decodeDataPart(const char * buffer, int size, Message *answer) throw(a
     Avp* avp;
     anna::DataBlock db;
 
+    // Me as parent:
+    parent_t me = parent;
+    me.addAvp(a_id);
+
     while(avpPos < size) {
       try {
         avp = getEngine()->allocateAvp();
         db.assign(buffer + avpPos, size - avpPos /* is valid to pass total size (indeed i don't know the real avp size) because it will be limited and this has deep copy disabled (no memory is reserved) */);
-        avp -> decode(db, answer);
+        avp -> decode(db, me, answer);
       } catch(anna::RuntimeException &ex) {
         getEngine()->releaseAvp(avp);
         throw;
@@ -723,7 +722,7 @@ void Avp::decodeDataPart(const char * buffer, int size, Message *answer) throw(a
 //------------------------------------------------------------------------------
 //---------------------------------------------------------------- Avp::decode()
 //------------------------------------------------------------------------------
-void Avp::decode(const anna::DataBlock &db, Message *answer) throw(anna::RuntimeException) {
+void Avp::decode(const anna::DataBlock &db, const parent_t & parent, Message *answer) throw(anna::RuntimeException) {
   // OAM
   OamModule &oamModule = OamModule::instantiate();
 
@@ -785,7 +784,15 @@ void Avp::decode(const anna::DataBlock &db, Message *answer) throw(anna::Runtime
   //   The 'M' Bit, known as the Mandatory bit, indicates whether support of the AVP is required. If an AVP with the 'M' bit set is received by
   //   a Diameter client, server, proxy, or translation agent and either the AVP or its value is unrecognized, the message MUST be rejected.
   //   Diameter Relay and redirect agents MUST NOT reject messages with unrecognized AVPs.
-  if(!getStackAvp() && mandatoryBit()) unknownAvpWithMandatoryBit(answer);
+  if(!getStackAvp() && mandatoryBit()) {
+
+       if(answer) {
+         answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_AVP_UNSUPPORTED);
+         answer->setFailedAvp(parent, a_id);
+       }
+
+       unknownAvpWithMandatoryBit();
+  }
 
   // Avp Length
   U24 length = DECODE3BYTES_INDX_VALUETYPE(buffer, 5, U24);
@@ -800,21 +807,21 @@ void Avp::decode(const anna::DataBlock &db, Message *answer) throw(anna::Runtime
 
     if(answer) {
       answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_INVALID_AVP_LENGTH);
-      //answer->setFailedAvp(a_id);
+      answer->setFailedAvp(parent, a_id);
     }
 
     throw anna::RuntimeException(anna::functions::asString("Avp format error, the avp length is incorrect (avp code = %u)", code), ANNA_FILE_LOCATION);
   }
 
   try {
-    decodeDataPart(buffer + startDataPos, dataBytes, answer);
+    decodeDataPart(buffer + startDataPos, dataBytes, parent, answer);
   } catch(anna::RuntimeException &ex) {
     oamModule.activateAlarm(OamModule::Alarm::AvpDecode__DataPartInconsistence);
     oamModule.count(OamModule::Counter::AvpDecode__DataPartInconsistence);
 
     if(answer) {
-      answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_INVALID_AVP_VALUE); // unspecified error ...
-      //answer->setFailedAvp((Avp*)this);
+      answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_INVALID_AVP_VALUE);
+      answer->setFailedAvp(parent, a_id);
     }
 
     throw anna::RuntimeException(anna::functions::asString("Internal Avp decoding error (avp code = %u): %s", code, ex.getText().c_str()), ANNA_FILE_LOCATION);
@@ -902,7 +909,7 @@ void Avp::fix() throw() {
 //------------------------------------------------------------------------------
 //------------------------------------------------------------ Avp::validLevel()
 //------------------------------------------------------------------------------
-bool Avp::validLevel(const avp_container &avps, anna::diameter::stack::const_avprule_iterator ruleBegin, anna::diameter::stack::const_avprule_iterator ruleEnd, Engine * engine, const std::string & parentDescription, Message *answer) throw(anna::RuntimeException) {
+bool Avp::validLevel(const avp_container &avps, anna::diameter::stack::const_avprule_iterator ruleBegin, anna::diameter::stack::const_avprule_iterator ruleEnd, Engine * engine, const parent_t & parent, Message *answer) throw(anna::RuntimeException) {
   bool result = true;
   // OAM
   OamModule &oamModule = OamModule::instantiate();
@@ -940,15 +947,15 @@ bool Avp::validLevel(const avp_container &avps, anna::diameter::stack::const_avp
       if(!okFixed) {
         result = false;
         // OAM & Depth management
-        oamModule.activateAlarm(OamModule::Alarm::LevelValidation__MissingFixedRule__s__Inside__s__, STRING_WITH_QUOTATION_MARKS__C_STR((*rule_it).second.asString(false /*ommit dots & pair*/)));
+        oamModule.activateAlarm(OamModule::Alarm::LevelValidation__MissingFixedRule__s__Inside__s__, STRING_WITH_QUOTATION_MARKS__C_STR((*rule_it).second.asString(false /*ommit dots & pair*/)), STRING_WITH_QUOTATION_MARKS__C_STR(parent.asString()));
         oamModule.count(OamModule::Counter::LevelValidation__MissingFixedRule);
 
         if(answer) {
           answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_MISSING_AVP);
-          answer->setFailedAvp((*rule_it).second.getId());
+          answer->setFailedAvp(parent, (*rule_it).second.getId());
         }
 
-        engine->validationAnomaly(anna::functions::asString("Missing fixed rule %s inside %s", STRING_WITH_QUOTATION_MARKS__C_STR((*rule_it).second.asString(false /*ommit dots & pair*/)), STRING_WITH_QUOTATION_MARKS__C_STR(parentDescription)));
+        engine->validationAnomaly(anna::functions::asString("Missing fixed rule %s inside %s", STRING_WITH_QUOTATION_MARKS__C_STR((*rule_it).second.asString(false /*ommit dots & pair*/)), STRING_WITH_QUOTATION_MARKS__C_STR(parent.asString())));
       }
     } else break; // finish fixed
   }
@@ -971,7 +978,7 @@ bool Avp::validLevel(const avp_container &avps, anna::diameter::stack::const_avp
       // Failed rule %s for cardinality (found %d items)
       result = false;
       // OAM & Depth management
-      oamModule.activateAlarm(OamModule::Alarm::LevelValidation__FailedRule__s__ForCardinality_Found__d__ItemsInside__s__, STRING_WITH_QUOTATION_MARKS__C_STR((*rule_it).second.asString(false /*ommit dots & pair*/)), amount, STRING_WITH_QUOTATION_MARKS__C_STR(parentDescription));
+      oamModule.activateAlarm(OamModule::Alarm::LevelValidation__FailedRule__s__ForCardinality_Found__d__ItemsInside__s__, STRING_WITH_QUOTATION_MARKS__C_STR((*rule_it).second.asString(false /*ommit dots & pair*/)), amount, STRING_WITH_QUOTATION_MARKS__C_STR(parent.asString()));
       oamModule.count(OamModule::Counter::LevelValidation__FailedRuleForCardinality);
 
       if(amount < min) {
@@ -979,18 +986,18 @@ bool Avp::validLevel(const avp_container &avps, anna::diameter::stack::const_avp
 
         if(answer) {
           answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_MISSING_AVP);
-          answer->setFailedAvp(id);
+          answer->setFailedAvp(parent, id);
         }
       } else {
         oamModule.count(OamModule::Counter::LevelValidation__FailedRuleForCardinalityMoreThanNeeded);
 
         if(answer) {
           answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_AVP_OCCURS_TOO_MANY_TIMES);
-          answer->setFailedAvp((Avp*)firstAvp(avps, id) /* first instance */);
+          answer->setFailedAvp(parent, id);
         }
       }
 
-      engine->validationAnomaly(anna::functions::asString("Failed rule %s for cardinality (found %d items inside %s)", STRING_WITH_QUOTATION_MARKS__C_STR((*rule_it).second.asString(false /*ommit dots & pair*/)), amount, STRING_WITH_QUOTATION_MARKS__C_STR(parentDescription)));
+      engine->validationAnomaly(anna::functions::asString("Failed rule %s for cardinality (found %d items inside %s)", STRING_WITH_QUOTATION_MARKS__C_STR((*rule_it).second.asString(false /*ommit dots & pair*/)), amount, STRING_WITH_QUOTATION_MARKS__C_STR(parent.asString())));
     }
   }
 
@@ -1031,15 +1038,15 @@ bool Avp::validLevel(const avp_container &avps, anna::diameter::stack::const_avp
       // Failed Generic AVP rule %s for cardinality (found %d disregarded items inside %s)
       result = false;
       // OAM & Depth management
-      oamModule.activateAlarm(OamModule::Alarm::LevelValidation__FailedGenericAvpRule__s__ForCardinality_Found__d__DisregardedItemsInside__s__, STRING_WITH_QUOTATION_MARKS__C_STR((*generic_rule_it).second.asString(false /*ommit dots & pair*/)), amount, STRING_WITH_QUOTATION_MARKS__C_STR(parentDescription));
+      oamModule.activateAlarm(OamModule::Alarm::LevelValidation__FailedGenericAvpRule__s__ForCardinality_Found__d__DisregardedItemsInside__s__, STRING_WITH_QUOTATION_MARKS__C_STR((*generic_rule_it).second.asString(false /*ommit dots & pair*/)), amount, STRING_WITH_QUOTATION_MARKS__C_STR(parent.asString()));
       oamModule.count(OamModule::Counter::LevelValidation__FailedGenericAvpRuleForCardinalityFoundDisregardedItem);
 
       if(answer) {
         answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_AVP_NOT_ALLOWED);
-        //answer->setFailedAvp((Avp*)firstAvp(avps, id) /* first instance */); // NO SENSE... what to put ?
+        answer->setFailedAvp(parent, id); // NO SENSE... what to put ?
       }
 
-      engine->validationAnomaly(anna::functions::asString("Failed Generic AVP rule %s for cardinality (found %d disregarded items inside %s)", STRING_WITH_QUOTATION_MARKS__C_STR((*generic_rule_it).second.asString(false /*ommit dots & pair*/)), amount, STRING_WITH_QUOTATION_MARKS__C_STR(parentDescription)));
+      engine->validationAnomaly(anna::functions::asString("Failed Generic AVP rule %s for cardinality (found %d disregarded items inside %s)", STRING_WITH_QUOTATION_MARKS__C_STR((*generic_rule_it).second.asString(false /*ommit dots & pair*/)), amount, STRING_WITH_QUOTATION_MARKS__C_STR(parent.asString())));
     }
   } else if(disregardeds) {  // When Generic AVP missing, no disregarded Avps are allowed
     // Found %d disregarded items inside %s and Generic AVP was not specified
@@ -1057,15 +1064,15 @@ bool Avp::validLevel(const avp_container &avps, anna::diameter::stack::const_avp
       // We wouldn't know where are these disregarded, but...
       if(answer) {
         answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_AVP_NOT_ALLOWED);
-        answer->setFailedAvp((Avp*)firstAvp(avps, id) /* first instance */);
+        answer->setFailedAvp(parent, id);
       }
     }
 
     s_disregardeds.erase(s_disregardeds.size() - 2, 2); // remove last ', '
     // OAM & Depth management
-    oamModule.activateAlarm(OamModule::Alarm::LevelValidation__FoundDisregardedItemsInside__s__AndGenericAVPWasNotSpecified__s__, STRING_WITH_QUOTATION_MARKS__C_STR(parentDescription), STRING_WITH_QUOTATION_MARKS__C_STR(s_disregardeds));
+    oamModule.activateAlarm(OamModule::Alarm::LevelValidation__FoundDisregardedItemsInside__s__AndGenericAVPWasNotSpecified__s__, STRING_WITH_QUOTATION_MARKS__C_STR(parent.asString()), STRING_WITH_QUOTATION_MARKS__C_STR(s_disregardeds));
     oamModule.count(OamModule::Counter::LevelValidation__FoundDisregardedItemsAndGenericAVPWasNotSpecified);
-    engine->validationAnomaly(anna::functions::asString("Found disregarded items inside %s and Generic AVP was not specified: %s", STRING_WITH_QUOTATION_MARKS__C_STR(parentDescription), STRING_WITH_QUOTATION_MARKS__C_STR(s_disregardeds)));
+    engine->validationAnomaly(anna::functions::asString("Found disregarded items inside %s and Generic AVP was not specified: %s", STRING_WITH_QUOTATION_MARKS__C_STR(parent.asString()), STRING_WITH_QUOTATION_MARKS__C_STR(s_disregardeds)));
   }
 
   return result;
@@ -1075,20 +1082,21 @@ bool Avp::validLevel(const avp_container &avps, anna::diameter::stack::const_avp
 //------------------------------------------------------------------------------
 //----------------------------------------------------------------- Avp::valid()
 //------------------------------------------------------------------------------
-bool Avp::valid(const std::string & parentDescription, Message *answer) const throw(anna::RuntimeException) {
+bool Avp::valid(const parent_t & parent, Message *answer) const throw(anna::RuntimeException) {
   // OAM
   OamModule &oamModule = OamModule::instantiate();
   // Dictionary stack avp:
   const stack::Avp *stackAvp = getStackAvp();
   const stack::Format *stackFormat = stackAvp ? (stackAvp->getFormat()) : NULL /*Unknown*/;
-  std::string me;
 
   if(!stackAvp) {
     // No dictionary avp reference found. Cannot validate
     return true; // perhaps a unknown Avp
   }
 
-  me = parentDescription + "->" + stackAvp->getName();
+  // Me as parent:
+  parent_t me = parent;
+  me.addAvp(a_id, stackAvp->getName().c_str());
 
   if(!stackFormat) {
     // No format avp reference found. Cannot validate
@@ -1102,15 +1110,15 @@ bool Avp::valid(const std::string & parentDescription, Message *answer) const th
 
   if(!result) {
     // OAM & Depth management
-    oamModule.activateAlarm(OamModule::Alarm::AvpValidation__Avp__s__Flags__d__DoesNotFulfillTheDefinedFlagRules__s__, STRING_WITH_QUOTATION_MARKS__C_STR(me), (int)a_flags, STRING_WITH_QUOTATION_MARKS__C_STR(stackAvp->getFlagRulesDescription()));
+    oamModule.activateAlarm(OamModule::Alarm::AvpValidation__Avp__s__Flags__d__DoesNotFulfillTheDefinedFlagRules__s__, STRING_WITH_QUOTATION_MARKS__C_STR(me.asString()), (int)a_flags, STRING_WITH_QUOTATION_MARKS__C_STR(stackAvp->getFlagRulesDescription()));
     oamModule.count(OamModule::Counter::AvpValidation__AvpFlagsDoesNotFulfillTheDefinedFlagRules);
 
     if(answer) {
       answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_INVALID_AVP_BITS);
-      answer->setFailedAvp((Avp*)this); // RFC 6733 says nothing about Failed-AVP in this case...
+      answer->setFailedAvp(parent, a_id); // RFC 6733 says nothing about Failed-AVP in this case...
     }
 
-    getEngine()->validationAnomaly(anna::functions::asString("The AVP %s flags (%d) does not fulfill the defined flag rules: %s", STRING_WITH_QUOTATION_MARKS__C_STR(me), (int)a_flags, STRING_WITH_QUOTATION_MARKS__C_STR(stackAvp->getFlagRulesDescription())));
+    getEngine()->validationAnomaly(anna::functions::asString("The AVP %s flags (%d) does not fulfill the defined flag rules: %s", STRING_WITH_QUOTATION_MARKS__C_STR(me.asString()), (int)a_flags, STRING_WITH_QUOTATION_MARKS__C_STR(stackAvp->getFlagRulesDescription())));
   }
 
   //////////////////////
@@ -1120,15 +1128,15 @@ bool Avp::valid(const std::string & parentDescription, Message *answer) const th
     if(!stackAvp->allowEnum(a_Enumerated->getValue())) {
       result = false;
       // OAM & Depth management
-      oamModule.activateAlarm(OamModule::Alarm::AvpValidation__EnumeratedAvp__s__WithValue__d__DoesNotComplyRestriction__s__, STRING_WITH_QUOTATION_MARKS__C_STR(me), a_Enumerated->getValue(), stackAvp->getEnums());
+      oamModule.activateAlarm(OamModule::Alarm::AvpValidation__EnumeratedAvp__s__WithValue__d__DoesNotComplyRestriction__s__, STRING_WITH_QUOTATION_MARKS__C_STR(me.asString()), a_Enumerated->getValue(), stackAvp->getEnums());
       oamModule.count(OamModule::Counter::AvpValidation__EnumeratedAvpWithValueDoesNotComplyRestriction);
 
       if(answer) {
         answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_INVALID_AVP_VALUE);
-        answer->setFailedAvp((Avp*)this);
+        answer->setFailedAvp(parent, a_id);
       }
 
-      getEngine()->validationAnomaly(anna::functions::asString("Enumerated AVP %s with value %d does not comply to restriction: %s", STRING_WITH_QUOTATION_MARKS__C_STR(me), a_Enumerated->getValue(), stackAvp->getEnums()));
+      getEngine()->validationAnomaly(anna::functions::asString("Enumerated AVP %s with value %d does not comply to restriction: %s", STRING_WITH_QUOTATION_MARKS__C_STR(me.asString()), a_Enumerated->getValue(), stackAvp->getEnums()));
     }
   }
 
ANNA Suite