-// 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
// 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::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)", 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::setApplicationId()
+//------------------------------------------------------------------------------
+void Message::setApplicationId(U32 aid) throw(anna::RuntimeException) {
+ a_applicationId = aid;
+
+ // Default behaviour:
+ if (!getEngine()->hasSelectStackWithApplicationId()) return;
+
+ // Adapts for Application-ID stack identifier:
+ getEngine()->setDictionary(aid);
+}
+
+
//------------------------------------------------------------------------------
//------------------------------------------------------------ Message::addAvp()
//------------------------------------------------------------------------------
//
// 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();
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->setFailedAvp(avp->getId());
- }
getEngine()->releaseAvp(avp);
LOGWARNING(
anna::Logger::warning(ex.getText(), ANNA_FILE_LOCATION);
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::addTheFailedAVP()
-//------------------------------------------------------------------------------
-Avp * Message::addTheFailedAVP() throw() {
- Avp *result = getAvp(helpers::base::AVPID__Failed_AVP, 1, anna::Exception::Mode::Ignore);
-
- // Section 7.5 RFC 6733: A Diameter message SHOULD contain one Failed-AVP AVP
- if(!result) result = addAvp(helpers::base::AVPID__Failed_AVP);
-
- return result;
-}
-
-
//------------------------------------------------------------------------------
//------------------------------------------------------ Message::setFailedAvp()
//------------------------------------------------------------------------------
-Avp * Message::setFailedAvp(AvpId id) throw(anna::RuntimeException) {
+void Message::setFailedAvp(const parent_t &parent, AvpId wrong, const char *wrongName) throw(anna::RuntimeException) {
- if(isRequest()) return NULL;
+ if(isRequest()) return;
// RFC 6733:
//
// 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 commenting condition block (*).
- Avp *theFailedAvp = addTheFailedAVP();
- LOGDEBUG(
- std::string msg = "Adding wrong avp ";
- msg += anna::diameter::functions::avpIdAsPairString(id);
- msg += " within the message Failed-AVP ...";
- anna::Logger::debug(msg, ANNA_FILE_LOCATION);
- );
-
- if (theFailedAvp->countChilds()) { // (*)
- LOGDEBUG(anna::Logger::debug("Discarding wrong avp. A previous wrong avp was already added into the Failed-AVP. RFC 6733 Section 7.5 recommends to store only the first.", ANNA_FILE_LOCATION));
- return NULL;
+ // 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;
+ }
}
- return (theFailedAvp->addAvp(id));
-}
-
-
-//------------------------------------------------------------------------------
-//------------------------------------------------------ Message::setFailedAvp()
-//------------------------------------------------------------------------------
-Avp * Message::setFailedAvp(Avp *avp) throw(anna::RuntimeException) {
-
- if(!avp || isRequest()) return NULL;
+ // Section 7.5 RFC 6733: A Diameter message SHOULD contain one Failed-AVP AVP
+ theFailedAvp = addAvp(helpers::base::AVPID__Failed_AVP);
+ Avp *leaf = theFailedAvp;
- Avp *theFailedAvp = addTheFailedAVP();
LOGDEBUG(
- std::string msg = "Adding wrong avp ";
- msg += anna::diameter::functions::avpIdAsPairString(avp->getId());
- msg += " within the message Failed-AVP ...";
+ 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);
);
- if (theFailedAvp->countChilds()) { // (*)
- LOGDEBUG(anna::Logger::debug("Discarding wrong avp. A previous wrong avp was already added into the Failed-AVP. RFC 6733 Section 7.5 recommends to store only the first.", ANNA_FILE_LOCATION));
- return NULL;
- }
+ std::vector<AvpId>::const_iterator it;
+ for(it = parent.AvpsId.begin(); it != parent.AvpsId.end(); it++)
+ leaf = leaf->addAvp(*it);
- return (theFailedAvp->addAvp(avp));
+ leaf->addAvp(wrong);
}
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(
int i_aux;
unsigned int u_aux;
+ // Clear the message
+ clear();
+
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;
throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
}
- setId(stackCommand->getId());
+ setId(stackCommand->getId(), false /* don't clear */);
// '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
- u_aux = appid->getIntegerValue();
-
- /*
- if(u_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(u_aux);
-
// Hob-by-hop-id
if(hbh) {
u_aux = hbh->getIntegerValue();
}
try {
- avp = getEngine()->allocateAvp();
+ avp = getEngine()->createAvp(NULL);
avp -> fromXML(*it);
} catch(anna::RuntimeException &ex) {
getEngine()->releaseAvp(avp);
projects / anna.git / blobdiff