pana_retransmission.h

/* BEGIN_COPYRIGHT                                                        */
/*                                                                        */
/* Open Diameter: Open-source software for the Diameter and               */
/*                Diameter related protocols                              */
/*                                                                        */
/* Copyright (C) 2002-2004 Open Diameter Project                          */
/*                                                                        */
/* This library is free software; you can redistribute it and/or modify   */
/* it under the terms of the GNU Lesser General Public License as         */
/* published by the Free Software Foundation; either version 2.1 of the   */
/* License, or (at your option) any later version.                        */
/*                                                                        */
/* This library is distributed in the hope that it will be useful,        */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of         */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU      */
/* Lesser General Public License for more details.                        */
/*                                                                        */
/* You should have received a copy of the GNU Lesser General Public       */
/* License along with this library; if not, write to the Free Software    */
/* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307    */
/* USA.                                                                   */
/*                                                                        */
/* In addition, when you copy and redistribute some or the entire part of */
/* the source code of this software with or without modification, you     */
/* MUST include this copyright notice in each copy.                       */
/*                                                                        */
/* If you make any changes that are appeared to be useful, please send    */
/* sources that include the changed part to                               */
/* diameter-developers@lists.sourceforge.net so that we can reflect your  */
/* changes to one unified version of this software.                       */
/*                                                                        */
/* END_COPYRIGHT                                                          */

#ifndef __PANA_RETRANSMISSION_H__
#define __PANA_RETRANSMISSION_H__

#include <iostream>
#include <list>
#include "ace/OS.h"
#include "pana_config_manager.h"

/*
   PANA retransmission timers are based on the model used in DHCPv6
   [RFC3315].  Variables used here are also borrowed from this
   specification.  PANA is a request response like protocol.  The
   message exchange terminates when either the request sender
   successfully receives the appropriate answer, or when the message
   exchange is considered to have failed according to the retransmission
   mechanism described below.

   The retransmission behavior is controlled and described by the
   following variables:

         RT     Retransmission timeout

         IRT    Initial retransmission time

         MRC    Maximum retransmission count

         MRT    Maximum retransmission time

         MRD    Maximum retransmission duration

         RAND   Randomization factor
         
   With each message transmission or retransmission, the sender sets RT
   according to the rules given below.  If RT expires before the message
   exchange terminates, the sender recomputes RT and retransmits the
   message.
*/
class PANA_RtQueue;
class PANA_RtQueueData
{
       friend class PANA_RtQueue;
    public:
       PANA_RtQueueData() : m_Timeout(0),
                            m_Duration(0),
                            m_Count(0) { }
       virtual ~PANA_RtQueueData() { }
       int Timeout() { return m_Timeout; }
       virtual PANA_RtQueueData *clone() = 0;
       virtual PANA_RtQueueData &operator=(PANA_RtQueueData &d) {
           m_Timeout = d.m_Timeout;
           m_Duration = d.m_Duration;
           m_Count = d.m_Count;
           return *this;
       }
    
    protected:
       unsigned int m_Timeout;
       unsigned int m_Duration;
       unsigned int m_Count;
};

class PANA_RtQueueNullData : public PANA_RtQueueData
{
    public:
       PANA_RtQueueData *clone() {
           return (new PANA_RtQueueNullData(*this));
       }
};

class PANA_RtQueueMsgBlockData : public PANA_RtQueueData
{
    public:
       PANA_RtQueueMsgBlockData(AAAMessageBlock *blk) :
           m_MsgBlock(NULL) {
           if (blk) {
               m_MsgBlock = AAAMessageBlock::Acquire(ACE_UINT32(blk->size()));
               m_MsgBlock->copy(blk->base(), blk->size());
           }
       }
       virtual ~PANA_RtQueueMsgBlockData() {
           if (m_MsgBlock) {
               m_MsgBlock->Release();
           }
       }
       AAAMessageBlock *MsgBlock() { return m_MsgBlock; }
       PANA_RtQueueData *clone() {
           PANA_RtQueueData *c = new PANA_RtQueueMsgBlockData(m_MsgBlock);
           *c = *this;
           // *c(*this);
           return (c);
       }
    protected:
       AAAMessageBlock *m_MsgBlock;
};

class PANA_RtQueueMsgBlockDataWithRcode : public PANA_RtQueueMsgBlockData
{
    public:
       PANA_RtQueueMsgBlockDataWithRcode(AAAMessageBlock *blk,
                                         ACE_UINT32 rCode) :
           PANA_RtQueueMsgBlockData(blk), m_Rcode(rCode) { }
       virtual ~PANA_RtQueueMsgBlockDataWithRcode() { }
       ACE_UINT32 RCode() { return m_Rcode; }
       PANA_RtQueueData *clone() {
           PANA_RtQueueData *c = new PANA_RtQueueMsgBlockDataWithRcode
                                      (m_MsgBlock, m_Rcode);
           *c = *this;
           return (c);
       }
    protected:
       ACE_UINT32 m_Rcode;
};

