Message.hpp

Go to the documentation of this file.

// 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 //


#ifndef anna_diameter_comm_Message_hpp
#define anna_diameter_comm_Message_hpp

// Local
#include <anna/diameter/defines.hpp>
#include <anna/diameter.comm/ClassCode.hpp>

#include <anna/core/RuntimeException.hpp>
#include <anna/comm/Message.hpp>
#include <anna/core/util/Millisecond.hpp>
#include <anna/core/functions.hpp>



namespace anna {
namespace xml {
class Node;
}
}



namespace anna {

namespace diameter {

namespace comm {


class ClientSession;
class ServerSession;

class Message : public anna::comm::Message {
public:

  struct OnExpiry { enum _v { Abandon, Ignore, Retransmit }; };

  Message(const OnExpiry::_v onExpiry = OnExpiry::Ignore) : anna::comm::Message(StatusCodeBuffer::Reserve),
    a_classCode(ClassCode::ApplicationMessage),
    a_onExpiry(onExpiry) { initialize(); }

  const ClassCode::_v & getClassCode() const { return a_classCode; }

  OnExpiry::_v getOnExpiry() const { return a_onExpiry; }

  void setOnExpiry(const OnExpiry::_v onExpiry) { a_onExpiry = onExpiry; }

  // Internal use (CER message)
  void setClassCode(const ClassCode::_v & classCode) { a_classCode = classCode; }


  virtual std::string asString() const ;

  virtual anna::xml::Node* asXML(anna::xml::Node* parent) const ;


  // Helpers
  HopByHop getHopByHop() const ;
  EndToEnd getEndToEnd() const ;
  HopByHop getRequestHopByHop() const { return a_requestHopByHop; }
  EndToEnd getRequestEndToEnd() const { return a_requestEndToEnd; }
  void setRequestHopByHop(HopByHop hbh) { a_requestHopByHop = hbh; }
  void setRequestEndToEnd(EndToEnd ete) { a_requestEndToEnd = ete; }
  CommandId getCommandId(bool &isRequest) const ;
  CommandId getCommandId() const { bool dummy; return getCommandId(dummy); }
  ApplicationId getApplicationId() const ;

  bool fixRequestSequence(HopByHop hbh, EndToEnd ete) ;

  // http://diameter-protocol.blogspot.com.es/2011/05/diameter-message-structure-and-message.html

  bool endToEndSequenced() const { return a_endToEndSequenced; }

  void forwardEndToEnd() { a_endToEndSequenced = false; }

  void sequenceEndToEnd() { a_endToEndSequenced = true; }


  // Statistics
  void updateRequestTimestampMs(void) { a_request_timestamp_ms = anna::functions::millisecond(); }
  const anna::Millisecond & getRequestTimestampMs() const { return (a_request_timestamp_ms); }

  int getRetries() const { return a_retries; }
  void setRetries(int value) { a_retries = value; }


  int getRequestServerSessionKey() const { return a_requestServerSessionKey; }

  void setRequestServerSessionKey(int value) { a_requestServerSessionKey = value; }

  const std::string & getRequestClientSessionKey() const { return a_requestClientSessionKey; }

  void setRequestClientSessionKey(const std::string & value) { a_requestClientSessionKey = value; }

  void initialize() {
    a_retries = 1;
    a_requestServerSessionKey = -1; // means unknown/unset
    a_requestClientSessionKey = ""; // means unknown/unset
    a_requestHopByHop = 0;
    a_requestEndToEnd = 0;
    a_endToEndSequenced = true;
  }


protected:
  Message(const ClassCode::_v & classCode, const OnExpiry::_v onExpiry = OnExpiry::Ignore) : anna::comm::Message(StatusCodeBuffer::Reserve),
    a_classCode(classCode),
    a_onExpiry(onExpiry) { initialize(); }


private:
  ClassCode::_v a_classCode;
  OnExpiry::_v a_onExpiry;
  anna::Millisecond a_request_timestamp_ms;    // Lapsed timestamp milliseconds at request event. Used for statistic purposes.
  int a_retries;
  int a_requestServerSessionKey;            // useful to resolve origin of messages when diameter sessions are involved in the other side (if another interface, inherit from this Message class and put/carry context information)
  std::string a_requestClientSessionKey;    // idem for request which was received from servers
  HopByHop a_requestHopByHop; // application backup for hop-by-hop in order to restore on answer receive
  EndToEnd a_requestEndToEnd; // application backup for end-to-end in order to restore on answer receive
  bool a_endToEndSequenced; // end-to-end will be sequenced by default (true)

  void send(ClientSession&) const noexcept(false);
  void send(ServerSession&) const noexcept(false);
  void restoreSequencesAfterFix() ;

  static const char* asText(const OnExpiry::_v) ;

  friend class Session;
  friend class ClientSession;
  friend class ServerSession;
};

}
}
}

#endif