1 // ANNA - Anna is Not Nothingness Anymore
3 // (c) Copyright 2005-2014 Eduardo Ramos Testillano & Francisco Ruiz Rayo
5 // http://redmine.teslayout.com/projects/anna-suite
7 // Redistribution and use in source and binary forms, with or without
8 // modification, are permitted provided that the following conditions
11 // * Redistributions of source code must retain the above copyright
12 // notice, this list of conditions and the following disclaimer.
13 // * Redistributions in binary form must reproduce the above
14 // copyright notice, this list of conditions and the following disclaimer
15 // in the documentation and/or other materials provided with the
17 // * Neither the name of the copyright holder nor the names of its
18 // contributors may be used to endorse or promote products derived from
19 // this software without specific prior written permission.
21 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 // Authors: eduardo.ramos.testillano@gmail.com
34 // cisco.tierra@gmail.com
38 #include <anna/diameter/codec/Avp.hpp>
39 #include <anna/diameter/codec/Format.hpp>
41 #include <anna/config/defines.hpp> // general types, decoding helpers (DECODE[2/3/4]BYTES_INDX_VALUETYPE), etc.
42 #include <anna/diameter/functions.hpp>
43 #include <anna/diameter/helpers/defines.hpp>
44 #include <anna/diameter/codec/basetypes/basetypes.hpp>
45 #include <anna/diameter/codec/functions.hpp> // REQUIRED_WORDS
46 #include <anna/diameter/codec/OamModule.hpp>
47 #include <anna/diameter/stack/Avp.hpp>
48 #include <anna/diameter/stack/Format.hpp>
49 #include <anna/diameter/stack/Dictionary.hpp>
50 #include <anna/diameter/stack/Engine.hpp>
51 #include <anna/diameter/codec/Engine.hpp>
52 #include <anna/core/functions.hpp>
53 #include <anna/core/util/RegularExpression.hpp>
55 #include <anna/core/tracing/Logger.hpp>
56 #include <anna/core/functions.hpp>
57 #include <anna/core/tracing/TraceMethod.hpp>
58 #include <anna/xml/xml.hpp>
65 using namespace anna::diameter::codec;
74 const int Avp::HeaderLengthVactive(12);
75 const int Avp::HeaderLengthVinactive(8);
76 const U8 Avp::VBitMask(0x80);
77 const U8 Avp::MBitMask(0x40);
78 const U8 Avp::PBitMask(0x20);
83 //------------------------------------------------------------------------------
84 //------------------------------------------------------------------- Avp::Avp()
85 //------------------------------------------------------------------------------
91 //------------------------------------------------------------------------------
92 //------------------------------------------------------------------- Avp::Avp()
93 //------------------------------------------------------------------------------
100 //------------------------------------------------------------------------------
101 //------------------------------------------------------------------ Avp::~Avp()
102 //------------------------------------------------------------------------------
108 //------------------------------------------------------------------------------
109 //------------------------------------------------------------- Avp::getEngine()
110 //------------------------------------------------------------------------------
111 Engine * Avp::getEngine() const throw(anna::RuntimeException) {
112 return a_engine ? a_engine : (a_engine = anna::functions::component <Engine> (ANNA_FILE_LOCATION));
116 //------------------------------------------------------------------------------
117 //------------------------------------------------------------ Avp::initialize()
118 //------------------------------------------------------------------------------
119 void Avp::initialize() throw() {
121 a_id = helpers::AVPID__AVP; // (0,0)
123 a_insertionPositionForChilds = 0;
124 a_OctetString = NULL;
135 a_DiameterIdentity = NULL;
136 a_DiameterURI = NULL;
138 a_IPFilterRule = NULL;
139 a_QoSFilterRule = NULL;
142 /////////////////////
143 // Format specific //
144 /////////////////////
145 initializeByFormat();
149 //------------------------------------------------------------------------------
150 //----------------------------------------------------------------- Avp::clear()
151 //------------------------------------------------------------------------------
152 void Avp::clear() throw(anna::RuntimeException) {
153 delete a_OctetString;
161 for(avp_iterator it = avp_begin(); it != avp_end(); it++) { /*avp(it)->clear(); */getEngine()->releaseAvp(avp(it)); }
167 delete a_DiameterIdentity;
168 delete a_DiameterURI;
170 delete a_IPFilterRule;
171 delete a_QoSFilterRule;
175 /////////////////////
176 // Format specific //
177 /////////////////////
184 //------------------------------------------------------------------------------
185 //-------------------------------------------------------------- Avp::avp_find()
186 //------------------------------------------------------------------------------
187 avp_iterator Avp::avp_find(avp_container &avps, AvpId id, unsigned int position) throw() {
191 for(avp_iterator it = avps.begin(); it != avps.end(); it++) {
194 if(aux && (aux->getId() == id)) {
197 if(match == position) return it;
205 //------------------------------------------------------------------------------
206 //---------------------------------------------------------------- Avp::addAvp()
207 //------------------------------------------------------------------------------
208 Avp * Avp::addAvp(avp_container &avps, int &insertionPositionForChilds, AvpId id, Engine *engine) throw() {
209 Avp * result = engine->allocateAvp();
211 addChild(avps, insertionPositionForChilds, result);
216 //------------------------------------------------------------------------------
217 //------------------------------------------------------------- Avp::removeAvp()
218 //------------------------------------------------------------------------------
219 bool Avp::removeAvp(avp_container &avps, find_container &finds, AvpId id, int ocurrence, Engine *engine) throw() {
220 bool removed = false;
221 bool do_remove = true;
222 int position = ocurrence;
224 if(position < 0) { /* reversed access */
225 position = countAvp(avps, id) + 1 + position;
227 // Special cases -> 0 and negative results:
228 // (1) User wants to remove the last, but no avp is found: position = 0 + 1 - 1 = 0 (would removes all but, no avp will be found: return now)
229 // (2) User wants to remove some intermediate avp, i.e. '-5', but only 4 avps are found: 4 + 1 - 5 = 0 (would removes all !!!: return to avoid unexpected behaviour)
230 // (2) User wants to remove some intermediate avp, i.e. '-5', but only 3 avps are found: 3 + 1 - 5 = -1 (can't find negative positions ...)
231 if(position <= 0) do_remove = false;
235 int n = position ? position : 1 /* will search always the first and remove, the first and remove, the first and remove ... */;
238 while((it = avp_find(avps, id, n)) != avps.end()) {
239 engine->releaseAvp((*it).second);
248 // Cache system reset (remove will invalidate cached findings):
251 const stack::Avp *stackAvp = getStackAvp(id, engine);
252 std::string msg = "Removed Avp "; msg += stackAvp ? (stackAvp->getName()) : (anna::diameter::functions::avpIdAsPairString(id));
253 msg += anna::functions::asString(" with provided ocurrence (%d)", ocurrence);
254 anna::Logger::debug(msg, ANNA_FILE_LOCATION);
258 const stack::Avp *stackAvp = getStackAvp(id, engine);
259 std::string msg = "Can't found Avp "; msg += stackAvp ? (stackAvp->getName()) : (anna::diameter::functions::avpIdAsPairString(id));
260 msg += anna::functions::asString(" with provided ocurrence (%d), in order to be removed", ocurrence);
261 anna::Logger::debug(msg, ANNA_FILE_LOCATION);
269 //------------------------------------------------------------------------------
270 //-------------------------------------------------------------- Avp::countAvp()
271 //------------------------------------------------------------------------------
272 int Avp::countAvp(const avp_container &avps, AvpId id) throw() {
274 const_avp_iterator it;
276 while((it = avp_find(avps, id, result + 1)) != avps.end()) result++;
282 //------------------------------------------------------------------------------
283 //-------------------------------------------------------------- Avp::firstAvp()
284 //------------------------------------------------------------------------------
285 const Avp* Avp::firstAvp(const avp_container &avps, AvpId id) throw() {
286 const_avp_iterator it = avp_find(avps, id, 1);
295 //------------------------------------------------------------------------------
296 //----------------------------------------------------------- Avp::countChilds()
297 //------------------------------------------------------------------------------
298 int Avp::countChilds(const avp_container &avps) throw() {
303 //------------------------------------------------------------------------------
304 //---------------------------------------------------------------- Avp::getAvp()
305 //------------------------------------------------------------------------------
306 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) {
308 LOGDEBUG(anna::Logger::debug("Ocurrence number zero has no sense. NULL returned.", ANNA_FILE_LOCATION));
312 bool do_search = true;
314 int position = ocurrence;
316 if(position < 0) { /* reversed access */
317 position = countAvp(avps, id) + 1 + position;
319 // Special cases -> 0 and negative results:
320 // (1) User wants to get the last, but no avp is found: position = 0 + 1 - 1 = 0 (can't find 0-position ...)
321 // (2) User wants to get some intermediate avp, i.e. '-5', but only 4 avps are found: 4 + 1 - 5 = 0 (can't find 0-position ...)
322 // (2) User wants to get some intermediate avp, i.e. '-5', but only 3 avps are found: 3 + 1 - 5 = -1 (can't find negative positions ...)
323 if(position <= 0) do_search = false;
326 const Avp * result = NULL;
329 // Search at cache finds:
330 find_key key(id, position);
331 find_iterator fit = finds.find(key);
332 cached = (fit != finds.end());
335 result = (*fit).second;
337 const_avp_iterator it = avp_find(avps, id, position);
339 if(it != avps.end()) {
340 result = (*it).second;
341 finds[key] = const_cast<Avp*>(result); // store in cache
349 const stack::Avp *stackAvp = getStackAvp(id, engine);
350 std::string msg = "Found Avp "; msg += stackAvp ? (stackAvp->getName()) : (anna::diameter::functions::avpIdAsPairString(id));
351 msg += anna::functions::asString(" with provided ocurrence (%d) which was ", ocurrence);
352 msg += cached ? "already cached:\n" : "the first search, now cached:\n";
353 msg += result->asXMLString();
354 anna::Logger::debug(msg, ANNA_FILE_LOCATION);
361 case anna::Exception::Mode::Throw: {
362 const stack::Avp *stackAvp = getStackAvp(id, engine);
363 std::string msg = "Can't found Avp "; msg += stackAvp ? (stackAvp->getName()) : (anna::diameter::functions::avpIdAsPairString(id));
364 msg += anna::functions::asString(" with provided ocurrence (%d)", ocurrence);
365 throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
368 case anna::Exception::Mode::Trace: {
370 const stack::Avp *stackAvp = getStackAvp(id, engine);
371 std::string msg = "Can't found Avp "; msg += stackAvp ? (stackAvp->getName()) : (anna::diameter::functions::avpIdAsPairString(id));
372 msg += anna::functions::asString(" with provided ocurrence (%d)", ocurrence);
373 anna::Logger::warning(msg, ANNA_FILE_LOCATION);
377 case anna::Exception::Mode::Ignore: {
379 const stack::Avp *stackAvp = getStackAvp(id, engine);
380 std::string msg = "Can't found Avp "; msg += stackAvp ? (stackAvp->getName()) : (anna::diameter::functions::avpIdAsPairString(id));
381 msg += anna::functions::asString(" with provided ocurrence (%d)", ocurrence);
382 anna::Logger::debug(msg, ANNA_FILE_LOCATION);
392 //------------------------------------------------------------------------------
393 //--------------------------------------------------------------- Avp::_getAvp()
394 //------------------------------------------------------------------------------
395 const Avp *Avp::_getAvp(AvpId id, int ocurrence, anna::Exception::Mode::_v emode) const throw(anna::RuntimeException) {
396 // Dictionary stack avp and format (this):
397 const stack::Avp *stackAvp = getStackAvp();
398 const stack::Format *stackFormat = stackAvp ? (stackAvp->getFormat()) : NULL /*Unknown*/;
400 if(!stackFormat || !stackFormat->isGrouped())
401 throw anna::RuntimeException("This method only applies over grouped avps.", ANNA_FILE_LOCATION);
403 return getAvp(a_avps, (find_container&)a_finds, id, ocurrence, getEngine(), emode);
407 //------------------------------------------------------------------------------
408 //---------------------------------------------------------- Avp::assertFormat()
409 //------------------------------------------------------------------------------
410 void Avp::assertFormat(const std::string &name) const throw(anna::RuntimeException) {
411 // Dictionary stack avp and format:
412 const stack::Avp *stackAvp = getStackAvp();
413 const stack::Format *stackFormat = stackAvp ? (stackAvp->getFormat()) : NULL /*Unknown*/;
414 std::string format = stackFormat ? stackFormat->getName() : "Unknown";
417 std::string msg = "The Avp ";
418 msg += anna::diameter::functions::avpIdAsPairString(a_id);
419 msg += " with format '";
421 msg += "' is not compatible with the API method used (";
424 throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
429 //------------------------------------------------------------------------------
430 //--------------------------------------------------------------- Avp::flagsOK()
431 //------------------------------------------------------------------------------
432 bool Avp::flagsOK() const throw() {
433 // Dictionary stack avp:
434 const stack::Avp *stackAvp = getStackAvp();
437 anna::Logger::error("Impossible to decide if flags are correct because stack avp is not identified. Assume flags ok", ANNA_FILE_LOCATION);
442 bool Vnone = (stackAvp->getVbit() == stack::Avp::FlagRule::None);
444 bool Vmust = (stackAvp->getVbit() == stack::Avp::FlagRule::must);
446 bool Vmustnot = (stackAvp->getVbit() == stack::Avp::FlagRule::mustnot);
448 bool Mnone = (stackAvp->getMbit() == stack::Avp::FlagRule::None);
450 bool Mmust = (stackAvp->getMbit() == stack::Avp::FlagRule::must);
452 bool Mmustnot = (stackAvp->getMbit() == stack::Avp::FlagRule::mustnot);
454 bool Pnone = (stackAvp->getPbit() == stack::Avp::FlagRule::None);
456 bool Pmust = (stackAvp->getPbit() == stack::Avp::FlagRule::must);
458 bool Pmustnot = (stackAvp->getPbit() == stack::Avp::FlagRule::mustnot);
461 if((Vnone && Mnone && Pnone && vendorBit()) || (Vmust && !vendorBit()) || (Vmustnot && vendorBit())) {
462 anna::Logger::error("Vendor Bit (V) incoherence found", ANNA_FILE_LOCATION);
466 // Exit on permissive mode:
467 if(getEngine()->ignoreFlagsOnValidation()) return true; // Ignore checking for AVP 'M' & 'P' bits
470 if((Mmust && !mandatoryBit()) || (Mmustnot && mandatoryBit())) {
471 anna::Logger::error("Mandatory Bit (M) incoherence found", ANNA_FILE_LOCATION);
476 if((Pmust && !encryptionBit()) || (Pmustnot && encryptionBit())) {
477 anna::Logger::error("Encryption Bit (P) incoherence found", ANNA_FILE_LOCATION);
482 if((a_flags & 0x1f) != 0x00) {
483 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);
491 //------------------------------------------------------------------------------
492 //----------------------------------------------------------------- Avp::setId()
493 //------------------------------------------------------------------------------
494 void Avp::setId(AvpId id) throw(anna::RuntimeException) {
495 // Generic AVP assignment has no sense
496 if(id == helpers::AVPID__AVP) return;
498 // Clear class content:
502 // Dictionary stack avp and format:
503 const stack::Avp *stackAvp = getStackAvp(); // based on dictionary and a_id
504 const stack::Format *stackFormat = stackAvp ? (stackAvp->getFormat()) : NULL /*Unknown*/;
506 // Dictionary flags for known types:
508 if(stackAvp->getVbit() == stack::Avp::FlagRule::must) a_flags |= VBitMask;
510 if(stackAvp->getMbit() == stack::Avp::FlagRule::must) a_flags |= MBitMask;
512 if(stackAvp->getPbit() == stack::Avp::FlagRule::must) a_flags |= PBitMask;
514 if(a_id.second != 0) a_flags |= VBitMask; else a_flags &= (~VBitMask);
517 if(!stackFormat) { // Unknown Avp
519 std::string msg = "Unknown format for AVP identifier ";
520 msg += anna::diameter::functions::avpIdAsPairString(id);
521 msg += ". Raw data without specific format will be managed";
522 anna::Logger::debug(msg, ANNA_FILE_LOCATION);
524 a_Unknown = new Unknown();
528 // Avp class formats (Avp child classes should implement this source code block for application-specific formats):
529 if(stackFormat->isOctetString()) a_OctetString = new OctetString();
530 else if(stackFormat->isInteger32()) a_Integer32 = new Integer32();
531 else if(stackFormat->isInteger64()) a_Integer64 = new Integer64();
532 else if(stackFormat->isUnsigned32()) a_Unsigned32 = new Unsigned32();
533 else if(stackFormat->isUnsigned64()) a_Unsigned64 = new Unsigned64();
534 else if(stackFormat->isFloat32()) a_Float32 = new Float32();
535 else if(stackFormat->isFloat64()) a_Float64 = new Float64();
536 //else if (stackFormat->isGrouped())
537 else if(stackFormat->isAddress()) a_Address = new Address();
538 else if(stackFormat->isTime()) a_Time = new Time();
539 else if(stackFormat->isUTF8String()) a_UTF8String = new UTF8String();
540 else if(stackFormat->isDiameterIdentity()) a_DiameterIdentity = new DiameterIdentity();
541 else if(stackFormat->isDiameterURI()) a_DiameterURI = new DiameterURI();
542 else if(stackFormat->isEnumerated()) a_Enumerated = new Enumerated();
543 else if(stackFormat->isIPFilterRule()) a_IPFilterRule = new IPFilterRule();
544 else if(stackFormat->isQoSFilterRule()) a_QoSFilterRule = new QoSFilterRule();
546 /////////////////////
547 // Format specific //
548 /////////////////////
549 allocationByFormat(stackFormat);
553 //------------------------------------------------------------------------------
554 //----------------------------------------------------------------- Avp::setId()
555 //------------------------------------------------------------------------------
556 void Avp::setId(const char *name) throw(anna::RuntimeException) {
557 setId(getEngine()->avpIdForName(name));
561 //------------------------------------------------------------------------------
562 //---------------------------------------------------------------- Avp::addAvp()
563 //------------------------------------------------------------------------------
564 Avp * Avp::addAvp(const char *name) throw(anna::RuntimeException) {
565 return addAvp(getEngine()->avpIdForName(name));
569 //------------------------------------------------------------------------------
570 //------------------------------------------------------------- Avp::removeAvp()
571 //------------------------------------------------------------------------------
572 bool Avp::removeAvp(const char *name, int ocurrence) throw(anna::RuntimeException) {
573 return removeAvp(getEngine()->avpIdForName(name), ocurrence);
577 //------------------------------------------------------------------------------
578 //--------------------------------------------------------------- Avp::_getAvp()
579 //------------------------------------------------------------------------------
580 const Avp *Avp::_getAvp(const char *name, int ocurrence, anna::Exception::Mode::_v emode) const throw(anna::RuntimeException) {
581 return getAvp(getEngine()->avpIdForName(name), ocurrence, emode);
585 //------------------------------------------------------------------------------
586 //-------------------------------------------------------------- Avp::countAvp()
587 //------------------------------------------------------------------------------
588 int Avp::countAvp(const char *name) const throw(anna::RuntimeException) {
589 return countAvp(getEngine()->avpIdForName(name));
592 //------------------------------------------------------------------------------
593 //------------------------------------------------------------- Avp::getLength()
594 //------------------------------------------------------------------------------
595 U24 Avp::getLength() const throw() {
598 const stack::Avp *stackAvp = getStackAvp();
599 const stack::Format *stackFormat = stackAvp ? (stackAvp->getFormat()) : NULL /*Unknown*/;
601 result = vendorBit() ? HeaderLengthVactive : HeaderLengthVinactive;
604 result += a_Unknown->getSize();
608 if(stackFormat->isOctetString()) result += a_OctetString->getSize();
609 else if(stackFormat->isInteger32()) result += a_Integer32->getSize();
610 else if(stackFormat->isInteger64()) result += a_Integer64->getSize();
611 else if(stackFormat->isUnsigned32()) result += a_Unsigned32->getSize();
612 else if(stackFormat->isUnsigned64()) result += a_Unsigned64->getSize();
613 else if(stackFormat->isFloat32()) result += a_Float32->getSize();
614 else if(stackFormat->isFloat64()) result += a_Float64->getSize();
615 else if(stackFormat->isGrouped()) for(const_avp_iterator it = avp_begin(); it != avp_end(); it++) result += 4 * REQUIRED_WORDS(avp(it)->getLength());
616 else if(stackFormat->isAddress()) result += a_Address->getSize();
617 else if(stackFormat->isTime()) result += a_Time->getSize();
618 else if(stackFormat->isUTF8String()) result += a_UTF8String->getSize();
619 else if(stackFormat->isDiameterIdentity()) result += a_DiameterIdentity->getSize();
620 else if(stackFormat->isDiameterURI()) result += a_DiameterURI->getSize();
621 else if(stackFormat->isEnumerated()) result += a_Enumerated->getSize();
622 else if(stackFormat->isIPFilterRule()) result += a_IPFilterRule->getSize();
623 else if(stackFormat->isQoSFilterRule()) result += a_QoSFilterRule->getSize();
625 /////////////////////
626 // Format specific //
627 /////////////////////
628 result += getLengthByFormat(stackFormat);
633 //------------------------------------------------------------------------------
634 //-------------------------------------------- Avp::unknownAvpWithMandatoryBit()
635 //------------------------------------------------------------------------------
636 void Avp::unknownAvpWithMandatoryBit() const throw(anna::RuntimeException) {
637 OamModule &oamModule = OamModule::instantiate();
638 const char *c_aid = STRING_WITH_QUOTATION_MARKS__C_STR(anna::diameter::functions::avpIdAsPairString(a_id));
639 oamModule.activateAlarm(OamModule::Alarm::AvpDecode__UnknownAvp__s__WithMandatoryBit, c_aid);
640 oamModule.count(OamModule::Counter::AvpDecode__UnknownAvpWithMandatoryBit);
642 std::string msg = anna::functions::asString("Detected unknown Avp %s with mandatory bit activated", c_aid);
643 anna::Logger::warning(msg, ANNA_FILE_LOCATION);
647 //------------------------------------------------------------------------------
648 //-------------------------------------------------------- Avp::decodeDataPart()
649 //------------------------------------------------------------------------------
650 void Avp::decodeDataPart(const char * buffer, int size, const parent_t & parent, Message *answer) throw(anna::RuntimeException) {
652 OamModule &oamModule = OamModule::instantiate();
653 // Dictionary stack avp and format:
654 const stack::Avp *stackAvp = getStackAvp();
655 const stack::Format *stackFormat = stackAvp ? (stackAvp->getFormat()) : NULL /*Unknown*/;
658 a_Unknown->decode(buffer, size);
662 if(stackFormat->isOctetString()) a_OctetString->decode(buffer, size);
663 else if(stackFormat->isInteger32()) a_Integer32->decode(buffer, size);
664 else if(stackFormat->isInteger64()) a_Integer64->decode(buffer, size);
665 else if(stackFormat->isUnsigned32()) a_Unsigned32->decode(buffer, size);
666 else if(stackFormat->isUnsigned64()) a_Unsigned64->decode(buffer, size);
667 else if(stackFormat->isFloat32()) a_Float32->decode(buffer, size);
668 else if(stackFormat->isFloat64()) a_Float64->decode(buffer, size);
669 else if(stackFormat->isGrouped()) {
671 LOGDEBUG(anna::Logger::debug("Grouped Avp has empty data part", ANNA_FILE_LOCATION));
675 if((size % 4) != 0) {
676 oamModule.activateAlarm(OamModule::Alarm::AvpDecode__IncorrectLength);
677 oamModule.count(OamModule::Counter::AvpDecode__IncorrectLength);
680 answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_INVALID_AVP_LENGTH);
681 answer->setFailedAvp(parent, a_id);
684 throw anna::RuntimeException("Avp format error, the avp length is incorrect (must be multiple of 4 on grouped type)", ANNA_FILE_LOCATION);
692 parent_t me = parent;
695 while(avpPos < size) {
697 avp = getEngine()->allocateAvp();
698 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) */);
699 avp -> decode(db, me, answer);
700 } catch(anna::RuntimeException &ex) {
701 getEngine()->releaseAvp(avp);
706 avpPos += 4 * REQUIRED_WORDS(avp->getLength());
708 } else if(stackFormat->isAddress()) a_Address->decode(buffer, size);
709 else if(stackFormat->isTime()) a_Time->decode(buffer, size);
710 else if(stackFormat->isUTF8String()) a_UTF8String->decode(buffer, size);
711 else if(stackFormat->isDiameterIdentity()) a_DiameterIdentity->decode(buffer, size);
712 else if(stackFormat->isDiameterURI()) a_DiameterURI->decode(buffer, size);
713 else if(stackFormat->isEnumerated()) a_Enumerated->decode(buffer, size);
714 else if(stackFormat->isIPFilterRule()) a_IPFilterRule->decode(buffer, size);
715 else if(stackFormat->isQoSFilterRule()) a_QoSFilterRule->decode(buffer, size);
717 /////////////////////
718 // Format specific //
719 /////////////////////
720 decodeDataPartByFormat(buffer, size, stackFormat);
723 //------------------------------------------------------------------------------
724 //---------------------------------------------------------------- Avp::decode()
725 //------------------------------------------------------------------------------
726 void Avp::decode(const anna::DataBlock &db, const parent_t & parent, Message *answer) throw(anna::RuntimeException) {
728 OamModule &oamModule = OamModule::instantiate();
730 if(db.getSize() < HeaderLengthVinactive) {
731 oamModule.activateAlarm(OamModule::Alarm::AvpDecode__NotEnoughBytesToCoverAvpHeaderLength);
732 oamModule.count(OamModule::Counter::AvpDecode__NotEnoughBytesToCoverAvpHeaderLength);
733 // DIAMETER_INVALID_AVP_LENGTH; // no podr� construir un avp fiable, as� que no registro el result-code
734 throw anna::RuntimeException("Not enough bytes to cover avp header length", ANNA_FILE_LOCATION);
737 const char * buffer = db.getData();
740 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
741 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
743 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
744 // | AVP Flags | AVP Length |
745 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
746 // | Vendor-ID (opt) |
747 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
750 // Code flags and vendor-id
751 U32 code = DECODE4BYTES_INDX_VALUETYPE(buffer, 0, U32);
753 a_flags = (S8)buffer[4];
755 U32 vendorID = helpers::VENDORID__base;
758 if(db.getSize() < HeaderLengthVactive) {
759 oamModule.activateAlarm(OamModule::Alarm::AvpDecode__NotEnoughBytesToCoverAvpHeaderLength);
760 oamModule.count(OamModule::Counter::AvpDecode__NotEnoughBytesToCoverAvpHeaderLength);
761 // DIAMETER_INVALID_AVP_LENGTH; // no podr� construir un avp fiable, as� que no registro el result-code
762 throw anna::RuntimeException(anna::functions::asString("Not enough bytes to cover avp header length (avp code = %u)", code), ANNA_FILE_LOCATION);
765 vendorID = DECODE4BYTES_INDX_VALUETYPE(buffer, 8, U32);
767 if(vendorID == helpers::VENDORID__base) {
768 // A vendor ID value of zero (0) corresponds to the IETF adopted AVP
769 // values, as managed by the IANA. Since the absence of the vendor
770 // ID field implies that the AVP in question is not vendor specific,
772 // implementations MUST NOT use the zero (0) vendor ID.
773 oamModule.activateAlarm(OamModule::Alarm::AvpDecode__IncoherenceBetweenActivatedVBitAndZeroedVendorIDValueReceived);
774 oamModule.count(OamModule::Counter::AvpDecode__IncoherenceBetweenActivatedVBitAndZeroedVendorIDValueReceived);
775 throw anna::RuntimeException(anna::functions::asString("Incoherence between activated V bit and zeroed vendor-id value received (avp code = %u)", code), ANNA_FILE_LOCATION);
780 setId(AvpId(code, vendorID));
781 // Flags could have been updated regarding dictionary, but during decoding we must respect buffer received:
782 a_flags = (S8)buffer[4];
784 // Here i know id and flags:
785 // 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
786 // a Diameter client, server, proxy, or translation agent and either the AVP or its value is unrecognized, the message MUST be rejected.
787 // Diameter Relay and redirect agents MUST NOT reject messages with unrecognized AVPs.
788 if(!getStackAvp() && mandatoryBit()) {
791 answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_AVP_UNSUPPORTED);
792 answer->setFailedAvp(parent, a_id);
795 unknownAvpWithMandatoryBit();
799 U24 length = DECODE3BYTES_INDX_VALUETYPE(buffer, 5, U24);
800 // Data start position:
801 int startDataPos = vendorBit() ? HeaderLengthVactive : HeaderLengthVinactive;
803 int dataBytes = length - startDataPos;
806 oamModule.activateAlarm(OamModule::Alarm::AvpDecode__IncorrectLength);
807 oamModule.count(OamModule::Counter::AvpDecode__IncorrectLength);
810 answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_INVALID_AVP_LENGTH);
811 answer->setFailedAvp(parent, a_id);
814 throw anna::RuntimeException(anna::functions::asString("Avp format error, the avp length is incorrect (avp code = %u)", code), ANNA_FILE_LOCATION);
818 decodeDataPart(buffer + startDataPos, dataBytes, parent, answer);
819 } catch(anna::RuntimeException &ex) {
820 oamModule.activateAlarm(OamModule::Alarm::AvpDecode__DataPartInconsistence);
821 oamModule.count(OamModule::Counter::AvpDecode__DataPartInconsistence);
824 answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_INVALID_AVP_VALUE);
825 answer->setFailedAvp(parent, a_id);
828 throw anna::RuntimeException(anna::functions::asString("Internal Avp decoding error (avp code = %u): %s", code, ex.getText().c_str()), ANNA_FILE_LOCATION);
833 //------------------------------------------------------------------------------
834 //----------------------------------------------------------- Avp::getStackAvp()
835 //------------------------------------------------------------------------------
836 const anna::diameter::stack::Avp *Avp::getStackAvp(AvpId id, Engine *engine) throw() {
837 const stack::Dictionary * dictionary = engine->getDictionary();
838 return (dictionary ? (dictionary->getAvp(id)) : NULL);
842 //------------------------------------------------------------------------------
843 //------------------------------------------------------------------- Avp::fix()
844 //------------------------------------------------------------------------------
845 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() {
847 if(avps.size() == 0) return; // empty content, nothing to fix
849 if(ruleBegin == ruleEnd) return; // no reference. Cannot fix
851 // Copy reference container and clear internal map in order to build a fixed version:
852 avp_container unfixedAvps;
854 for(const_avp_iterator it = avps.begin(); it != avps.end(); it++)
855 unfixedAvps[(*it).first] = (*it).second;
858 // Cache system reset (fix probably will invalidate cached findings):
860 insertionPositionForChilds = 0;
864 for(anna::diameter::stack::const_avprule_iterator rule_it = ruleBegin; rule_it != ruleEnd; rule_it++) {
865 while((avp_it = Avp::avp_find(unfixedAvps, (*rule_it).second.getId(), 1)) != unfixedAvps.end()) {
866 avp = (*avp_it).second;
867 addChild(avps, insertionPositionForChilds, avp);
868 unfixedAvps.erase(avp_it); // processed
872 // Add remaining avps:
873 for(avp_it = unfixedAvps.begin(); avp_it != unfixedAvps.end(); avp_it++) {
874 avp = (*avp_it).second;
876 if(avp) addChild(avps, insertionPositionForChilds, avp);
880 for(avp_iterator it = avps.begin(); it != avps.end(); it++) {
883 if(avp->hasChildren()) avp->fix();
888 //------------------------------------------------------------------------------
889 //------------------------------------------------------------------- Avp::fix()
890 //------------------------------------------------------------------------------
891 void Avp::fix() throw() {
892 // Dictionary stack avp:
893 const stack::Avp *stackAvp = getStackAvp();
894 const stack::Format *stackFormat = stackAvp ? (stackAvp->getFormat()) : NULL /*Unknown*/;
897 //LOGDEBUG(anna::Logger::debug("No dictionary avp reference found. Cannot fix.", ANNA_FILE_LOCATION));
901 if(!stackFormat || !stackFormat->isGrouped()) {
902 //LOGDEBUG(anna::Logger::debug("Avp is not grouped. Nothing to fix.", ANNA_FILE_LOCATION));
906 fix(a_avps, (find_container&)a_finds, a_insertionPositionForChilds, stackAvp->avprule_begin(), stackAvp->avprule_end());
910 //------------------------------------------------------------------------------
911 //------------------------------------------------------------ Avp::validLevel()
912 //------------------------------------------------------------------------------
913 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) {
916 OamModule &oamModule = OamModule::instantiate();
922 const_avp_iterator avp_it = avps.begin();
923 anna::diameter::stack::const_avprule_iterator rule_it;
926 for(rule_it = ruleBegin; rule_it != ruleEnd; rule_it++) {
929 if((*rule_it).second.isFixed()) {
930 if(avps.size() == 0) break; // cardinality checking will show this anomaly
932 if(avp_it != avps.end()) {
933 id = Avp::avp(avp_it)->getId();
935 if(id != (*rule_it).second.getId()) {
937 // Missing fixed rule: %s
938 } else if(Avp::avp_find(avps, id, 2) != avps.end()) {
940 // More than one fixed ocurrency for rule %s (*)
944 // (*) for (int k = 0; k < (*rule_it).second.getQualMax(); k++) avp_it++
950 // OAM & Depth management
951 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()));
952 oamModule.count(OamModule::Counter::LevelValidation__MissingFixedRule);
955 answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_MISSING_AVP);
956 answer->setFailedAvp(parent, (*rule_it).second.getId());
959 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())));
961 } else break; // finish fixed
965 // Cardinality // Mandatory control is implicit here
967 anna::diameter::stack::const_avprule_iterator generic_rule_it = ruleEnd;
968 int min, max, amount;
970 for(rule_it = ruleBegin; rule_it != ruleEnd; rule_it++) {
971 if((*rule_it).second.isAny()) { generic_rule_it = rule_it; continue; } // generic Avp will be managed after
973 id = (*rule_it).second.getId();
974 min = (*rule_it).second.getQualMin();
975 max = (*rule_it).second.getQualMax(); // -1 means infinite
976 amount = Avp::countAvp(avps, id);
978 if((amount < min) || ((max != -1) && (amount > max))) {
979 // Failed rule %s for cardinality (found %d items)
981 // OAM & Depth management
982 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()));
983 oamModule.count(OamModule::Counter::LevelValidation__FailedRuleForCardinality);
986 oamModule.count(OamModule::Counter::LevelValidation__FailedRuleForCardinalityLessThanNeeded);
989 answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_MISSING_AVP);
990 answer->setFailedAvp(parent, id);
993 oamModule.count(OamModule::Counter::LevelValidation__FailedRuleForCardinalityMoreThanNeeded);
996 answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_AVP_OCCURS_TOO_MANY_TIMES);
997 answer->setFailedAvp(parent, id);
1001 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())));
1005 bool haveGeneric = (generic_rule_it != ruleEnd);
1010 std::map < AvpId, int /* dummy */ > disregarded; // 'Disregardeds' are Avps not in rules list
1011 std::map < AvpId, int /* dummy */ >::const_iterator disregarded_it;
1013 for(avp_it = avps.begin(); avp_it != avps.end(); avp_it++) {
1014 id = Avp::avp(avp_it)->getId();
1015 // Find rule for the child:
1016 foundInRules = false;
1018 for(rule_it = ruleBegin; rule_it != ruleEnd; rule_it++) {
1019 if((*rule_it).second.getId() == id) {
1020 foundInRules = true;
1026 disregarded[id] = 0;
1030 // Generic AVP cardinality checkings
1031 int disregardeds = disregarded.size();
1034 min = (*generic_rule_it).second.getQualMin();
1035 max = (*generic_rule_it).second.getQualMax(); // -1 means infinite
1036 amount = disregardeds;
1038 if((amount < min) || ((max != -1) && (amount > max))) {
1039 // Failed Generic AVP rule %s for cardinality (found %d disregarded items inside %s)
1041 // OAM & Depth management
1042 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()));
1043 oamModule.count(OamModule::Counter::LevelValidation__FailedGenericAvpRuleForCardinalityFoundDisregardedItem);
1046 answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_AVP_NOT_ALLOWED);
1047 answer->setFailedAvp(parent, id); // NO SENSE... what to put ?
1050 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())));
1052 } else if(disregardeds) { // When Generic AVP missing, no disregarded Avps are allowed
1053 // Found %d disregarded items inside %s and Generic AVP was not specified
1055 // Build disregarded list as string (unknown as avp id pair):
1056 std::string s_disregardeds = "";
1057 const stack::Avp *stackAvp;
1059 for(disregarded_it = disregarded.begin(); disregarded_it != disregarded.end(); disregarded_it++) {
1060 id = (*disregarded_it).first;
1061 stackAvp = getStackAvp(id, engine);
1062 s_disregardeds += (stackAvp ? (stackAvp->getName()) : (anna::diameter::functions::avpIdAsPairString(id)));
1063 s_disregardeds += ", ";
1065 // We wouldn't know where are these disregarded, but...
1067 answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_AVP_NOT_ALLOWED);
1068 answer->setFailedAvp(parent, id);
1072 s_disregardeds.erase(s_disregardeds.size() - 2, 2); // remove last ', '
1073 // OAM & Depth management
1074 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));
1075 oamModule.count(OamModule::Counter::LevelValidation__FoundDisregardedItemsAndGenericAVPWasNotSpecified);
1076 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)));
1083 //------------------------------------------------------------------------------
1084 //----------------------------------------------------------------- Avp::valid()
1085 //------------------------------------------------------------------------------
1086 bool Avp::valid(const parent_t & parent, Message *answer) const throw(anna::RuntimeException) {
1088 OamModule &oamModule = OamModule::instantiate();
1089 // Dictionary stack avp:
1090 const stack::Avp *stackAvp = getStackAvp();
1091 const stack::Format *stackFormat = stackAvp ? (stackAvp->getFormat()) : NULL /*Unknown*/;
1094 // No dictionary avp reference found. Cannot validate
1095 return true; // perhaps a unknown Avp
1099 parent_t me = parent;
1100 me.addAvp(a_id, stackAvp->getName().c_str());
1103 // No format avp reference found. Cannot validate
1104 return true; // perhaps a unknown Avp
1107 //////////////////////////////
1108 // Flags coherence checking //
1109 //////////////////////////////
1110 bool result = flagsOK();
1113 // OAM & Depth management
1114 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()));
1115 oamModule.count(OamModule::Counter::AvpValidation__AvpFlagsDoesNotFulfillTheDefinedFlagRules);
1118 answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_INVALID_AVP_BITS);
1119 answer->setFailedAvp(parent, a_id, stackAvp->getName().c_str()); // RFC 6733 says nothing about Failed-AVP in this case...
1122 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())));
1125 //////////////////////
1126 // Enumerated range //
1127 //////////////////////
1128 if(stackFormat->isEnumerated()) {
1129 if(!stackAvp->allowEnum(a_Enumerated->getValue())) {
1131 // OAM & Depth management
1132 oamModule.activateAlarm(OamModule::Alarm::AvpValidation__EnumeratedAvp__s__WithValue__d__DoesNotComplyRestriction__s__, STRING_WITH_QUOTATION_MARKS__C_STR(me.asString()), a_Enumerated->getValue(), stackAvp->getEnums());
1133 oamModule.count(OamModule::Counter::AvpValidation__EnumeratedAvpWithValueDoesNotComplyRestriction);
1136 answer->setResultCode(helpers::base::AVPVALUES__Result_Code::DIAMETER_INVALID_AVP_VALUE);
1137 answer->setFailedAvp(parent, a_id, stackAvp->getName().c_str());
1140 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()));
1144 ////////////////////
1145 // Level checking //
1146 ////////////////////
1147 result = Avp::validLevel(a_avps, stackAvp->avprule_begin(), stackAvp->avprule_end(), getEngine(), me, answer) && result;
1149 ////////////////////////
1150 // Childrens checking //
1151 ////////////////////////
1152 if(a_id == helpers::base::AVPID__Failed_AVP) return result; // DON'T VALIDATE CONTENT FOR Failed-AVP, because it won't be valid...
1154 for(const_avp_iterator it = avp_begin(); it != avp_end(); it++)
1155 result = ((*it).second->valid(me, answer)) && result;
1161 //------------------------------------------------------------------------------
1162 //------------------------------------------------------------------ Avp::code()
1163 //------------------------------------------------------------------------------
1164 void Avp::code(char* buffer, int &size) const throw(anna::RuntimeException) {
1166 buffer[0] = (S8)(a_id.first >> 24);
1167 buffer[1] = (S8)(a_id.first >> 16);
1168 buffer[2] = (S8)(a_id.first >> 8);
1169 buffer[3] = (S8) a_id.first;
1172 buffer[4] = (S8) a_flags;
1173 buffer[5] = (S8)(size >> 16);
1174 buffer[6] = (S8)(size >> 8);
1175 buffer[7] = (S8) size;
1179 buffer[8] = (S8)(a_id.second >> 24);
1180 buffer[9] = (S8)(a_id.second >> 16);
1181 buffer[10] = (S8)(a_id.second >> 8);
1182 buffer[11] = (S8) a_id.second;
1185 // Data start position:
1186 int startDataPos = vendorBit() ? HeaderLengthVactive : HeaderLengthVinactive;
1188 S8 * dataPart = buffer + startDataPos;
1189 int dataBytes; // not used but could be useful for checking (size - startDataPos)
1191 if(startDataPos == size) {
1192 LOGDEBUG(anna::Logger::debug("There is no data part to encode", ANNA_FILE_LOCATION));
1197 const stack::Avp *stackAvp = getStackAvp();
1198 const stack::Format *stackFormat = stackAvp ? (stackAvp->getFormat()) : NULL /*Unknown*/;
1201 a_Unknown->code(dataPart, dataBytes);
1205 if(stackFormat->isOctetString()) a_OctetString->code(dataPart, dataBytes);
1206 else if(stackFormat->isInteger32()) a_Integer32->code(dataPart, dataBytes);
1207 else if(stackFormat->isInteger64()) a_Integer64->code(dataPart, dataBytes);
1208 else if(stackFormat->isUnsigned32()) a_Unsigned32->code(dataPart, dataBytes);
1209 else if(stackFormat->isUnsigned64()) a_Unsigned64->code(dataPart, dataBytes);
1210 else if(stackFormat->isFloat32()) a_Float32->code(dataPart, dataBytes);
1211 else if(stackFormat->isFloat64()) a_Float64->code(dataPart, dataBytes);
1212 else if(stackFormat->isGrouped()) {
1213 // // Each avp encoding will remain padding octets depending on format. In order to
1214 // // code grouped content (each avp will be multiple of 4) we clean the entire buffer
1215 // // to ensure padding (easier than custom-made for each format):
1216 // memset(dataPart, 0, size - startDataPos);
1217 char *dataPartGrouped = dataPart;
1218 int dataBytesGrouped;
1220 for(const_avp_iterator it = avp_begin(); it != avp_end(); it++) {
1221 avp(it)->code(dataPartGrouped, dataBytesGrouped);
1222 dataPartGrouped = dataPartGrouped + 4 * REQUIRED_WORDS(dataBytesGrouped);
1224 } else if(stackFormat->isAddress()) a_Address->code(dataPart, dataBytes);
1225 else if(stackFormat->isTime()) a_Time->code(dataPart, dataBytes);
1226 else if(stackFormat->isUTF8String()) a_UTF8String->code(dataPart, dataBytes);
1227 else if(stackFormat->isDiameterIdentity()) a_DiameterIdentity->code(dataPart, dataBytes);
1228 else if(stackFormat->isDiameterURI()) a_DiameterURI->code(dataPart, dataBytes);
1229 else if(stackFormat->isEnumerated()) a_Enumerated->code(dataPart, dataBytes);
1230 else if(stackFormat->isIPFilterRule()) a_IPFilterRule->code(dataPart, dataBytes);
1231 else if(stackFormat->isQoSFilterRule()) a_QoSFilterRule->code(dataPart, dataBytes);
1233 /////////////////////
1234 // Format specific //
1235 /////////////////////
1236 codeByFormat(dataPart, stackFormat);
1240 //------------------------------------------------------------------------------
1241 //------------------------------------------------------------ Avp::getXMLdata()
1242 //------------------------------------------------------------------------------
1243 std::string Avp::getXMLdata(bool & isHex, const stack::Format *stackFormat) const throw() {
1244 std::string result = "";
1248 // if (!stackFormat) {
1250 // return a_Unknown->asHexString();
1252 // } catch (anna::RuntimeException &ex) {
1258 return a_Unknown->asHexString(); // el asHexString del OctetString no puede lanzar una excepcion en realidad
1261 // Special case for Address: could launch exception if not printable
1263 if(stackFormat->isAddress()) return a_Address->asPrintableString();
1264 } catch(anna::RuntimeException&) {
1267 return a_Address->asHexString();
1271 if(stackFormat->isOctetString()) {
1273 return a_OctetString->asHexString();
1277 if(stackFormat->isInteger32()) return a_Integer32->asPrintableString();
1279 if(stackFormat->isInteger64()) return a_Integer64->asPrintableString();
1281 if(stackFormat->isUnsigned32()) return a_Unsigned32->asPrintableString();
1283 if(stackFormat->isUnsigned64()) return a_Unsigned64->asPrintableString();
1285 if(stackFormat->isFloat32()) return a_Float32->asPrintableString();
1287 if(stackFormat->isFloat64()) return a_Float64->asPrintableString();
1289 //if (stackFormat->isAddress()) return a_Address->asPrintableString();
1291 if(stackFormat->isTime()) return a_Time->asPrintableString();
1293 if(stackFormat->isUTF8String()) return a_UTF8String->asPrintableString();
1295 if(stackFormat->isDiameterIdentity()) return a_DiameterIdentity->asPrintableString();
1297 if(stackFormat->isDiameterURI()) return a_DiameterURI->asPrintableString();
1299 if(stackFormat->isEnumerated()) return a_Enumerated->asPrintableString();
1301 if(stackFormat->isIPFilterRule()) return a_IPFilterRule->asPrintableString();
1303 if(stackFormat->isQoSFilterRule()) return a_QoSFilterRule->asPrintableString();
1305 /////////////////////
1306 // Format specific //
1307 /////////////////////
1308 return getXMLdataByFormat(isHex, stackFormat);
1309 } catch(anna::RuntimeException &ex) {
1317 //------------------------------------------------------------------------------
1318 //---------------------------------------------------------------- Avp::decode()
1319 //------------------------------------------------------------------------------
1320 void Avp::decode(const anna::DataBlock &db) throw(anna::RuntimeException) {
1323 parent.setMessage(CommandId(0,false), "No-Parent");
1324 decode(db, parent, NULL);
1328 //------------------------------------------------------------------------------
1329 //--------------------------------------------------------------- Avp::fromXML()
1330 //------------------------------------------------------------------------------
1331 void Avp::fromXML(const anna::xml::Node* avpNode) throw(anna::RuntimeException) {
1332 // <!ATTLIST avp id CDATA #IMPLIED code CDATA #IMPLIED vendor-code CDATA #IMPLIED flags CDATA #IMPLIED data CDATA #IMPLIED hex-data CDATA #IMPLIED>
1333 const anna::xml::Attribute *name, *code, *vendorCode, *flags, *data, *hexData;
1334 name = avpNode->getAttribute("name", false /* no exception */);
1335 code = avpNode->getAttribute("code", false /* no exception */);
1336 vendorCode = avpNode->getAttribute("vendor-code", false /* no exception */);
1337 flags = avpNode->getAttribute("flags", false /* no exception */);
1338 data = avpNode->getAttribute("data", false /* no exception */);
1339 hexData = avpNode->getAttribute("hex-data", false /* no exception */);
1341 const stack::Dictionary * dictionary = getEngine()->getDictionary();
1342 const stack::Avp *stackAvp = NULL;
1343 const stack::Format *stackFormat = NULL;
1348 std::string msg = "Error processing avp <name '"; msg += name->getValue();
1349 msg += "'>: no dictionary available. Load one or use <'code' + 'flags' + 'vendorCode'> instead of <'name'>";
1350 throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
1353 stackAvp = dictionary->getAvp(name->getValue());
1356 std::string msg = "Error processing avp <name '"; msg += name->getValue();
1357 msg += "'>: no avp found for this identifier at available dictionary";
1358 throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
1361 stackFormat = stackAvp->getFormat();
1364 // Check attributes exclusiveness
1365 if(name) { // compact mode
1366 if(code || flags || vendorCode) {
1367 std::string msg = "Error processing avp <name '"; msg += name->getValue();
1368 msg += "'>: avp attributes <'code' + 'flags' + 'vendorCode'> are not allowed if <'name'> is provided";
1369 throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
1372 setId(stackAvp->getId());
1374 if(!code || !flags || !vendorCode) {
1375 std::string s_code = code ? code->getValue() : "?";
1376 std::string s_flags = flags ? flags->getValue() : "?";
1377 std::string s_vendorCode = vendorCode ? vendorCode->getValue() : "?";
1378 std::string msg = "Error processing avp <code '"; msg += s_code;
1379 msg += "' + flags '"; msg += s_flags;
1380 msg += "' + vendorCode '"; msg += s_vendorCode;
1381 msg += "'>: all must be provided if <'name'> don't";
1382 throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
1386 int i_aux = code->getIntegerValue();
1389 std::string msg = "Error processing avp <code '"; msg += code->getValue();
1390 msg += "': negative values are not allowed";
1391 throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
1396 i_aux = flags->getIntegerValue();
1398 if(i_aux < 0 || i_aux > 256) {
1399 std::string msg = "Error processing avp <flags '"; msg += flags->getValue();
1400 msg += "': out of range [0,256]";
1401 throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
1405 int flagsBCK = a_flags;
1406 // VendorCode checks
1407 i_aux = vendorCode->getIntegerValue();
1410 std::string msg = "Error processing avp <vendorCode '"; msg += vendorCode->getValue();
1411 msg += "': negative values are not allowed";
1412 throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
1415 U32 u_vendorCode = i_aux;
1416 bool vendorSpecific1 = (u_vendorCode != 0);
1417 bool vendorSpecific2 = (((a_flags) & VBitMask) != 0x00);
1419 if(vendorSpecific1 != vendorSpecific2) {
1420 std::string msg = "Error processing avp <vendorCode '"; msg += vendorCode->getValue();
1421 msg += "' and avp <flags '"; msg += flags->getValue();
1422 msg += "': incompatible vendor-specific properties";
1423 throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
1426 // Final assignments
1427 setId(AvpId(u_code, u_vendorCode));
1428 // Flags could have been updated regarding dictionary, but during parsing we must respect xml file:
1430 stackAvp = getStackAvp();
1431 stackFormat = stackAvp ? stackAvp->getFormat() : NULL;
1435 // Check if grouped not confirmed
1436 anna::xml::Node::const_child_iterator it;
1437 anna::xml::Node::const_child_iterator minii = avpNode->child_begin();
1438 anna::xml::Node::const_child_iterator maxii = avpNode->child_end();
1439 const bool hasChildren(minii != maxii);
1442 // We need to confirm is grouped
1444 throw anna::RuntimeException("An xml avp node with children nodes could not confirmed as Grouped", ANNA_FILE_LOCATION);
1446 if(!stackFormat->isGrouped())
1447 throw anna::RuntimeException("An xml avp node with children nodes is not grouped type", ANNA_FILE_LOCATION);
1450 throw anna::RuntimeException("An xml avp node with children nodes has 'data' or 'hex-data' field", ANNA_FILE_LOCATION);
1454 std::string s_avp = name ? (name->getValue()) : (anna::diameter::functions::avpIdAsPairString(a_id));
1456 if(data && hexData) {
1457 std::string msg = "Not allowed both 'data' and 'hex-data' definitions. Avp ";
1459 throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
1463 bool unknown = !stackFormat;
1464 bool octetString = stackFormat && (stackFormat->isOctetString());
1466 if(data && (unknown || octetString)) {
1467 std::string msg = "Not recommended 'data' field at ";
1468 msg += unknown ? "Unknown" : "OctetString";
1469 msg += "-format Avp "; msg += s_avp;
1470 msg += ". Use better 'hex-data' or omit content fields if empty";
1471 anna::Logger::warning(msg, ANNA_FILE_LOCATION);
1476 if(data) a_Unknown->fromPrintableString(data->getValue().c_str());
1477 else if(hexData) a_Unknown->fromHexString(hexData->getValue());
1482 if(stackFormat->isOctetString()) {
1483 if(data) a_OctetString->fromPrintableString(data->getValue().c_str());
1484 else if(hexData) a_OctetString->fromHexString(hexData->getValue());
1485 } else if(stackFormat->isInteger32()) {
1486 if(data) a_Integer32->fromPrintableString(data->getValue().c_str());
1487 else if(hexData) a_Integer32->fromHexString(hexData->getValue());
1488 } else if(stackFormat->isInteger64()) {
1489 if(data) a_Integer64->fromPrintableString(data->getValue().c_str());
1490 else if(hexData) a_Integer64->fromHexString(hexData->getValue());
1491 } else if(stackFormat->isUnsigned32()) {
1492 if(data) a_Unsigned32->fromPrintableString(data->getValue().c_str());
1493 else if(hexData) a_Unsigned32->fromHexString(hexData->getValue());
1494 } else if(stackFormat->isUnsigned64()) {
1495 if(data) a_Unsigned64->fromPrintableString(data->getValue().c_str());
1496 else if(hexData) a_Unsigned64->fromHexString(hexData->getValue());
1497 } else if(stackFormat->isFloat32()) {
1498 if(data) a_Float32->fromPrintableString(data->getValue().c_str());
1499 else if(hexData) a_Float32->fromHexString(hexData->getValue());
1500 } else if(stackFormat->isFloat64()) {
1501 if(data) a_Float64->fromPrintableString(data->getValue().c_str());
1502 else if(hexData) a_Float64->fromHexString(hexData->getValue());
1503 } else if(stackFormat->isGrouped()) {
1507 for(it = minii; it != maxii; it++) {
1508 std::string nodeName = (*it)->getName();
1510 if(nodeName != "avp") {
1511 std::string msg = "Unsupported grouped avp child node name '"; msg += nodeName;
1512 msg += "': use 'avp'";
1513 throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
1517 avp = getEngine()->allocateAvp();
1518 avp -> fromXML(*it);
1519 } catch(anna::RuntimeException &ex) {
1520 getEngine()->releaseAvp(avp);
1526 } else if(stackFormat->isAddress()) {
1527 if(data) a_Address->fromPrintableString(data->getValue().c_str());
1528 else if(hexData) a_Address->fromHexString(hexData->getValue());
1529 } else if(stackFormat->isTime()) {
1530 if(data) a_Time->fromPrintableString(data->getValue().c_str());
1531 else if(hexData) a_Time->fromHexString(hexData->getValue());
1532 } else if(stackFormat->isUTF8String()) {
1533 if(data) a_UTF8String->fromPrintableString(data->getValue().c_str());
1534 else if(hexData) a_UTF8String->fromHexString(hexData->getValue());
1535 } else if(stackFormat->isDiameterIdentity()) {
1536 if(data) a_DiameterIdentity->fromPrintableString(data->getValue().c_str());
1537 else if(hexData) a_DiameterIdentity->fromHexString(hexData->getValue());
1538 } else if(stackFormat->isDiameterURI()) {
1539 if(data) a_DiameterURI->fromPrintableString(data->getValue().c_str());
1540 else if(hexData) a_DiameterURI->fromHexString(hexData->getValue());
1541 } else if(stackFormat->isEnumerated()) {
1542 if(data) a_Enumerated->fromPrintableString(data->getValue().c_str());
1543 else if(hexData) a_Enumerated->fromHexString(hexData->getValue());
1544 } else if(stackFormat->isIPFilterRule()) {
1545 if(data) a_IPFilterRule->fromPrintableString(data->getValue().c_str());
1546 else if(hexData) a_IPFilterRule->fromHexString(hexData->getValue());
1547 } else if(stackFormat->isQoSFilterRule()) {
1548 if(data) a_QoSFilterRule->fromPrintableString(data->getValue().c_str());
1549 else if(hexData) a_QoSFilterRule->fromHexString(hexData->getValue());
1552 /////////////////////
1553 // Format specific //
1554 /////////////////////
1555 fromXMLByFormat(data, hexData, stackFormat);
1558 //------------------------------------------------------------------------------
1559 //----------------------------------------------------------------- Avp::asXML()
1560 //------------------------------------------------------------------------------
1561 anna::xml::Node* Avp::asXML(anna::xml::Node* parent) const throw() {
1562 // <!ATTLIST avp id CDATA #IMPLIED code CDATA #IMPLIED vendor-code CDATA #IMPLIED flags CDATA #IMPLIED data CDATA #IMPLIED hex-data CDATA #IMPLIED>
1563 anna::xml::Node* result = parent->createChild("avp");
1564 // Dictionary stack avp and format:
1565 const stack::Avp *stackAvp = getStackAvp();
1566 const stack::Format *stackFormat = stackAvp ? (stackAvp->getFormat()) : NULL /*Unknown*/;
1567 bool compactMode = (stackAvp && flagsOK());
1570 result->createAttribute("name", stackAvp->getName());
1572 result->createAttribute("code", a_id.first);
1573 result->createAttribute("vendor-code", a_id.second);
1574 result->createAttribute("flags", (int)a_flags);
1577 // Grouped special case:
1578 if(stackFormat && stackFormat->isGrouped()) {
1579 for(const_avp_iterator it = avp_begin(); it != avp_end(); it++) avp(it)->asXML(result);
1584 // Data part literals:
1586 std::string value = getXMLdata(isHex, stackFormat);
1589 result->createAttribute("hex-data", value);
1591 result->createAttribute("data", value);
1592 const char *alias = stackAvp->getAlias(value);
1594 if(alias) result->createAttribute("alias", alias); // additional information
1601 //------------------------------------------------------------------------------
1602 //----------------------------------------------------------- Avp::asXMLString()
1603 //------------------------------------------------------------------------------
1604 std::string Avp::asXMLString() const throw() {
1605 anna::xml::Node root("root");
1606 return anna::xml::Compiler().apply(asXML(&root));
1610 //------------------------------------------------------------------------------
1611 //---------------------------------------------------------------- Avp::isLike()
1612 //------------------------------------------------------------------------------
1613 bool Avp::isLike(const std::string &pattern) const throw() {
1614 anna::RegularExpression re(pattern);
1615 return re.isLike(asXMLString());