diameter_nasreq_client_fsm.hxx

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

/* $Id: */
/* 
   diameter_nasreq_client_fsm.hxx
   Client Statemachine definition for Diameter NASREQ Application 
   Written by Yoshihiro Ohba
   Created May 1, 2004.
*/

#ifndef __NASREQ_CLIENT_FSM_H__
#define __NASREQ_CLIENT_FSM_H__

#include "framework.h"
#include "diameter_nasreq_parser.hxx"
#include "diameter_nasreq_authinfo.hxx"

#ifdef WIN32
   #if defined(DIAMETER_NASREQ_CLIENT_EXPORT)
       #define DIAMETER_NASREQ_CLIENT_EXPORTS __declspec(dllexport)
   #else
       #define DIAMETER_NASREQ_CLIENT_EXPORTS __declspec(dllimport)
   #endif
#else
   #define DIAMETER_NASREQ_CLIENT_EXPORTS
   #define DIAMETER_NASREQ_CLIENT_EXPORTS
#endif

typedef AAA_JobHandle<AAA_GroupedJob> DiameterJobHandle;

class DiameterNasreqClientSession;

class DIAMETER_NASREQ_CLIENT_EXPORTS DiameterNasreqClientStateMachine 
  : public AAA_StateMachine<DiameterNasreqClientStateMachine>,
    public AAA_EventQueueJob
{
  friend class DiameterJobMultiplexor;

 public:
  DiameterNasreqClientStateMachine(DiameterNasreqClientSession& s,
                                   DiameterJobHandle &h);

  ~DiameterNasreqClientStateMachine() 
  {
    handle.Job().Remove(this); 
  }

  enum {
    //    EvSgStartLocalMethod,
    EvSgStart=-1,
    EvRxAuthInfo=-2,
    EvRxAA_Answer=-3,
    EvSgSessionTimeout=-4,
    EvSgAuthLifetimeTimeout=-5,
    EvSgAuthGracePeriodTimeout=-6,
    EvSgTimeout=-7,
    EvSgDisconnect=-8
  };

  inline void Notify(AAA_Event ev) {
    // Enqueue the event.
    if (AAA_EventQueueJob::Enqueue(ev) <= 0)
      Abort();

    if (handle.Job().Schedule(this) < 0)
      Abort();
  }

  inline DiameterNasreqClientSession& Session() { return session; }

  virtual void Abort()=0;

  void SendAA_Request();

  virtual void SignalContinue(DiameterNasreqAuthenticationInfo &authInfo)=0;

  virtual void SignalSuccess()=0;

  virtual void SignalFailure()=0;

  void ForwardAuthenticationInfo
  (DiameterNasreqAuthenticationInfo &authenticationInfo);

  virtual void SignalReauthentication()=0;

  virtual void SignalDisconnect()=0;

  inline AAA_JobData& JobData() { return *handle.Job().Data(); }

  template <class T> inline T& JobData(Type2Type<T>) 
  { return (T&)*handle.Job().Data(); }

  // Insert-AVP member functions.

  virtual void SetDestinationRealm
  (AAA_ScholarAttribute<diameter_utf8string_t> &destinationRealm)
  {
  }

  virtual void SetDestinationHost
  (AAA_ScholarAttribute<diameter_utf8string_t> &destinationHost)
  {
  }

  virtual void SetAuthRequestType
  (AAA_ScholarAttribute<diameter_enumerated_t> &authRequestType)
  {
    authRequestType = AUTH_REQUEST_TYPE_AUTHORIZE_AUTHENTICATE;
  }

  virtual void SetNasIdentifier
  (AAA_ScholarAttribute<diameter_utf8string_t> &nasIdentifier)
  {
  }

  virtual void SetNasIpAddress
  (AAA_ScholarAttribute<diameter_octetstring_t> &nasIpAddress)
  {
  }

  virtual void SetNasIpv6Address
  (AAA_ScholarAttribute<diameter_octetstring_t> &nasIpv6Address)
  {
  }

  virtual void SetNasPort
  (AAA_ScholarAttribute<diameter_unsigned32_t> &nasPort)
  {
  }

  virtual void SetNasPortType
  (AAA_ScholarAttribute<diameter_enumerated_t> &nasPortType)
  {
  }

  virtual void SetNasPortId
  (AAA_ScholarAttribute<diameter_utf8string_t> &nasPortId)
  {
  }

  virtual void SetOriginStateId
  (AAA_ScholarAttribute<diameter_unsigned32_t> &originStateId)
  {
  }

  virtual void SetPortLimit
  (AAA_ScholarAttribute<diameter_unsigned32_t> &portLimit)
  {
  }

  virtual void
  SetServiceType(AAA_ScholarAttribute<diameter_enumerated_t> &serviceType)
  {
  }

  virtual void
  SetState(AAA_ScholarAttribute<diameter_octetstring_t> &state)
  {
  }

  virtual void
  SetAuthorizationLifetime
  (AAA_ScholarAttribute<diameter_unsigned32_t> &authorizationLifetime)
  {
  }

  virtual void
  SetAuthGracePeriod
  (AAA_ScholarAttribute<diameter_unsigned32_t> &authGracePeriod)
  {
  }

  virtual void
  SetAuthSessionState
  (AAA_ScholarAttribute<diameter_enumerated_t> &authSessionState)
  {
  }

  virtual void SetCallbackNumber
  (AAA_ScholarAttribute<diameter_utf8string_t> &callbackNumber)
  {
  }

  virtual void SetCalledStationId
  (AAA_ScholarAttribute<diameter_utf8string_t> &calledStationId)
  {
  }

  virtual void SetCallingStationId
  (AAA_ScholarAttribute<diameter_utf8string_t> &callingStationId)
  {
  }

  virtual void SetOriginatingLineInfo
  (AAA_ScholarAttribute<diameter_octetstring_t> &originatingLineInfo)
  {
  }

  virtual void SetConnectInfo
  (AAA_ScholarAttribute<diameter_utf8string_t> &connectInfo)
  {
  }

  virtual void SetFramedCompression
  (AAA_VectorAttribute<diameter_enumerated_t> &framedCompression)
  {
  }

  virtual void SetFramedInterfaceId
  (AAA_ScholarAttribute<diameter_unsigned64_t> &framedInterfaceId)
  {
  }

  virtual void SetFramedIpAddress
  (AAA_ScholarAttribute<diameter_octetstring_t> &framedIpAddress)
  {
  }

  virtual void SetFramedIpv6Prefix
  (AAA_VectorAttribute<diameter_octetstring_t> &framedIpv6Prefix)
  {
  }

  virtual void SetFramedIpNetmask
  (AAA_ScholarAttribute<diameter_octetstring_t> &framedIpNetmask)
  {
  }

  virtual void SetFramedMtu
  (AAA_ScholarAttribute<diameter_unsigned32_t> &framedMtu)
  {
  }

  virtual void SetFramedProtocol
  (AAA_ScholarAttribute<diameter_enumerated_t> &framedProtocol)
  {
  }

  virtual void SetLoginIpHost
  (AAA_VectorAttribute<diameter_octetstring_t> &loginIpHost)
  {
  }

  virtual void SetLoginIpv6Host
  (AAA_VectorAttribute<diameter_octetstring_t> &loginIpv6Host)
  {
  }

  virtual void SetLoginLatGroup
  (AAA_ScholarAttribute<diameter_octetstring_t> &loginLatGroup)
  {
  }

  virtual void SetLoginLatNode
  (AAA_ScholarAttribute<diameter_octetstring_t> &loginLatNode)
  {
  }

  virtual void SetLoginLatPort
  (AAA_ScholarAttribute<diameter_octetstring_t> &loginLatPort)
  {
  }

  virtual void SetLoginLatService
  (AAA_ScholarAttribute<diameter_octetstring_t> &loginLatService)
  {
  }

  virtual void SetTunneling
  (AAA_VectorAttribute<tunneling_t> &tunneling)
  {
  }

  // Enforcement member functions.
  
  virtual void EnforceServiceType
  (const diameter_enumerated_t &serviceType)
  {
  }

  virtual void EnforceConfigurationToken
  (const std::vector<diameter_octetstring_t> &Class)
  {
  }

  virtual void EnforceClass
  (const std::vector<diameter_octetstring_t> &Class)
  {
  }

  virtual void EnforceAcctInterimInterval
  (const diameter_unsigned32_t &acctInterimInterval)
  {
  }

  virtual void EnforceIdleTimeout
  (const diameter_unsigned32_t &idleTimeout)
  {
  }

  virtual void EnforceAuthorizationLifetime
  (const diameter_unsigned32_t &authorizationLifetime)
  {
  }

  virtual void EnforceAuthGracePeriod
  (const diameter_unsigned32_t &authGracePeriod)
  {
  }

  virtual void EnforceAuthSessionState
  (const diameter_enumerated_t &authSessionState)
  {
  }

  virtual void EnforceReAuthRequestType
  (const diameter_enumerated_t &reAuthRequestType)
  {
  }

  virtual void EnforceSessionTimeout
  (const diameter_unsigned32_t &sessionTimeout)
  {
  }

  virtual void EnforceFilterId
  (const std::vector<diameter_utf8string_t> &filterId)
  {
  }

  virtual void EnforcePortLimit
  (const diameter_unsigned32_t &portLimit)
  {
  }

  virtual void EnforcePrompt
  (const diameter_enumerated_t &prompt)
  {
  }

  virtual void EnforceCallbackId
  (const diameter_utf8string_t &callbackId)
  {
  }
  
  virtual void EnforceCallbackNumber
  (const diameter_utf8string_t &callbackNumberInDEA)
  {
  }
  
  virtual void EnforceFramedAppletalkLink
  (const diameter_unsigned32_t &framedAppletalkLink)
  {
  }
  
  virtual void EnforceFramedAppletalkZone
  (const diameter_octetstring_t &framedAppletalkZone)
  {
  }

  virtual void EnforceFramedAppletalkNetwork
  (const std::vector<diameter_unsigned32_t> &framedAppletalkNetwork)
  {
  }
  
  virtual void EnforceFramedCompression
  (const std::vector<diameter_enumerated_t> &framedCompression)
  {
  }

  virtual void EnforceFramedInterfaceId
  (const diameter_unsigned64_t &framedInterfaceId)
  {
  }
  
  virtual void EnforceFramedIpAddress
  (const diameter_octetstring_t &framedIpAddress)
  {
  }
  
  virtual void EnforceFramedIpv6Prefix
  (const std::vector<diameter_octetstring_t> &framedIpv6Prefix)
  {
  }

  virtual void EnforceFramedIpv6Pool
  (const diameter_octetstring_t &framedIpv6Pool)
  {
  }

  virtual void EnforceFramedPool
  (const diameter_octetstring_t &framedPool)
  {
  }

  virtual void EnforceFramedIpv6Route
  (const std::vector<diameter_utf8string_t> &framedIpv6Route)
  {
  }

  virtual void EnforceFramedIpNetmask
  (const diameter_octetstring_t &framedIpNetmaskInDEA)
  {
  }

  virtual void EnforceFramedIpxNetwork
  (const diameter_utf8string_t &framedIpxNetwork)
  {
  }

  virtual void EnforceFramedMtu
  (const diameter_unsigned32_t &framedMtu)
  {
  }

  virtual void EnforceFramedProtocol
  (const diameter_enumerated_t &framedProtocol)
  {
  }

  virtual void EnforceFramedRouting
  (const diameter_enumerated_t &framedRouting)
  {
  }

  virtual void EnforceNasFilterRule
  (const std::vector<diameter_ipfilter_rule_t> &nasFilterRule)
  {
  }

  virtual void EnforceLoginIpHost
  (const std::vector<diameter_octetstring_t> &loginIpHost)
  {
  }

  virtual void EnforceLoginIpv6Host
  (const std::vector<diameter_octetstring_t> &loginIpv6Host)
  {
  }

  virtual void EnforceLoginLatGroup
  (const diameter_octetstring_t &loginLatGroup)
  {
  }

  virtual void EnforceLoginLatNode
  (const diameter_octetstring_t &loginLatNode)
  {
  }

  virtual void EnforceLoginLatPort
  (const diameter_octetstring_t &loginLatPort)
  {
  }

  virtual void EnforceLoginLatService
  (const diameter_octetstring_t &loginLatService)
  {
  }

  virtual void EnforceLoginService
  (const diameter_enumerated_t &loginService)
  {
  }

  virtual void EnforceLoginTcpPort
  (const diameter_unsigned32_t &loginTcpPort)
  {
  }

  virtual void EnforceTunneling
  (const std::vector<tunneling_t> &tunneling)
  {
  }

  inline DiameterNasreqAuthenticationInfo& AuthenticationInfo()
  { return *authenticationInfo; }

  inline AA_RequestData& AA_Request() { return aaRequestData; }
  inline AA_AnswerData& AA_Answer() { return aaAnswerData; }

 protected:

 private:
  int Schedule(AAA_Job *job, size_t=1) { return (-1); }

  inline int Serve()
  {
    if (!AAA_EventQueueJob::ExistBacklog())
      {
        AAA_LOG(LM_ERROR, "%N: no backlog to serve.");
        return 0;
      }

    // Obtain the event to execute.
    AAA_Event ev;
    AAA_EventQueueJob::Dequeue(ev);

    bool existBacklog = AAA_EventQueueJob::ExistBacklog();

    // Execute it.
    Event(ev);
    return existBacklog ? 1 : 0;
  }

  DiameterNasreqClientSession &session;

  // Job handle.
  DiameterJobHandle handle;

  // authentication information.
  boost::shared_ptr<DiameterNasreqAuthenticationInfo> authenticationInfo;

  // AA-Request and AA-Answer data.
  AA_RequestData aaRequestData;
  AA_AnswerData aaAnswerData;
};

#endif

---