-// ANNA - Anna is Not 'N' Anymore
-//
-// (c) Copyright 2005-2014 Eduardo Ramos Testillano & Francisco Ruiz Rayo
-//
-// https://bitbucket.org/testillano/anna
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions
-// are met:
-//
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-// * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Authors: eduardo.ramos.testillano@gmail.com
-// cisco.tierra@gmail.com
+// ANNA - Anna is Not Nothingness Anymore //
+// //
+// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo //
+// //
+// See project site at http://redmine.teslayout.com/projects/anna-suite //
+// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //
// Local
#include <anna/diameter/stack/Engine.hpp>
#include <anna/diameter/codec/Engine.hpp>
#include <anna/core/functions.hpp>
+#include <anna/core/util/RegularExpression.hpp>
#include <anna/core/tracing/Logger.hpp>
#include <anna/core/functions.hpp>
//------------------------------------------------------------------------------
//------------------------------------------------------------------- Avp::Avp()
//------------------------------------------------------------------------------
-Avp::Avp() {
+Avp::Avp(Engine *engine) : a_engine(engine) {
initialize();
}
-
//------------------------------------------------------------------------------
//------------------------------------------------------------------- Avp::Avp()
//------------------------------------------------------------------------------
-Avp::Avp(AvpId id) {
+Avp::Avp(AvpId id, Engine *engine) : a_engine(engine) {
initialize();
setId(id);
}
-
//------------------------------------------------------------------------------
//------------------------------------------------------------------ Avp::~Avp()
//------------------------------------------------------------------------------
clear();
}
+//------------------------------------------------------------------------------
+//------------------------------------------------------------- Avp::setEngine()
+//------------------------------------------------------------------------------
+void Avp::setEngine(Engine *engine) throw() {
+ if (a_engine && engine != a_engine) {
+ LOGWARNING(anna::Logger::warning("Ignored: it is not a good practice to change the codec engine once assigned. Clear the avp first to set the engine again.", ANNA_FILE_LOCATION));
+ return;
+ }
+
+ a_engine = engine;
+}
//------------------------------------------------------------------------------
//------------------------------------------------------------- Avp::getEngine()
//------------------------------------------------------------------------------
Engine * Avp::getEngine() const throw(anna::RuntimeException) {
- return a_engine ? a_engine : (a_engine = anna::functions::component <Engine> (ANNA_FILE_LOCATION));
+ if(!a_engine)
+ throw anna::RuntimeException("Invalid codec engine reference (NULL). Use setEngine() to set the corresponding codec engine", ANNA_FILE_LOCATION);
+
+ return a_engine;
}
//------------------------------------------------------------ Avp::initialize()
//------------------------------------------------------------------------------
void Avp::initialize() throw() {
- a_engine = NULL;
a_id = helpers::AVPID__AVP; // (0,0)
a_flags = 0x00;
a_insertionPositionForChilds = 0;
//---------------------------------------------------------------- Avp::addAvp()
//------------------------------------------------------------------------------
Avp * Avp::addAvp(avp_container &avps, int &insertionPositionForChilds, AvpId id, Engine *engine) throw() {
- Avp * result = engine->allocateAvp();
+ Avp * result = engine->createAvp(NULL);
result->setId(id);
addChild(avps, insertionPositionForChilds, result);
return result;
}
+//------------------------------------------------------------------------------
+//---------------------------------------------------------------- Avp::addAvp()
+//------------------------------------------------------------------------------
+Avp * Avp::addAvp(Avp * avp) throw(anna::RuntimeException) {
+ if(!avp) return NULL;
+ if (avp->getEngine() != getEngine()) return NULL;
+ addChild(avp);
+ return avp;
+}
+
+
//------------------------------------------------------------------------------
//------------------------------------------------------------- Avp::removeAvp()
//------------------------------------------------------------------------------
const stack::Avp *stackAvp = getStackAvp();
if(!stackAvp) {
- anna::Logger::error("Impossible to decide if flags are correct because stack avp is not identified. Assume flags ok", ANNA_FILE_LOCATION);
+ std::string msg = "Impossible to decide if flags are correct because stack avp is not identified. Assume flags ok for Avp ";
+ msg += anna::diameter::functions::avpIdAsPairString(a_id);
+ anna::Logger::error(msg, ANNA_FILE_LOCATION);
return true;
};
// V-bit
if((Vnone && Mnone && Pnone && vendorBit()) || (Vmust && !vendorBit()) || (Vmustnot && vendorBit())) {
- anna::Logger::error("Vendor Bit (V) incoherence found", ANNA_FILE_LOCATION);
+ std::string msg = "Vendor Bit (V) incoherence found for Avp ";
+ msg += stackAvp->getName();
+ anna::Logger::error(msg, ANNA_FILE_LOCATION);
return false;
}
// M-bit
if((Mmust && !mandatoryBit()) || (Mmustnot && mandatoryBit())) {
- anna::Logger::error("Mandatory Bit (M) incoherence found", ANNA_FILE_LOCATION);
+ std::string msg = "Mandatory Bit (M) incoherence found for Avp ";
+ msg += stackAvp->getName();
+ anna::Logger::error(msg, ANNA_FILE_LOCATION);
return false;
}
// P-bit
if((Pmust && !encryptionBit()) || (Pmustnot && encryptionBit())) {
- anna::Logger::error("Encryption Bit (P) incoherence found", ANNA_FILE_LOCATION);
+ std::string msg = "Encryption Bit (P) incoherence found for Avp ";
+ msg += stackAvp->getName();
+ anna::Logger::error(msg, ANNA_FILE_LOCATION);
return false;
}
// Reserved bits
if((a_flags & 0x1f) != 0x00) {
- anna::Logger::error("Any (or more than one) of the reserved avp flags bit has been activated. Reserved bits must be null", ANNA_FILE_LOCATION);
+ std::string msg = "Any (or more than one) of the reserved avp flags bit has been activated. Reserved bits must be null. Avp is ";
+ msg += stackAvp->getName();
+ anna::Logger::error(msg, ANNA_FILE_LOCATION);
return false;
}
//------------------------------------------------------------------------------
//-------------------------------------------- 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);
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->setNewFailedAvp((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:
if((size % 4) != 0) {
oamModule.activateAlarm(OamModule::Alarm::AvpDecode__IncorrectLength);
oamModule.count(OamModule::Counter::AvpDecode__IncorrectLength);
+
+ if(answer) {
+ answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_INVALID_AVP_LENGTH);
+ 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);
}
int avpPos = 0;
Avp* avp;
anna::DataBlock db;
+ // Me as parent:
+ parent_t me = parent;
+ me.addAvp(a_id);
while(avpPos < size) {
try {
- avp = getEngine()->allocateAvp();
+ avp = getEngine()->createAvp(NULL);
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;
//------------------------------------------------------------------------------
//---------------------------------------------------------------- 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();
if(db.getSize() < HeaderLengthVinactive) {
oamModule.activateAlarm(OamModule::Alarm::AvpDecode__NotEnoughBytesToCoverAvpHeaderLength);
oamModule.count(OamModule::Counter::AvpDecode__NotEnoughBytesToCoverAvpHeaderLength);
- // DIAMETER_INVALID_AVP_LENGTH; // no podré construir un avp fiable, así que no registro el result-code
+ // DIAMETER_INVALID_AVP_LENGTH; // no podr� construir un avp fiable, as� que no registro el result-code
throw anna::RuntimeException("Not enough bytes to cover avp header length", ANNA_FILE_LOCATION);
}
if(db.getSize() < HeaderLengthVactive) {
oamModule.activateAlarm(OamModule::Alarm::AvpDecode__NotEnoughBytesToCoverAvpHeaderLength);
oamModule.count(OamModule::Counter::AvpDecode__NotEnoughBytesToCoverAvpHeaderLength);
- // DIAMETER_INVALID_AVP_LENGTH; // no podré construir un avp fiable, así que no registro el result-code
+ // DIAMETER_INVALID_AVP_LENGTH; // no podr� construir un avp fiable, as� que no registro el result-code
throw anna::RuntimeException(anna::functions::asString("Not enough bytes to cover avp header length (avp code = %u)", code), ANNA_FILE_LOCATION);
}
// 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);
if(answer) {
answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_INVALID_AVP_LENGTH);
- answer->setNewFailedAvp(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->setNewFailedAvp((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);
}
if(!stackFormat || !stackFormat->isGrouped()) {
- //LOGDEBUG(anna::Logger::debug("Avp is not grouped. Nothing fix.", ANNA_FILE_LOCATION));
+ //LOGDEBUG(anna::Logger::debug("Avp is not grouped. Nothing to fix.", ANNA_FILE_LOCATION));
return;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------ 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();
}
avp_it++;
- // (*) for (register int k = 0; k < (*rule_it).second.getQualMax(); k++) avp_it++
+ // (*) for (int k = 0; k < (*rule_it).second.getQualMax(); k++) avp_it++
} else
okFixed = false;
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->setNewFailedAvp((*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
}
// 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) {
if(answer) {
answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_MISSING_AVP);
- answer->setNewFailedAvp(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->setNewFailedAvp((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())));
}
}
// 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->setNewFailedAvp((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
// We wouldn't know where are these disregarded, but...
if(answer) {
answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_AVP_NOT_ALLOWED);
- answer->setNewFailedAvp((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;
//------------------------------------------------------------------------------
//----------------------------------------------------------------- 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
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->setNewFailedAvp((Avp*)this); RFC 6733 says nothing about Failed-AVP in this case...
+ answer->setFailedAvp(parent, a_id, stackAvp->getName().c_str()); // 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())));
}
//////////////////////
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->setNewFailedAvp((Avp*)this);
+ answer->setFailedAvp(parent, a_id, stackAvp->getName().c_str());
}
- 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()));
}
}
if(!stackFormat) {
isHex = true;
- return a_Unknown->asHexString(); // el asHexString del OctetString no puede lanzar una excepcion en realidad
+ // Tricky situation: if you change the dictionary dynamically, and a previous formatted avp
+ // becomes unknown (the change consists in remove Avps basically), then this would get a core
+ // dump: a_Unknown = NULL. We are not going to protect that situation because it represents a
+ // implementation fault, and there are many points which could have similar bad behaviour
+ // (those where we access directly the a_Unknown pointer).
+ // The best way to afford this is ... TODO:
+ // Freeze dictionary after use from any resource (avp, message), setting a flag which deny
+ // any modification in such dictionary. The best way to do this is on engine configuration
+ // for Avp o Message, where we could invoke something like getEngine()->getDictionary()->freeze()
+
+ return a_Unknown->asHexString(); // asHexString for OctetString cannot launch exception
}
// Special case for Address: could launch exception if not printable
}
+//------------------------------------------------------------------------------
+//---------------------------------------------------------------- Avp::decode()
+//------------------------------------------------------------------------------
+void Avp::decode(const anna::DataBlock &db) throw(anna::RuntimeException) {
+ parent_t parent;
+ parent.setMessage(CommandId(0, false), "No-Parent");
+ decode(db, parent, NULL);
+}
+
+
//------------------------------------------------------------------------------
//--------------------------------------------------------------- Avp::fromXML()
//------------------------------------------------------------------------------
// Check attributes exclusiveness
if(name) { // compact mode
- if(code || flags || vendorCode) {
+ bool allowFlagsField = ( stackAvp->getVbit() == anna::diameter::stack::Avp::FlagRule::may || stackAvp->getVbit() == anna::diameter::stack::Avp::FlagRule::shouldnot
+ || stackAvp->getMbit() == anna::diameter::stack::Avp::FlagRule::may || stackAvp->getMbit() == anna::diameter::stack::Avp::FlagRule::shouldnot
+ /* umm, perhaps we could omit for bit P, whic is deprecated ... */
+ /* || stackAvp->getPbit() == anna::diameter::stack::Avp::FlagRule::may || stackAvp->getPbit() == anna::diameter::stack::Avp::FlagRule::shouldnot*/ );
+ if(code || (flags && !allowFlagsField) || vendorCode) {
std::string msg = "Error processing avp <name '"; msg += name->getValue();
- msg += "'>: avp attributes <'code' + 'flags' + 'vendorCode'> are not allowed if <'name'> is provided";
+ if (flags) msg += "'>: avp attributes <'code' + 'flags' + 'vendorCode'> are not allowed if <'name'> is provided (also flags is not permitted: no may, no shouldnot)";
+ else msg += "'>: avp attributes <'code' + 'vendorCode'> are not allowed if <'name'> is provided";
throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
}
setId(stackAvp->getId());
+
+ if (flags && allowFlagsField) {
+ // Flags check
+ int i_aux = flags->getIntegerValue();
+
+ if(i_aux < 0 || i_aux > 256) {
+ std::string msg = "Error processing avp <flags '"; msg += flags->getValue();
+ msg += "': out of range [0,256]";
+ throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
+ }
+
+ a_flags = i_aux;
+ }
+
+
} else {
if(!code || !flags || !vendorCode) {
std::string s_code = code ? code->getValue() : "?";
}
try {
- avp = getEngine()->allocateAvp();
+ avp = getEngine()->createAvp(NULL);
avp -> fromXML(*it);
} catch(anna::RuntimeException &ex) {
getEngine()->releaseAvp(avp);
if(compactMode) {
result->createAttribute("name", stackAvp->getName());
+ // If may or shouldnot is present in AVP definition, we have to show flags to avoid uncertainty
+ if ( stackAvp->getVbit() == anna::diameter::stack::Avp::FlagRule::may || stackAvp->getVbit() == anna::diameter::stack::Avp::FlagRule::shouldnot
+ || stackAvp->getMbit() == anna::diameter::stack::Avp::FlagRule::may || stackAvp->getMbit() == anna::diameter::stack::Avp::FlagRule::shouldnot
+ /* umm, perhaps we could omit for bit P, whic is deprecated ... */
+ /* || stackAvp->getPbit() == anna::diameter::stack::Avp::FlagRule::may || stackAvp->getPbit() == anna::diameter::stack::Avp::FlagRule::shouldnot*/ )
+ result->createAttribute("flags", (int)a_flags);
} else {
result->createAttribute("code", a_id.first);
result->createAttribute("vendor-code", a_id.second);
return result;
}
+
//------------------------------------------------------------------------------
//----------------------------------------------------------- Avp::asXMLString()
//------------------------------------------------------------------------------
}
-/////////////////////
-// FORMAT-SPECIFIC //
-/////////////////////
-
-
//------------------------------------------------------------------------------
-//---------------------------------------------------- Avp::initializeByFormat()
+//---------------------------------------------------------------- Avp::isLike()
//------------------------------------------------------------------------------
-void Avp::initializeByFormat() throw() {
- a_ISDNNumber = NULL;
- a_ISDNAddress = NULL;
- a_Unsigned16 = NULL;
+bool Avp::isLike(const std::string &pattern) const throw() {
+ anna::RegularExpression re(pattern);
+ return re.isLike(asXMLString());
}
-
-
-//------------------------------------------------------------------------------
-//--------------------------------------------------------- Avp::clearByFormat()
-//------------------------------------------------------------------------------
-void Avp::clearByFormat() throw() {
- delete a_ISDNNumber;
- delete a_ISDNAddress;
- delete a_Unsigned16;
-}
-
-
-//------------------------------------------------------------------------------
-//---------------------------------------------------- Avp::allocationByFormat()
-//------------------------------------------------------------------------------
-void Avp::allocationByFormat(const stack::Format *stackFormat) throw() {
- if(stackFormat->getName() == "ISDNNumber") a_ISDNNumber = new ISDNNumber();
- else if(stackFormat->getName() == "ISDNAddress") a_ISDNAddress = new ISDNAddress();
- else if(stackFormat->getName() == "Unsigned16") a_Unsigned16 = new Unsigned16();
-}
-
-
-//------------------------------------------------------------------------------
-//----------------------------------------------------- Avp::getLengthByFormat()
-//------------------------------------------------------------------------------
-U24 Avp::getLengthByFormat(const stack::Format *stackFormat) const throw() {
- U24 result = 0;
-
- if(stackFormat->getName() == "ISDNNumber") result += a_ISDNNumber->getSize();
- else if(stackFormat->getName() == "ISDNAddress") result += a_ISDNAddress->getSize();
- else if(stackFormat->getName() == "Unsigned16") result += a_Unsigned16->getSize();
-
- return result;
-}
-
-
-//------------------------------------------------------------------------------
-//------------------------------------------------ Avp::decodeDataPartByFormat()
-//------------------------------------------------------------------------------
-void Avp::decodeDataPartByFormat(const char * buffer, int size, const stack::Format *stackFormat) throw(anna::RuntimeException) {
- if(stackFormat->getName() == "ISDNNumber") a_ISDNNumber->decode(buffer, size);
- else if(stackFormat->getName() == "ISDNAddress") a_ISDNAddress->decode(buffer, size);
- else if(stackFormat->getName() == "Unsigned16") a_Unsigned16->decode(buffer, size);
-}
-
-
-//------------------------------------------------------------------------------
-//---------------------------------------------------------- Avp::codeByFormat()
-//------------------------------------------------------------------------------
-void Avp::codeByFormat(char* dataPart, const stack::Format *stackFormat) const throw(anna::RuntimeException) {
- int dataBytes;
-
- if(stackFormat->getName() == "ISDNNumber") a_ISDNNumber->code(dataPart, dataBytes);
- else if(stackFormat->getName() == "ISDNAddress") a_ISDNAddress->code(dataPart, dataBytes);
- else if(stackFormat->getName() == "Unsigned16") a_Unsigned16->code(dataPart, dataBytes);
-}
-
-
-//------------------------------------------------------------------------------
-//---------------------------------------------------- Avp::getXMLdataByFormat()
-//------------------------------------------------------------------------------
-std::string Avp::getXMLdataByFormat(bool & isHex, const stack::Format *stackFormat) const throw() {
- std::string result;
-
- if(stackFormat->getName() == "ISDNNumber") {
- isHex = true;
- return a_ISDNNumber->asHexString();
- } else if(stackFormat->getName() == "ISDNAddress") {
- isHex = true;
- return a_ISDNAddress->asHexString();
- } else if(stackFormat->getName() == "Unsigned16") return a_Unsigned16->asPrintableString();
-
- return result;
-}
-
-
-//------------------------------------------------------------------------------
-//------------------------------------------------------- Avp::fromXMLByFormat()
-//------------------------------------------------------------------------------
-void Avp::fromXMLByFormat(const anna::xml::Attribute* data, const anna::xml::Attribute* hexData, const stack::Format *stackFormat) throw(anna::RuntimeException) {
- if(stackFormat->getName() == "ISDNNumber") {
- if(data) a_ISDNNumber->fromPrintableString(data->getValue().c_str());
- else if(hexData) a_ISDNNumber->fromHexString(hexData->getValue());
- } else if(stackFormat->getName() == "ISDNAddress") {
- if(data) a_ISDNAddress->fromPrintableString(data->getValue().c_str());
- else if(hexData) a_ISDNAddress->fromHexString(hexData->getValue());
- } else if(stackFormat->getName() == "Unsigned16") {
- if(data) a_Unsigned16->fromPrintableString(data->getValue().c_str());
- else if(hexData) a_Unsigned16->fromHexString(hexData->getValue());
- }
-}
-