-// ANNA - Anna is Not Nothingness Anymore
-//
-// (c) Copyright 2005-2014 Eduardo Ramos Testillano & Francisco Ruiz Rayo
-//
-// http://redmine.teslayout.com/projects/anna-suite
-//
-// 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 the copyright holder 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
//------------------------------------------------------------------------------
//------------------------------------------------------------------- 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) {
+ 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));
+Engine * Avp::getEngine() const noexcept(false) {
+ 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;
+void Avp::initialize() {
a_id = helpers::AVPID__AVP; // (0,0)
a_flags = 0x00;
a_insertionPositionForChilds = 0;
//------------------------------------------------------------------------------
//----------------------------------------------------------------- Avp::clear()
//------------------------------------------------------------------------------
-void Avp::clear() throw(anna::RuntimeException) {
+void Avp::clear() noexcept(false) {
delete a_OctetString;
delete a_Integer32;
delete a_Integer64;
//------------------------------------------------------------------------------
//-------------------------------------------------------------- Avp::avp_find()
//------------------------------------------------------------------------------
-avp_iterator Avp::avp_find(avp_container &avps, AvpId id, unsigned int position) throw() {
+avp_iterator Avp::avp_find(avp_container &avps, AvpId id, unsigned int position) {
int match = 0;
Avp *aux;
//------------------------------------------------------------------------------
//---------------------------------------------------------------- Avp::addAvp()
//------------------------------------------------------------------------------
-Avp * Avp::addAvp(avp_container &avps, int &insertionPositionForChilds, AvpId id, Engine *engine) throw() {
- Avp * result = engine->allocateAvp();
+Avp * Avp::addAvp(avp_container &avps, int &insertionPositionForChilds, AvpId id, Engine *engine) {
+ Avp * result = engine->createAvp(NULL);
result->setId(id);
addChild(avps, insertionPositionForChilds, result);
return result;
}
+//------------------------------------------------------------------------------
+//---------------------------------------------------------------- Avp::addAvp()
+//------------------------------------------------------------------------------
+Avp * Avp::addAvp(Avp * avp) noexcept(false) {
+ if(!avp) return NULL;
+ if (avp->getEngine() != getEngine()) return NULL;
+ addChild(avp);
+ return avp;
+}
+
+
//------------------------------------------------------------------------------
//------------------------------------------------------------- Avp::removeAvp()
//------------------------------------------------------------------------------
-bool Avp::removeAvp(avp_container &avps, find_container &finds, AvpId id, int ocurrence, Engine *engine) throw() {
+bool Avp::removeAvp(avp_container &avps, find_container &finds, AvpId id, int ocurrence, Engine *engine) {
bool removed = false;
bool do_remove = true;
int position = ocurrence;
//------------------------------------------------------------------------------
//-------------------------------------------------------------- Avp::countAvp()
//------------------------------------------------------------------------------
-int Avp::countAvp(const avp_container &avps, AvpId id) throw() {
+int Avp::countAvp(const avp_container &avps, AvpId id) {
int result = 0;
const_avp_iterator it;
//------------------------------------------------------------------------------
//-------------------------------------------------------------- Avp::firstAvp()
//------------------------------------------------------------------------------
-const Avp* Avp::firstAvp(const avp_container &avps, AvpId id) throw() {
+const Avp* Avp::firstAvp(const avp_container &avps, AvpId id) {
const_avp_iterator it = avp_find(avps, id, 1);
if(it != avps.end())
//------------------------------------------------------------------------------
//----------------------------------------------------------- Avp::countChilds()
//------------------------------------------------------------------------------
-int Avp::countChilds(const avp_container &avps) throw() {
+int Avp::countChilds(const avp_container &avps) {
return avps.size();
}
//------------------------------------------------------------------------------
//---------------------------------------------------------------- Avp::getAvp()
//------------------------------------------------------------------------------
-const Avp *Avp::getAvp(const avp_container &avps, find_container &finds, AvpId id, int ocurrence, Engine *engine, anna::Exception::Mode::_v emode) throw(anna::RuntimeException) {
+const Avp *Avp::getAvp(const avp_container &avps, find_container &finds, AvpId id, int ocurrence, Engine *engine, anna::Exception::Mode::_v emode) noexcept(false) {
if(ocurrence == 0) {
LOGDEBUG(anna::Logger::debug("Ocurrence number zero has no sense. NULL returned.", ANNA_FILE_LOCATION));
return NULL;
//------------------------------------------------------------------------------
//--------------------------------------------------------------- Avp::_getAvp()
//------------------------------------------------------------------------------
-const Avp *Avp::_getAvp(AvpId id, int ocurrence, anna::Exception::Mode::_v emode) const throw(anna::RuntimeException) {
+const Avp *Avp::_getAvp(AvpId id, int ocurrence, anna::Exception::Mode::_v emode) const noexcept(false) {
// Dictionary stack avp and format (this):
const stack::Avp *stackAvp = getStackAvp();
const stack::Format *stackFormat = stackAvp ? (stackAvp->getFormat()) : NULL /*Unknown*/;
//------------------------------------------------------------------------------
//---------------------------------------------------------- Avp::assertFormat()
//------------------------------------------------------------------------------
-void Avp::assertFormat(const std::string &name) const throw(anna::RuntimeException) {
+void Avp::assertFormat(const std::string &name) const noexcept(false) {
// Dictionary stack avp and format:
const stack::Avp *stackAvp = getStackAvp();
const stack::Format *stackFormat = stackAvp ? (stackAvp->getFormat()) : NULL /*Unknown*/;
//------------------------------------------------------------------------------
//--------------------------------------------------------------- Avp::flagsOK()
//------------------------------------------------------------------------------
-bool Avp::flagsOK() const throw() {
+bool Avp::flagsOK() const {
// Dictionary stack avp:
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::setId()
//------------------------------------------------------------------------------
-void Avp::setId(AvpId id) throw(anna::RuntimeException) {
+void Avp::setId(AvpId id) noexcept(false) {
// Generic AVP assignment has no sense
if(id == helpers::AVPID__AVP) return;
//------------------------------------------------------------------------------
//----------------------------------------------------------------- Avp::setId()
//------------------------------------------------------------------------------
-void Avp::setId(const char *name) throw(anna::RuntimeException) {
+void Avp::setId(const char *name) noexcept(false) {
setId(getEngine()->avpIdForName(name));
}
//------------------------------------------------------------------------------
//---------------------------------------------------------------- Avp::addAvp()
//------------------------------------------------------------------------------
-Avp * Avp::addAvp(const char *name) throw(anna::RuntimeException) {
+Avp * Avp::addAvp(const char *name) noexcept(false) {
return addAvp(getEngine()->avpIdForName(name));
}
//------------------------------------------------------------------------------
//------------------------------------------------------------- Avp::removeAvp()
//------------------------------------------------------------------------------
-bool Avp::removeAvp(const char *name, int ocurrence) throw(anna::RuntimeException) {
+bool Avp::removeAvp(const char *name, int ocurrence) noexcept(false) {
return removeAvp(getEngine()->avpIdForName(name), ocurrence);
}
//------------------------------------------------------------------------------
//--------------------------------------------------------------- Avp::_getAvp()
//------------------------------------------------------------------------------
-const Avp *Avp::_getAvp(const char *name, int ocurrence, anna::Exception::Mode::_v emode) const throw(anna::RuntimeException) {
+const Avp *Avp::_getAvp(const char *name, int ocurrence, anna::Exception::Mode::_v emode) const noexcept(false) {
return getAvp(getEngine()->avpIdForName(name), ocurrence, emode);
}
//------------------------------------------------------------------------------
//-------------------------------------------------------------- Avp::countAvp()
//------------------------------------------------------------------------------
-int Avp::countAvp(const char *name) const throw(anna::RuntimeException) {
+int Avp::countAvp(const char *name) const noexcept(false) {
return countAvp(getEngine()->avpIdForName(name));
}
//------------------------------------------------------------------------------
//------------------------------------------------------------- Avp::getLength()
//------------------------------------------------------------------------------
-U24 Avp::getLength() const throw() {
+U24 Avp::getLength() const {
U24 result;
// Avp format:
const stack::Avp *stackAvp = getStackAvp();
//------------------------------------------------------------------------------
//-------------------------------------------- Avp::unknownAvpWithMandatoryBit()
//------------------------------------------------------------------------------
-void Avp::unknownAvpWithMandatoryBit() const throw(anna::RuntimeException) {
+void Avp::unknownAvpWithMandatoryBit() const noexcept(false) {
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);
//------------------------------------------------------------------------------
//-------------------------------------------------------- Avp::decodeDataPart()
//------------------------------------------------------------------------------
-void Avp::decodeDataPart(const char * buffer, int size, const parent_t & parent, Message *answer) throw(anna::RuntimeException) {
+void Avp::decodeDataPart(const char * buffer, int size, const parent_t & parent, Message *answer) noexcept(false) {
// OAM
OamModule &oamModule = OamModule::instantiate();
// Dictionary stack avp and format:
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, me, answer);
} catch(anna::RuntimeException &ex) {
//------------------------------------------------------------------------------
//---------------------------------------------------------------- Avp::decode()
//------------------------------------------------------------------------------
-void Avp::decode(const anna::DataBlock &db, const parent_t & parent, Message *answer) throw(anna::RuntimeException) {
+void Avp::decode(const anna::DataBlock &db, const parent_t & parent, Message *answer) noexcept(false) {
// OAM
OamModule &oamModule = OamModule::instantiate();
// 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()) {
+ if(answer) {
+ answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_AVP_UNSUPPORTED);
+ answer->setFailedAvp(parent, a_id);
+ }
- if(answer) {
- answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_AVP_UNSUPPORTED);
- answer->setFailedAvp(parent, a_id);
- }
-
- unknownAvpWithMandatoryBit();
+ unknownAvpWithMandatoryBit();
}
// Avp Length
//------------------------------------------------------------------------------
//----------------------------------------------------------- Avp::getStackAvp()
//------------------------------------------------------------------------------
-const anna::diameter::stack::Avp *Avp::getStackAvp(AvpId id, Engine *engine) throw() {
+const anna::diameter::stack::Avp *Avp::getStackAvp(AvpId id, Engine *engine) {
const stack::Dictionary * dictionary = engine->getDictionary();
return (dictionary ? (dictionary->getAvp(id)) : NULL);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------- Avp::fix()
//------------------------------------------------------------------------------
-void Avp::fix(avp_container &avps, find_container &finds, int &insertionPositionForChilds, anna::diameter::stack::const_avprule_iterator ruleBegin, anna::diameter::stack::const_avprule_iterator ruleEnd) throw() {
+void Avp::fix(avp_container &avps, find_container &finds, int &insertionPositionForChilds, anna::diameter::stack::const_avprule_iterator ruleBegin, anna::diameter::stack::const_avprule_iterator ruleEnd) {
// Exit cases
if(avps.size() == 0) return; // empty content, nothing to fix
//------------------------------------------------------------------------------
//------------------------------------------------------------------- Avp::fix()
//------------------------------------------------------------------------------
-void Avp::fix() throw() {
+void Avp::fix() {
// Dictionary stack avp:
const stack::Avp *stackAvp = getStackAvp();
const stack::Format *stackFormat = stackAvp ? (stackAvp->getFormat()) : NULL /*Unknown*/;
//------------------------------------------------------------------------------
//------------------------------------------------------------ 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 parent_t & parent, 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) noexcept(false) {
bool result = true;
// OAM
OamModule &oamModule = OamModule::instantiate();
//------------------------------------------------------------------------------
//----------------------------------------------------------------- Avp::valid()
//------------------------------------------------------------------------------
-bool Avp::valid(const parent_t & parent, Message *answer) const throw(anna::RuntimeException) {
+bool Avp::valid(const parent_t & parent, Message *answer) const noexcept(false) {
// OAM
OamModule &oamModule = OamModule::instantiate();
// Dictionary stack avp:
//------------------------------------------------------------------------------
//------------------------------------------------------------------ Avp::code()
//------------------------------------------------------------------------------
-void Avp::code(char* buffer, int &size) const throw(anna::RuntimeException) {
+void Avp::code(char* buffer, int &size) const noexcept(false) {
// Code
buffer[0] = (S8)(a_id.first >> 24);
buffer[1] = (S8)(a_id.first >> 16);
//------------------------------------------------------------------------------
//------------------------------------------------------------ Avp::getXMLdata()
//------------------------------------------------------------------------------
-std::string Avp::getXMLdata(bool & isHex, const stack::Format *stackFormat) const throw() {
+std::string Avp::getXMLdata(bool & isHex, const stack::Format *stackFormat) const {
std::string result = "";
isHex = false;
// Unknown
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) {
-
+void Avp::decode(const anna::DataBlock &db) noexcept(false) {
parent_t parent;
- parent.setMessage(CommandId(0,false), "No-Parent");
+ parent.setMessage(CommandId(0, false), "No-Parent");
decode(db, parent, NULL);
}
//------------------------------------------------------------------------------
//--------------------------------------------------------------- Avp::fromXML()
//------------------------------------------------------------------------------
-void Avp::fromXML(const anna::xml::Node* avpNode) throw(anna::RuntimeException) {
+void Avp::fromXML(const anna::xml::Node* avpNode) noexcept(false) {
// <!ATTLIST avp id CDATA #IMPLIED code CDATA #IMPLIED vendor-code CDATA #IMPLIED flags CDATA #IMPLIED data CDATA #IMPLIED hex-data CDATA #IMPLIED>
const anna::xml::Attribute *name, *code, *vendorCode, *flags, *data, *hexData;
name = avpNode->getAttribute("name", false /* no exception */);
// Check attributes exclusiveness
if(name) { // compact mode
- if(code || flags || vendorCode) {
+
+ if(code || vendorCode) {
std::string msg = "Error processing avp <name '"; msg += name->getValue();
- msg += "'>: avp attributes <'code' + 'flags' + 'vendorCode'> are not allowed if <'name'> is provided";
+ msg += "'>: avp attributes <'code' + 'vendorCode'> are not allowed if <'name'> is provided";
throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
}
+ // flags uncertainty:
+ bool flagsUncertainty = ( 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(flags && !flagsUncertainty) {
+ std::string msg = "Be careful processing avp <name '"; msg += name->getValue();
+ msg += "'> together with avp 'flags' attribute, because may/shouldnot uncertainty was not specified";
+ LOGINFORMATION(Logger::information(msg, ANNA_FILE_LOCATION));
+ }
+
setId(stackAvp->getId());
+
+ //if (flags && flagsUncertainty) {
+ if (flags) {
+ // 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() : "?";
int i_aux = code->getIntegerValue();
if(i_aux < 0) {
- std::string msg = "Error processing avp <code '"; msg += code->getValue();
- msg += "': negative values are not allowed";
- throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
+ LOGWARNING(
+ std::string msg = "Error processing avp <code '"; msg += code->getValue();
+ msg += "': negative value read from xml";
+ anna::Logger::warning(msg, ANNA_FILE_LOCATION);
+ );
}
U24 u_code = i_aux;
}
try {
- avp = getEngine()->allocateAvp();
+ avp = getEngine()->createAvp(NULL);
avp -> fromXML(*it);
} catch(anna::RuntimeException &ex) {
getEngine()->releaseAvp(avp);
//------------------------------------------------------------------------------
//----------------------------------------------------------------- Avp::asXML()
//------------------------------------------------------------------------------
-anna::xml::Node* Avp::asXML(anna::xml::Node* parent) const throw() {
+anna::xml::Node* Avp::asXML(anna::xml::Node* parent) const {
// <!ATTLIST avp id CDATA #IMPLIED code CDATA #IMPLIED vendor-code CDATA #IMPLIED flags CDATA #IMPLIED data CDATA #IMPLIED hex-data CDATA #IMPLIED>
anna::xml::Node* result = parent->createChild("avp");
// Dictionary stack avp and format:
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);
//------------------------------------------------------------------------------
//----------------------------------------------------------- Avp::asXMLString()
//------------------------------------------------------------------------------
-std::string Avp::asXMLString() const throw() {
+std::string Avp::asXMLString(bool normalize) const {
anna::xml::Node root("root");
- return anna::xml::Compiler().apply(asXML(&root));
+
+ anna::xml::Compiler::Mode::_v mode = normalize ? anna::xml::Compiler::Mode::Sort : anna::xml::Compiler::Mode::Visual;
+ std::string result = anna::xml::Compiler().apply(asXML(&root), mode);
+
+ if (normalize)
+ result.erase(std::remove(result.begin(), result.end(), '\n'), result.end());
+
+ return result;
}
//------------------------------------------------------------------------------
//---------------------------------------------------------------- Avp::isLike()
//------------------------------------------------------------------------------
-bool Avp::isLike(const std::string &pattern) const throw() {
+bool Avp::isLike(const std::string &pattern) const {
anna::RegularExpression re(pattern);
- return re.isLike(asXMLString());
+ return re.isLike(asXMLString(true /* normalize by mean sorting attribute names and removing new lines */));
}
+
projects / anna.git / blobdiff