-// 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/codec/functions.hpp> // REQUIRED_WORDS
#include <anna/diameter/codec/OamModule.hpp>
#include <anna/diameter/codec/Engine.hpp>
+#include <anna/diameter/codec/EngineManager.hpp>
#include <anna/diameter/stack/Avp.hpp>
#include <anna/diameter/stack/Format.hpp>
#include <anna/diameter/stack/Dictionary.hpp>
// STL
#include <string>
+#include <vector>
using namespace anna;
//------------------------------------------------------------------------------
//----------------------------------------------------------- Message::Message()
//------------------------------------------------------------------------------
-Message::Message() : a_forCode(true) {
+Message::Message(Engine *engine) : a_engine(engine), a_forCode(true) {
initialize();
}
//------------------------------------------------------------------------------
//----------------------------------------------------------- Message::Message()
//------------------------------------------------------------------------------
-Message::Message(CommandId id) : a_forCode(true) {
+Message::Message(CommandId id, Engine *engine) : a_engine(engine), a_forCode(true) {
initialize();
setId(id);
}
}
+//------------------------------------------------------------------------------
+//--------------------------------------------------------- Message::setEngine()
+//------------------------------------------------------------------------------
+void Message::setEngine(Engine *engine) throw() {
+
+ if (!engine) {
+ LOGWARNING(anna::Logger::warning("Ignored: you must assign a valid codec engine. If you want to set NULL engine, clear the message", ANNA_FILE_LOCATION));
+ return;
+ }
+
+ 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 message first to set the engine again.", ANNA_FILE_LOCATION));
+ return;
+ }
+
+ a_engine = engine;
+}
+
+
//------------------------------------------------------------------------------
//--------------------------------------------------------- Message::getEngine()
//------------------------------------------------------------------------------
Engine * Message::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;
+
}
//-------------------------------------------------------- Message::initialize()
//------------------------------------------------------------------------------
void Message::initialize() throw() {
- a_engine = NULL;
a_version = 1;
a_id = CommandId(0, false);
a_flags = 0x00;
//------------------------------------------------------------------------------
//------------------------------------------------------------- Message::clear()
//------------------------------------------------------------------------------
-void Message::clear() throw(anna::RuntimeException) {
+void Message::clear(bool resetEngine) throw(anna::RuntimeException) {
for(avp_iterator it = avp_begin(); it != avp_end(); it++) { /*avp(it)->clear(); */getEngine()->releaseAvp(Avp::avp(it)); }
a_avps.clear();
a_finds.clear();
// Initialize:
initialize();
+ if (resetEngine) a_engine = NULL;
}
const stack::Command *stackCommand = getStackCommand();
if(!stackCommand) {
- anna::Logger::error("Impossible to decide if flags are correct because stack command is not identified. Assume flags ok", ANNA_FILE_LOCATION);
+ std::string msg = "Impossible to decide if flags are correct because stack command is not identified. Assume flags ok for Message ";
+ msg += anna::diameter::functions::commandIdAsPairString(a_id);
+ anna::Logger::error(msg, ANNA_FILE_LOCATION);
//rc = helpers::base::AVPVALUES__Result_Code::?????;
return true;
};
if(stackCommand->isRequest() != isRequest()) ok = false; // en teoria es imposible salir por aqui: blindado en la dtd
if(isRequest() && errorBit()) {
- anna::Logger::error("E(rror) bit is not allowed at diameter requests", ANNA_FILE_LOCATION);
+ std::string msg = "E(rror) bit is not allowed at diameter requests as ";
+ msg += stackCommand->getName();
+ anna::Logger::error(msg, ANNA_FILE_LOCATION);
ok = false;
}
if(isAnswer() && potentiallyReTransmittedMessageBit()) {
- anna::Logger::error("T(Potentially re-transmitted message) bit is not allowed at diameter answers", ANNA_FILE_LOCATION);
+ std::string msg = "T(Potentially re-transmitted message) bit is not allowed at diameter answers as ";
+ msg += stackCommand->getName();
+ anna::Logger::error(msg, ANNA_FILE_LOCATION);
ok = false;
}
// is set to one (1) or the bits in the Diameter header are set
// incorrectly.
if((a_flags & 0x0f) != 0x00) {
- anna::Logger::error("Any (or more than one) of the reserved message flags bit has been activated. Reserved bits must be null", ANNA_FILE_LOCATION);
+ std::string msg = "Any (or more than one) of the reserved message flags bit has been activated. Reserved bits must be null. Message is ";
+ msg += stackCommand->getName();
+ anna::Logger::error(msg, ANNA_FILE_LOCATION);
rc = helpers::base::AVPVALUES__Result_Code::DIAMETER_INVALID_BIT_IN_HEADER;
return false;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------- Message::setId()
//------------------------------------------------------------------------------
-void Message::setId(CommandId id, bool _clear) throw(anna::RuntimeException) {
- // Clear class content:
- if(_clear) clear();
+void Message::setId(CommandId id) throw(anna::RuntimeException) {
// Id assignment:
a_id = id;
}
+//------------------------------------------------------------------------------
+//-------------------------------------------------- Message::setApplicationId()
+//------------------------------------------------------------------------------
+void Message::setApplicationId(U32 aid) throw(anna::RuntimeException) {
+ a_applicationId = aid;
+
+ // Automatic engine configuration:
+ if (a_engine) return;
+
+ // Codec engine manager (a multithreaded application, normally does not achieve this point, because
+ // messages are prepared for each interface with the corresponding codec engine)
+ anna::diameter::codec::EngineManager &em = anna::diameter::codec::EngineManager::instantiate();
+ if (em.size() == 0) return;
+ if (em.selectFromApplicationId()) {
+ Engine *monostackEngine = em.getMonoStackCodecEngine();
+ if (monostackEngine) { a_engine = monostackEngine; return; }
+ a_engine = em.getCodecEngine(aid);
+ }
+}
+
+
//------------------------------------------------------------------------------
//------------------------------------------------------------ Message::addAvp()
//------------------------------------------------------------------------------
}
+//------------------------------------------------------------------------------
+//------------------------------------------------------------ Message::addAvp()
+//------------------------------------------------------------------------------
+Avp * Message::addAvp(Avp * avp) throw() {
+ if(!avp) return NULL;
+ if (avp->getEngine() != getEngine()) return NULL;
+ addChild(avp);
+ return avp;
+}
+
+
//------------------------------------------------------------------------------
//--------------------------------------------------------- Message::removeAvp()
//------------------------------------------------------------------------------
void Message::decode(const anna::DataBlock &db, Message *ptrAnswer) throw(anna::RuntimeException) {
// Trace
LOGDEBUG(
- anna::xml::Node root("Message::decode");
- std::string trace = "DataBlock to decode:\n";
- trace += db.asString();
- anna::Logger::debug(trace, ANNA_FILE_LOCATION);
+ anna::xml::Node root("Message::decode");
+ std::string trace = "DataBlock to decode:\n";
+ trace += db.asString();
+ anna::Logger::debug(trace, ANNA_FILE_LOCATION);
);
- clear();
+ clear(false /* respect engine */);
// EXCEPTION MANAGEMENT IN THIS METHOD
// ===================================
// DECODE PHASE
//
// VALIDATION PHASE
// Launch exception on first validation error (validateAll == false), or log warning reporting all validation errors when
- // complete validation is desired (validateAll == true, engine default) launching a final exception like "decoded an invalid message".
+ // complete validation is desired (validateAll == true, engine default) launching a final exception like "the decoded message is invalid".
// OAM
OamModule &oamModule = OamModule::instantiate();
if(db.getSize() < HeaderLength) {
oamModule.activateAlarm(OamModule::Alarm::MessageDecode__NotEnoughBytesToCoverMessageHeaderLength);
oamModule.count(OamModule::Counter::MessageDecode__NotEnoughBytesToCoverMessageHeaderLength);
- // DIAMETER_INVALID_MESSAGE_LENGTH; // no podré construir un answer fiable, así que no registro el result-code
+ // DIAMETER_INVALID_MESSAGE_LENGTH; // no podr� construir un answer fiable, as� que no registro el result-code
throw anna::RuntimeException("Not enough bytes to cover message header length (20 bytes)", ANNA_FILE_LOCATION);
}
U24 code = DECODE3BYTES_INDX_VALUETYPE(buffer, 5, U24);
- setId(CommandId(code, requestBit() /* based on a_flags */));
+ a_id = CommandId(code, requestBit() /* based on a_flags */);
- a_applicationId = DECODE4BYTES_INDX_VALUETYPE(buffer, 8, U32);
+ setApplicationId(DECODE4BYTES_INDX_VALUETYPE(buffer, 8, U32)); // centralize set, because it could be used for stack selection.
a_hopByHop = DECODE4BYTES_INDX_VALUETYPE(buffer, 12, U32);
Avp* avp;
anna::DataBlock db_aux;
+ // Parent information:
+ parent_t parent;
+ parent.setMessage(a_id);
+
+
while(avpPos < dataBytes) {
try {
- avp = getEngine()->allocateAvp();
+ avp = getEngine()->createAvp(NULL);
db_aux.assign(startData + avpPos, dataBytes - avpPos /* is valid to pass total length (indeed i don't know the real avp length) because it will be limited and this has deep copy disabled (no memory is reserved) */);
- avp -> decode(db_aux, answer);
+ avp -> decode(db_aux, parent, answer);
} catch(anna::RuntimeException &ex) {
- if(answer) {
- answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_INVALID_AVP_VALUE); // unspecified error ...
- answer->setNewFailedAvp(avp->getId());
- }
-
getEngine()->releaseAvp(avp);
LOGWARNING(
- anna::Logger::warning(ex.getText(), ANNA_FILE_LOCATION);
- anna::Logger::warning("Although a decoding error was found, validation could be checked because message could be enough for the application", ANNA_FILE_LOCATION);
+ anna::Logger::warning(ex.getText(), ANNA_FILE_LOCATION);
+ anna::Logger::warning("Although a decoding error was found, validation could be checked because message could be enough for the application", ANNA_FILE_LOCATION);
);
break;
}
// Trace
LOGDEBUG(
- std::string trace = "Message decoded:\n";
- trace += asXMLString();
- anna::Logger::debug(trace, ANNA_FILE_LOCATION);
+ std::string trace = "Message decoded:\n";
+ trace += asXMLString();
+ anna::Logger::debug(trace, ANNA_FILE_LOCATION);
);
// Post-Validation
Engine::ValidationMode::_v vmode = getEngine()->getValidationMode();
if((vmode == Engine::ValidationMode::AfterDecoding) || (vmode == Engine::ValidationMode::Always))
if(!valid(answer))
- throw anna::RuntimeException("Decoded an invalid message. See previous report on warning-level traces", ANNA_FILE_LOCATION);
+ throw anna::RuntimeException("The decoded message is invalid. See previous report on warning-level traces", ANNA_FILE_LOCATION);
}
//------------------------------------------------------------------------------
-//------------------------------------------------------ Message::addFailedAVP()
+//------------------------------------------------------ Message::setFailedAvp()
//------------------------------------------------------------------------------
-Avp * Message::addFailedAVP() throw() {
- Avp *result = getAvp(helpers::base::AVPID__Failed_AVP, 1, anna::Exception::Mode::Ignore);
+void Message::setFailedAvp(const parent_t &parent, AvpId wrong, const char *wrongName) throw(anna::RuntimeException) {
- if(!result) result = addAvp(helpers::base::AVPID__Failed_AVP);
+ if(isRequest()) return;
- return result;
+ // RFC 6733:
+ //
+ // 7.5. Failed-AVP AVP
+ //
+ // The Failed-AVP AVP (AVP Code 279) is of type Grouped and provides
+ // debugging information in cases where a request is rejected or not
+ // fully processed due to erroneous information in a specific AVP. The
+ // value of the Result-Code AVP will provide information on the reason
+ // for the Failed-AVP AVP. A Diameter answer message SHOULD contain an
+ // instance of the Failed-AVP AVP that corresponds to the error
+ // indicated by the Result-Code AVP. For practical purposes, this
+ // Failed-AVP would typically refer to the first AVP processing error
+ // that a Diameter node encounters.
+
+ // Although the Failed-AVP definition has cardinality 1* and Failed-AVP itself is defined in
+ // most of the command codes as *[Failed-AVP], i think this is not a deliberate ambiguity.
+ // Probably the RFC wants to give freedom to the application layer, but it is recommended to
+ // have only one child (wrong avp) inside a unique message Failed-AVP to ease the Result-Code
+ // correspondence. Anyway, this behaviour could be easily opened by mean 'setSingleFailedAVP(false)'
+ Avp *theFailedAvp = getAvp(helpers::base::AVPID__Failed_AVP, 1, anna::Exception::Mode::Ignore);
+ if (theFailedAvp) {
+ if (getEngine()->getSingleFailedAVP()) {
+ LOGDEBUG(anna::Logger::debug("Failed-AVP has already been added. RFC 6733 Section 7.5 recommends to store only the first error found", ANNA_FILE_LOCATION));
+ return;
+ }
+ }
+
+ // Section 7.5 RFC 6733: A Diameter message SHOULD contain one Failed-AVP AVP
+ theFailedAvp = addAvp(helpers::base::AVPID__Failed_AVP);
+ Avp *leaf = theFailedAvp;
+
+ LOGDEBUG(
+ std::string msg = "Adding to Failed-AVP, the wrong avp ";
+ msg += wrongName ? wrongName : (anna::diameter::functions::avpIdAsPairString(wrong));
+ msg += " found inside ";
+ msg += parent.asString();
+
+ anna::Logger::debug(msg, ANNA_FILE_LOCATION);
+ );
+
+ std::vector<AvpId>::const_iterator it;
+ for(it = parent.AvpsId.begin(); it != parent.AvpsId.end(); it++)
+ leaf = leaf->addAvp(*it);
+
+ leaf->addAvp(wrong);
}
//------------------------------------------------------------------------------
//----------------------------------------------- Message::setStandardToAnswer()
//------------------------------------------------------------------------------
-void Message::setStandardToAnswer(const Message &request, const std::string &originHost, const std::string &originRealm, int resultCode) throw() {
+void Message::setStandardToAnswer(const Message &request, const std::string &originHost, const std::string &originRealm, int resultCode) throw(anna::RuntimeException) {
if(!request.getId().second) return;
// Message header:
const Avp *reqSessionId = request.getAvp(helpers::base::AVPID__Session_Id, 1, anna::Exception::Mode::Ignore);
if(reqSessionId)
- addAvp(helpers::base::AVPID__Session_Id)->getUTF8String()->setValue(reqSessionId->getUTF8String()->getValue());
+ if(!getAvp(helpers::base::AVPID__Session_Id, 1, anna::Exception::Mode::Ignore))
+ addAvp(helpers::base::AVPID__Session_Id)->getUTF8String()->setValue(reqSessionId->getUTF8String()->getValue());
// Origin-Host & Realm
if(!getAvp(helpers::base::AVPID__Origin_Host, 1, anna::Exception::Mode::Ignore))
// Fix:
fix();
LOGDEBUG(
- std::string msg = "Completed answer:\n";
- msg += asXMLString();
- anna::Logger::debug(msg, ANNA_FILE_LOCATION);
+ std::string msg = "Completed answer:\n";
+ msg += asXMLString();
+ anna::Logger::debug(msg, ANNA_FILE_LOCATION);
);
}
OamModule &oamModule = OamModule::instantiate();
// Dictionary stack command:
const stack::Command *stackCommand = getStackCommand();
- std::string me;
// Only build answer for a request:
Message *answer = isRequest() ? ptrAnswer : NULL;
if(!stackCommand) {
// OAM
- me = anna::diameter::functions::commandIdAsPairString(a_id);
+ std::string me = anna::diameter::functions::commandIdAsPairString(a_id);
oamModule.activateAlarm(OamModule::Alarm::MessageValidation__UnknownOperation__s__UnableToValidate, STRING_WITH_QUOTATION_MARKS__C_STR(me));
oamModule.count(OamModule::Counter::MessageValidation__UnknownOperationUnableToValidate);
return false;
}
- me = stackCommand->getName();
+ // Parent information:
+ parent_t me;
+ me.setMessage(a_id, stackCommand->getName().c_str());
+
//////////////////////////////
// Flags coherence checking //
//////////////////////////////
if(!result) {
// OAM & Depth management
- oamModule.activateAlarm(OamModule::Alarm::MessageValidation__Operation__s__HaveIncoherentFlags__d__, STRING_WITH_QUOTATION_MARKS__C_STR(me), (int)a_flags);
+ oamModule.activateAlarm(OamModule::Alarm::MessageValidation__Operation__s__HaveIncoherentFlags__d__, STRING_WITH_QUOTATION_MARKS__C_STR(me.asString()), (int)a_flags);
oamModule.count(OamModule::Counter::MessageValidation__OperationHaveIncoherentFlags);
if(answer) answer->setResultCode(rc);
- getEngine()->validationAnomaly(anna::functions::asString("Operation %s have incoherent flags (%d)", STRING_WITH_QUOTATION_MARKS__C_STR(me), (int)a_flags));
+ getEngine()->validationAnomaly(anna::functions::asString("Operation %s have incoherent flags (%d)", STRING_WITH_QUOTATION_MARKS__C_STR(me.asString()), (int)a_flags));
}
////////////////////
// Pre-Validation
Engine::ValidationMode::_v vmode = getEngine()->getValidationMode();
- if((vmode == Engine::ValidationMode::BeforeCoding) || (vmode == Engine::ValidationMode::Always)) {
+ if((vmode == Engine::ValidationMode::BeforeEncoding) || (vmode == Engine::ValidationMode::Always)) {
if(!valid())
throw anna::RuntimeException("Try to encode an invalid message. See previous report on warning-level traces", ANNA_FILE_LOCATION);
}
// Pre-Fixing
Engine::FixMode::_v fmode = getEngine()->getFixMode();
- if((fmode == Engine::FixMode::BeforeCoding) || (fmode == Engine::FixMode::Always)) fix();
+ if((fmode == Engine::FixMode::BeforeEncoding) || (fmode == Engine::FixMode::Always)) fix();
// Trace
LOGDEBUG(
- std::string trace = "Message to code:\n";
- trace += asXMLString();
- anna::Logger::debug(trace, ANNA_FILE_LOCATION);
+ std::string trace = "Message to code:\n";
+ trace += asXMLString();
+ anna::Logger::debug(trace, ANNA_FILE_LOCATION);
);
// Memory allocation
U24 length = getLength();
// Trace
LOGDEBUG(
- std::string trace = "DataBlock encoded:\n";
- trace += a_forCode.asString();
-// trace += "\nAs continuous hexadecimal string:\n";
-// trace += anna::functions::asHexString(a_forCode);
- anna::Logger::debug(trace, ANNA_FILE_LOCATION);
+ std::string trace = "DataBlock encoded:\n";
+ trace += a_forCode.asString();
+ // trace += "\nAs continuous hexadecimal string:\n";
+ // trace += anna::functions::asHexString(a_forCode);
+ anna::Logger::debug(trace, ANNA_FILE_LOCATION);
);
return a_forCode;
}
-
//------------------------------------------------------------------------------
-//----------------------------------------------------- Message::fromXMLString()
+//----------------------------------------------------------- Message::loadXML()
//------------------------------------------------------------------------------
-void Message::fromXMLString(const std::string &xmlString) throw(anna::RuntimeException) {
- LOGDEBUG(anna::Logger::debug("Reading diameter message from xml string representation", ANNA_FILE_LOCATION));
- anna::xml::DocumentMemory xmlDocument; // has private copy constructor defined but not implemented to avoid inhenrit/copy (is very heavy)
- const anna::xml::Node *rootNode;
- xmlDocument.initialize(xmlString.c_str());
- rootNode = xmlDocument.parse(getEngine()->getDTD()); // Parsing: fail here if xml violates dtd
- LOGDEBUG(anna::Logger::debug("Read OK from XML string representation", ANNA_FILE_LOCATION));
- fromXML(rootNode);
-}
+void Message::loadXML(const std::string &xmlPathFile) throw(anna::RuntimeException) {
+ anna::xml::DocumentFile xmlDocument;
+ anna::diameter::codec::functions::messageXmlDocumentFromXmlFile(xmlDocument, xmlPathFile);
+ fromXML(xmlDocument.getRootNode());
+}
//------------------------------------------------------------------------------
//----------------------------------------------------------- Message::fromXML()
//------------------------------------------------------------------------------
void Message::fromXML(const anna::xml::Node* messageNode) throw(anna::RuntimeException) {
- // <!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>
+ // <!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-to-end-id CDATA #IMPLIED>
const anna::xml::Attribute *version, *name, *code, *flags, *pbit, *ebit, *tbit, *appid, *hbh, *ete;
version = messageNode->getAttribute("version", false /* no exception */);
name = messageNode->getAttribute("name", false /* no exception */);
tbit = messageNode->getAttribute("t-bit", false /* no exception */);
appid = messageNode->getAttribute("application-id"); // required
hbh = messageNode->getAttribute("hop-by-hop-id", false /* no exception */);
- ete = messageNode->getAttribute("end-by-end-id", false /* no exception */);
+ ete = messageNode->getAttribute("end-to-end-id", false /* no exception */);
int i_aux;
+ unsigned int u_aux;
+
+ // Clear the message
+ clear(false /* respect engine */);
if(version) {
i_aux = version->getIntegerValue();
a_version = i_aux;
}
+ // Application-id
+ // This is called before any operation which needs to know about the stack elements (this could set the dictionary)
+ setApplicationId(appid->getIntegerValue());
+
// Dictionary
const stack::Dictionary * dictionary = getEngine()->getDictionary();
const stack::Command *stackCommand = NULL;
}
setId(stackCommand->getId());
+
// 'P', 'E' and 'T' flags:
bool activateP = pbit ? (pbit->getValue() == "yes") : false;
bool activateE = ebit ? (ebit->getValue() == "yes") : false;
a_flags = i_aux;
int flagsBCK = a_flags;
// Final assignments
- setId(CommandId(u_code, requestBit() /* based on a_flags */));
+ a_id = CommandId(u_code, requestBit() /* based on a_flags */);
// Flags could have been updated regarding dictionary, but during parsing we must respect xml file:
a_flags = flagsBCK;
}
- // Application-id
- i_aux = appid->getIntegerValue();
-
- if(i_aux < 0) {
- std::string msg = "Error processing command <application-id '"; msg += appid->getValue();
- msg += "': negative values are not allowed";
- throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
- }
-
- setApplicationId(i_aux);
-
// Hob-by-hop-id
if(hbh) {
- i_aux = hbh->getIntegerValue();
+ u_aux = hbh->getIntegerValue();
- if(i_aux < 0) {
+ /*
+ if(u_aux < 0) {
std::string msg = "Error processing command <hop-by-hop-id '"; msg += hbh->getValue();
msg += "': negative values are not allowed";
throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
}
- } else i_aux = 0;
+ */
+ } else u_aux = 0;
- setHopByHop(i_aux);
+ setHopByHop(u_aux);
// End-to-end-id
if(ete) {
- i_aux = ete->getIntegerValue();
+ u_aux = ete->getIntegerValue();
- if(i_aux < 0) {
+ /*
+ if(u_aux < 0) {
std::string msg = "Error processing command <end-to-end-id '"; msg += ete->getValue();
msg += "': negative values are not allowed";
throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
}
- } else i_aux = 0;
+ */
+ } else u_aux = 0;
- setEndToEnd(i_aux);
+ setEndToEnd(u_aux);
// Childrens
Avp *avp;
}
try {
- avp = getEngine()->allocateAvp();
+ avp = getEngine()->createAvp(NULL);
avp -> fromXML(*it);
} catch(anna::RuntimeException &ex) {
getEngine()->releaseAvp(avp);
}
-//------------------------------------------------------------------------------
-//----------------------------------------------------------- Message::loadXML()
-//------------------------------------------------------------------------------
-void Message::loadXML(const std::string & xmlPathFile) throw(anna::RuntimeException) {
- LOGDEBUG(
- std::string trace = "Loading diameter message from file '";
- trace += xmlPathFile;
- trace += "'";
- anna::Logger::debug(trace, ANNA_FILE_LOCATION);
- );
- anna::xml::DocumentFile xmlDocument; // has private copy constructor defined but not implemented to avoid inhenrit/copy (is very heavy)
- const anna::xml::Node *rootNode;
- xmlDocument.initialize(xmlPathFile.c_str()); // fail here is i/o error
- rootNode = xmlDocument.parse(getEngine()->getDTD()); // Parsing: fail here if xml violates dtd
- LOGDEBUG(
- std::string trace = "Loaded XML file (";
- trace += xmlPathFile;
- trace += "):\n";
- trace += anna::xml::Compiler().apply(rootNode);
- anna::Logger::debug(trace, ANNA_FILE_LOCATION);
- );
- fromXML(rootNode);
-}
-
-
//------------------------------------------------------------------------------
//------------------------------------------------------------- Message::asXML()
//------------------------------------------------------------------------------
anna::xml::Node* Message::asXML(anna::xml::Node* parent) const throw() {
- // <!ATTLIST message version CDATA #IMPLIED name CDATA #IMPLIED code CDATA #IMPLIED flags CDATA #IMPLIED application-id CDATA #REQUIRED hop-by-hop-id CDATA #IMPLIED end-by-end-id CDATA #IMPLIED>
+ // <!ATTLIST message version CDATA #IMPLIED name CDATA #IMPLIED code CDATA #IMPLIED flags CDATA #IMPLIED application-id CDATA #REQUIRED hop-by-hop-id CDATA #IMPLIED end-to-end-id CDATA #IMPLIED>
anna::xml::Node* result = parent->createChild("message");
// Dictionary stack command:
const stack::Command *stackCommand = getStackCommand();
result->createAttribute("application-id", anna::functions::asString(a_applicationId));
result->createAttribute("hop-by-hop-id", anna::functions::asString(a_hopByHop));
- result->createAttribute("end-by-end-id", anna::functions::asString(a_endToEnd));
+ result->createAttribute("end-to-end-id", anna::functions::asString(a_endToEnd));
// Avps:
for(const_avp_iterator it = avp_begin(); it != avp_end(); it++) {