typedef std::list<PANA_RtQueueData*> PANA_RtQueueDataList;

class PANA_RtQueue : public PANA_RtQueueDataList
{
    public:
       PANA_RtQueue(int Qsize = 1) : m_MaxQueueCount(Qsize) { }
       bool Schedule(PANA_RtQueueData &d) {
           if (size() >= m_MaxQueueCount) {
               return (false);
           }
           /*
              RT for the first message transmission is based on IRT:
              
                 RT = IRT + RAND*IRT
           */
           unsigned int newRt = PANA_CONFIG_GENERAL().rt_.irt_ +
                    int(RAND()*float(PANA_CONFIG_GENERAL().rt_.irt_));
           
           /*
              MRT specifies an upper bound on the value of RT
              (disregarding the randomization added by the use
              of RAND).  If MRT has a value of 0, there is no
              upper limit on the value of RT. Otherwise:

                if (RT > MRT)
                    RT = MRT + RAND*MRT
           */
           if (newRt > PANA_CONFIG_GENERAL().rt_.mrt_) {
               newRt = PANA_CONFIG_GENERAL().rt_.mrt_ + 
                    int(RAND()*float(PANA_CONFIG_GENERAL().rt_.mrt_));
               return false;
           }
           
           d.m_Timeout = newRt;
           d.m_Duration = newRt;
           d.m_Count = 1;
           push_back(d.clone());
           return (true);
       }
       bool ReSchedule(PANA_RtQueueData *&d) {
           if (empty()) {
               return (false);
           }
           
           PANA_RtQueueData *data = front();
           pop_front();

           /*
              RT for each subsequent message transmission is
              based on the previous value of RT:

                  RT = 2*RTprev + RAND*RTprev
           */
           unsigned int newRt = 2*data->m_Timeout + 
               int(RAND()*float(data->m_Timeout));

           /*
              MRT specifies an upper bound on the value of RT
              (disregarding the randomization added by the use
              of RAND).  If MRT has a value of 0, there is no
              upper limit on the value of RT. Otherwise:

                if (RT > MRT)
                    RT = MRT + RAND*MRT
           */
           if (newRt > PANA_CONFIG_GENERAL().rt_.mrt_) {
               newRt = PANA_CONFIG_GENERAL().rt_.mrt_ + 
                    int(RAND()*float(PANA_CONFIG_GENERAL().rt_.mrt_));
           }
           
           /*
              MRC specifies an upper bound on the number of
              times a sender may retransmit a message.  Unless
              MRC is zero, the message exchange fails once the
              sender has transmitted the message MRC times.

              MRD specifies an upper bound on the length of time
              a sender may retransmit a message.  Unless MRD is
              zero, the message exchange fails once MRD seconds
              have elapsed since the client first transmitted the
              message.

              If both MRC and MRD are non-zero, the message exchange
              fails whenever either of the conditions specified in
              the previous two paragraphs are met.

              If both MRC and MRD are zero, the client continues
              to transmit the message until it receives a response.
           */
           if ((PANA_CONFIG_GENERAL().rt_.mrc_ > 0) &&
               (data->m_Count >= PANA_CONFIG_GENERAL().rt_.mrc_)) {
               delete data;
               return (false);
           }
           
           if ((PANA_CONFIG_GENERAL().rt_.mrd_ > 0) &&
               ((data->m_Duration + newRt) > PANA_CONFIG_GENERAL().rt_.mrd_)) {
               delete data;
               return (false);
           }
           
           data->m_Timeout = newRt;
           data->m_Duration += newRt;
           data->m_Count ++;
           push_back(data);
           d = data;
           return (true);
       }
       void ClearFront() {
           if (! empty()) {
               PANA_RtQueueData *data = front();
               pop_front();
               delete data;
           }
       }
       void Clear() {
           while (! empty()) {
               ClearFront();
           }
       }

    private:
       inline float RAND() {
           /*
              Each of the computations of a new RT include a
              randomization factor (RAND), which is a random
              number chosen with a uniform distribution between
              -0.1 and +0.1.  The randomization factor is included
              to minimize synchronization of messages.

              The algorithm for choosing a random number does
              not need to be cryptographically sound.  The
              algorithm SHOULD produce a different sequence of
              random numbers from each invocation.
           */
           return float(-0.1 + 0.2*float(ACE_OS::rand()/(RAND_MAX+1.0)));
       }
    
       unsigned int m_MaxQueueCount; 
};

#endif // __PANA_RETRANSMISSION_H__

---