1 // ANNA - Anna is Not Nothingness Anymore //
3 // (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo //
5 // See project site at http://redmine.teslayout.com/projects/anna-suite //
6 // See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //
9 #ifndef anna_diameter_codec_EngineImpl_hpp
10 #define anna_diameter_codec_EngineImpl_hpp
16 #include <anna/core/RuntimeException.hpp>
17 #include <anna/xml/DTDMemory.hpp>
18 #include <anna/core/util/Recycler.hpp>
20 #include <anna/core/util/Component.hpp>
21 #include <anna/diameter/defines.hpp>
24 //------------------------------------------------------------------------------
25 //---------------------------------------------------------------------- #define
26 //------------------------------------------------------------------------------
39 extern const char *MessageDTD;
46 * General component implementation of a diameter elements factory (messages, avps) and common resources which
47 * configure encode/decode operations behaviour.
49 * Standard inheritance is done over codec::Engine, allocating basic Avp and Message classes.
50 * A child implementation could manage complex Avp classes with new data-part formats. Grouped ones could
51 * allocate new complex Avps through such engine which knows how to allocate this special Avp's (also for
52 * complex Message classes with application-specific setters and getters as credit-control related avps,
53 * or some another context items). For example helpers for TME scope stands for a new engine component
54 * called tme::Engine, allocating tme::Avp and tme::Message classes which support three new Avp formats:
55 * ISDNNumber, ISDNAddress and Unsigned16. Anyway, main Message/Avp and Engine classes stand for all contexts
56 * included in anna::diameter, that is to say, whole contexts (at the time only TME) will be included in future
57 * when needed apart from the independent namespace version. Thank to this, single threaded applications could
58 * use whole engine in a easy way.
60 * Usually an engine component is associated to a single diameter stack, although single threaded processes could
61 * use a common engine alternating different stack dictionaries by mean #setDictionary, depending on which kind of
62 * messages are being analyzed. Although the application must ensure that a single dictionary is activated during
63 * the same context operations an Avp could be considered as Unknown if was created with another, and we could
64 * have validation problems (i.e. if mandatory Avp bit is enabled). In general, managing Unknown data-part format
65 * don't have to be a problem because it is interpreted as OctetString format. Depending on what setters/getters
66 * we use, it could reach a RuntimeException at our application.
68 * At multithread processes we must use one heir engine per stack and never switching stacks within same component.
69 * We will use each engine for each context.
71 * It is recommended to use Message class to create Avps (adding them through pair identification <code + vendor-id>
72 * prototype), but we could create Avps separately (other program section, i.e) and join them after:
77 * // Message creation:
78 * Message * msg = new Message(helpers::base::COMMANDID__Re_Auth_Answer);
79 * // Adding + creation:
80 * Avp * avp_sid = msg->addAvp(helpers::base::AVPID__Session_Id);
81 * Avp * avp_oh = msg->addAvp(helpers::base::AVPID__Origin_Host);
82 * Avp * avp_or = msg->addAvp(helpers::base::AVPID__Origin_Realm);
83 * Avp * avp_rc = msg->addAvp(helpers::base::AVPID__Result_Code);
85 * avp_sid->getUTF8String()->setValue("grump.example.com:33041;23432;893;0AF3B81");
88 * 2. External Avp creation:
90 * // Message creation:
91 * Message * msg = new Message(helpers::base::COMMANDID__Re_Auth_Answer);
93 * Avp * avp_sid = new Avp(helpers::base::AVPID__Session_Id);
94 * Avp * avp_oh = new Avp(helpers::base::AVPID__Origin_Host);
95 * Avp * avp_or = new Avp(helpers::base::AVPID__Origin_Realm);
96 * Avp * avp_rc = new Avp(helpers::base::AVPID__Result_Code);
98 * msg->addAvp(avp_sid);
99 * msg->addAvp(avp_oh);
100 * msg->addAvp(avp_or);
101 * msg->addAvp(avp_rc);
103 * avp_sid->getUTF8String()->setValue("grump.example.com:33041;23432;893;0AF3B81");
106 * The main difference is that Avps created through Message (or through grouped Avps) are internally allocated
107 * through engine which normally implements a recycler to optimize memory use.
111 * Implementation example:
115 * class MyEngine : public EngineImpl {
117 * MyEngine (const char *className = "MyEngine") : Engine(className) {;}
120 * anna::Recycler<MyAvp> a_avps;
121 * anna::Recycler<MyMessage> a_messages;
123 * anna::diameter::codec::Avp* allocateAvp () throw () { return a_avps.create (); }
125 * void releaseAvp (anna::diameter::codec::Avp* avp) throw () {
126 * if (avp == NULL) return;
127 * MyAvp* aux = static_cast <MyAvp*> (avp);
128 * aux->clear(); // free internal data-part storage specially for grouped avps which will release its childrens
129 * a_avps.release (aux);
132 * anna::diameter::codec::Message* allocateMessage () throw () { return a_messages.create (); }
134 * void releaseMessage (anna::diameter::codec::Message* message) throw () {
135 * if (message == NULL) return;
136 * MyMessage* aux = static_cast <MyMessage*> (message);
137 * aux->clear(); // free internal data-part storage specially for childrens releasing
138 * a_messages.release (aux);
144 class EngineImpl : public anna::Component {
149 * Defines behaviour on validation procedure: complete analysis or stop at first validation error over the message (by default)
151 struct ValidationDepth { enum _v { Complete, FirstError /* default */ }; };
154 * Defines behaviour mode regarding when to validate a message: before encoding, after decoding (by default), always or never
155 * Anyway validation procedure may be called at any moment (#valid)
157 struct ValidationMode { enum _v { BeforeEncoding, AfterDecoding /* default */, Always, Never /* optimization */ }; };
160 * Defines behaviour mode regarding when to fix a message: before encoding (by default), after decoding, always or never.
161 * An application could add Avps in any order; the fix procedure try to adjust it regarding dictionary. I.e., fixed
162 * Avps will be placed on first position, before mandatory and optional ones, within the message level or any
163 * grouped Avp. Usually we need to configure fixing before encoding in order to provide flexibility to the application
164 * during message construction, but actually, optimal mode implies disabling this procedure. Fixing after decoding will
165 * hide any validation problem regarding Avps position at any level.
166 * Anyway fix procedure may be called at any moment (#fix)
168 struct FixMode { enum _v { BeforeEncoding /* default */, AfterDecoding, Always, Never /* optimization */ }; };
172 Avp* createAvp(const AvpId *id) throw(anna::RuntimeException);
173 Message* createMessage(const CommandId *id) throw(anna::RuntimeException);
178 anna::xml::DTDMemory a_dtd;
179 ValidationDepth::_v a_validationDepth;
180 ValidationMode::_v a_validationMode;
181 bool a_singleFailedAVP;
183 FixMode::_v a_fixMode;
184 bool a_selectStackWithApplicationId; // default behaviour: let the user switch the stack (false for this boolean)
188 const stack::Dictionary * a_dictionary;
191 static const char* asText(const ValidationDepth::_v) throw();
192 static const char* asText(const ValidationMode::_v) throw();
193 static const char* asText(const FixMode::_v) throw();
198 @param className Logical name for the class.
200 EngineImpl(const char* className);
205 virtual ~EngineImpl() {;}
210 Sets diameter dictionary loaded at stack engine. It's recommended to configure a valid dictionary
211 (if not, or NULL provided at #setDictionary, all avps will be managed as 'Unknown' format and all
212 items will need to be manually updated, i.e. message and avp flags).
214 @param dictionary Diameter dictionary. At single threaded processes, the same codec engine could be used with
215 different diameter dictionaries (multi-stack applications). In that case the process must switch the stack for
216 the whole decoding or enconding operation over a Message depending on the context (normally the message header
217 Application-Id is used as stack identifier). But the smart way implies inherit from this engine creating a
218 component for each diameter stack managed in the application. Inheritance is mandatory in multi-threaded processes:
219 one engine, a unique stack.
221 void setDictionary(const stack::Dictionary * dictionary) throw() { a_dictionary = dictionary; }
224 * Sets diameter dictionary loaded at stack engine with the provided identifier.
226 * @param stackId Stack identifier. When missing, NULL will be returned
227 * @return Returns configured dictionary (NULL if stack id was not found)
229 const stack::Dictionary *setDictionary(unsigned int stackId) throw();
233 * By default, the user will select the appropiate stack id depending on the context (see #setDictionary), but
234 * some applications could consider interesting automatic stack selection based on managed messages (incoming
235 * decoded ones, or built messages to be encoded). By default, on engine construction, no changes are done.
236 * Multithreaded processes should have a unique codec engine for each managed stack (then you don't have to
237 * worry about), but mono processes with multistack implementation over the same-unique engine, should activate
238 * this to have the commonly recommended way to choose the stack: using the Application-Id value.
240 * @warning do not activate in case of multithreaded applications.
241 * @warning must register the base protocol stack (with id = 0 = application-id) to manage base protocol messages.
242 * @param enable Activates/deactivates the stack selection from the Application-Id value within the message header.
243 * False by default on engine construction.
245 void selectStackWithApplicationId (bool enable) throw() { a_selectStackWithApplicationId = enable; }
250 Gets the currently configured behaviour regarding stack selection for multistack codec engines in mono thread
253 @return True if selection is done with the Application-Id. False (default) if no selection is performed (user responsibility).
255 bool hasSelectStackWithApplicationId (void) throw() { return a_selectStackWithApplicationId; }
259 Gets currently configured dictionary. NULL if not configured (manual encode/decode operations).
261 @return Returns currently configured engine dictionary
263 const stack::Dictionary *getDictionary() const throw() { return a_dictionary; }
267 * Sets behaviour on validation procedure.
268 * \param validationDepth Behaviour on validation procedure: complete analysis or stop at first validation error over the message.
270 void setValidationDepth(const ValidationDepth::_v validationDepth) throw() { a_validationDepth = validationDepth; }
273 * Returns behaviour on on validation procedure.
274 * For practical purposes, the Failed-AVP would typically refer to the first AVP processing error that a Diameter node encounters
275 * (decoding error or validation error in this case).
276 * A complete validation depth incurs on multiple-content Failed-AVP and is perhaps useful during integration tasks.
278 * \return Behaviour on validation procedure: complete analysis or stop at first validation error over the message (by default).
280 ValidationDepth::_v getValidationDepth() const throw() { return a_validationDepth; }
283 * Sets behaviour on validation procedure regarding stack flags. Actually, only AVP flags M & P are affected. The vendor bit is
284 * too important to be ignored, and there is no way to check operation flags (as request bit).
285 * By default (at engine start), flags are verified.
286 * \param ignoreFlags Validation will ignore flags.
289 void ignoreFlagsOnValidation(bool ignoreFlags) throw() { a_ignoreFlags = ignoreFlags; }
292 * Gets behaviour on validation procedure regarding stack flags. Actually, only AVP flags M & P are affected. The vendor bit is
293 * too important to be ignored, and there is no way to check operation flags (as request bit).
294 * By default (at engine start), flags are verified.
295 * \return Validation ignore flags indicator.
297 bool ignoreFlagsOnValidation() const throw() { return a_ignoreFlags; }
300 * Sets validation mode.
301 * \param validationMode Validation mode: before encoding, after decoding, always or never.
303 void setValidationMode(const ValidationMode::_v validationMode) throw() { a_validationMode = validationMode; }
306 * Returns validation mode.
307 * Before coding validation mode is perhaps useful during debugging tasks, i.e. to check answer messages built by the application
308 * during development phase.
309 * \return Validation mode: before encoding, after decoding (by default), always or never.
311 ValidationMode::_v getValidationMode() const throw() { return a_validationMode; }
317 * \param fixMode Fix mode: before encoding, after decoding, always or never.
319 void setFixMode(const FixMode::_v fixMode) throw() { a_fixMode = fixMode; }
323 * \return Fix mode: before encoding (by default), after decoding, always or never.
325 FixMode::_v getFixMode() const throw() { return a_fixMode; }
328 * Sets single FailedAVP. True by default. If false, and more than one wrong avp are found during message
329 * decoding and or validation, a new Failed-AVP will be added to the dynamic answer provided. The standard
330 * talks about only one but it is open to do this.
332 * \param single Single Failed-AVP boolean.
334 void setSingleFailedAVP(bool single = true) throw() { a_singleFailedAVP = single; }
337 * Returns single Failed-AVP boolean.
338 * \return Failed-AVP could be one (true) or more (false) in answer message.
340 bool getSingleFailedAVP() const throw() { return a_singleFailedAVP; }
343 DTD document for xml message parsing
345 const anna::xml::DTDMemory & getDTD() const throw() { return a_dtd; }
348 * Creates a new diameter avp assigning its identifier, using engine resources to allocate memory (recommended
349 * recycler allocation at engine component re-implementation of allocator methods). Obviously, normal objects
350 * creation (new) is possible.
352 * @param id Avp identifier. AVP flags will be established based on active dictionary for known avps, or
353 * uninitialized for unknown ones.
355 * @return Created avp ready to be used
357 Avp* createAvp(AvpId id) throw(anna::RuntimeException) { return createAvp(&id); }
360 * Creates a new diameter avp, using engine resources to allocate memory (recommended recycler allocation at
361 * engine component re-implementation of allocator methods). Obviously, normal objects creation (new) is possible.
363 * @return Created avp ready to be used
365 Avp* createAvp() throw(anna::RuntimeException) { return createAvp(NULL); }
368 * Creates a new diameter Message assigning its identifier, using engine resources to allocate memory (recommended
369 * recycler allocation at engine component re-implementation of allocator methods). Obviously, normal objects
370 * creation (new) is possible.
372 * @param id Command identifier. Message flags will be established based on active dictionary for known commands,
373 * or uninitialized for unknown ones.
375 * @return Created message ready to be used
377 Message* createMessage(CommandId id) throw(anna::RuntimeException) { return createMessage(&id); }
380 * Creates a new diameter message, using engine resources to allocate memory (recommended recycler allocation
381 * at engine component re-implementation of allocator methods). Obviously, normal objects creation (new) is possible.
383 * @return Created message ready to be used
385 Message* createMessage() throw(anna::RuntimeException) { return createMessage(NULL); }
389 Loads an xml file representing a diameter message base in a DTD document (#getDTD)
391 @param xmlPathFile Complete path file to the xml document which represents the diameter message
393 Message *createMessage(const std::string & xmlPathFile) throw(anna::RuntimeException);
397 Invoked to free Avps.
400 virtual void releaseAvp(Avp*) throw() = 0;
403 Invoked to free Messages.
406 virtual void releaseMessage(Message*) throw() = 0;
410 * Class string representation
412 * @return String with class content
414 virtual std::string asString(void) const throw();
417 Class XML representation.
418 \param parent XML node over which we will put instance information.
419 \return XML documentcon with class content.
421 virtual anna::xml::Node* asXML(anna::xml::Node* parent) const throw();
425 Gets the Avp identifier providing its logical name at engine dictionary
427 @param name Name of the Avp at engine dictionary
429 @return Avp identifier as pair (code,vendor-id)
431 AvpId avpIdForName(const char * name) throw(anna::RuntimeException);
435 Gets the Command identifier providing its logical name at engine dictionary
437 @param name Name of the Command at engine dictionary
439 @return Command identifier as pair (code,request-indicator)
441 CommandId commandIdForName(const char * name) throw(anna::RuntimeException);
447 Avp allocator method.
449 It is recommended to use anna::Recycler for Avps creation/releasing.
453 virtual Avp* allocateAvp() throw() = 0;
457 Message allocator method.
459 It is recommended to use anna::Recycler for Message creation/releasing.
463 virtual Message* allocateMessage() throw() = 0;
467 Manages warning trace or exception on validation anomaly depending on ValidationDepth configuration
468 ('complete' and 'first error' reports respectively).
470 @description Anomaly description used in trace or exception
472 @see setValidationDepth
473 @see getValidationDepth
475 void validationAnomaly(const std::string & description) const throw(anna::RuntimeException);