// STL
#include <string>
+#include <vector>
using namespace anna;
}
+//------------------------------------------------------------------------------
+//-------------------------------------------------- Message::setApplicationId()
+//------------------------------------------------------------------------------
+void Message::setApplicationId(U32 aid) throw() {
+ a_applicationId = aid;
+
+ // Default behaviour:
+ if (!getEngine()->selectStackWithApplicationId()) 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();
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 */));
+ // This is called before setId, and in general before any operation which needs to know about the stack elements.
+ setApplicationId(DECODE4BYTES_INDX_VALUETYPE(buffer, 8, U32)); // centralize set, because it could be used for stack selection.
- a_applicationId = DECODE4BYTES_INDX_VALUETYPE(buffer, 8, U32);
+ setId(CommandId(code, requestBit() /* based on a_flags */));
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();
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);
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 commenting condition block (*).
+ Avp *theFailedAvp = getAvp(helpers::base::AVPID__Failed_AVP, 1, anna::Exception::Mode::Ignore);
+ if (theFailedAvp) {
+ 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);
}
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))
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));
}
////////////////////
a_version = i_aux;
}
+ // Application-id
+ // This is called before setId, and in general before any operation which needs to know about the stack elements.
+ setApplicationId(appid->getIntegerValue()); // this could set the dictionary...
+
// Dictionary
const stack::Dictionary * dictionary = getEngine()->getDictionary();
const stack::Command *stackCommand = NULL;
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();
projects / anna.git / blobdiff