diameter_nasreq_server_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_eap_server_fsm.hxx
   Server Statemachine definition for Diameter NASREQ Application 
   Written by Yoshihiro Ohba
   Created April 8, 2004.
*/

#ifndef __NASREQ_SERVER_FSM_H__
#define __NASREQ_SERVER_FSM_H__

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

#ifdef WIN32
   #if defined(DIAMETER_NASREQ_SERVER_EXPORT)
       #define DIAMETER_NASREQ_SERVER_EXPORTS __declspec(dllexport)
   #else
       #define DIAMETER_NASREQ_SERVER_EXPORTS __declspec(dllimport)
   #endif
#else
   #define DIAMETER_NASREQ_SERVER_EXPORTS
   #define DIAMETER_NASREQ_SERVER_EXPORTS
#endif

typedef AAA_JobHandle<AAA_GroupedJob> DiameterNasreqJobHandle;

class DiameterNasreqServerSession;

class DIAMETER_NASREQ_SERVER_EXPORTS DiameterNasreqServerStateMachine 
  : public AAA_StateMachine<DiameterNasreqServerStateMachine>,
    public AAA_EventQueueJob
{
 public:
  DiameterNasreqServerStateMachine(DiameterNasreqServerSession& s,
                                   DiameterNasreqJobHandle &h);

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

  enum {
    EvSgStart,
    EvRxAuthContinue,
    EvRxAuthSuccess,
    EvRxAuthFailure,
    EvSgAuthorizationSuccess,
    EvSgAuthorizationFailure,
    EvRxAA_Request,
    EvSgSessionTimeout,
    EvSgAuthLifetimeTimeout,
    EvSgAuthGracePeriodTimeout,
    EvSgTimeout,
    EvSgDisconnect,
    EvSgValidAA_Request,
    EvSgInvalidAA_Request
  };

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

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

  inline DiameterNasreqServerSession& Session() { return session; }

  virtual void Abort()=0;

  virtual void ForwardAuthenticationInfo
  (DiameterNasreqAuthenticationInfo& authenticationInfo)=0;

  void SignalContinue(DiameterNasreqAuthenticationInfo &authInfo);

  void SignalSuccess();

  void SignalFailure();

  void SendAA_Answer();

  bool CheckAA_Request();

  virtual bool Authorize();

  bool AuthorizationDone() { return authorizationDone; }

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

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

  virtual bool AuthorizeOriginHost
  (const diameter_identity_t &originHost)
  {
    return true;
  }

  virtual bool AuthorizeOriginRealm
  (const diameter_identity_t &originRealm)
  {
    return true;
  }

  virtual bool AuthorizeNasIdentifier
  (const AAA_ScholarAttribute<diameter_utf8string_t> &nasIdentifier)
  {
    return true;
  }

  virtual bool AuthorizeNasIpAddress
  (const AAA_ScholarAttribute<diameter_octetstring_t> &nasIpaddress)
  {
    return true;
  }

  virtual bool AuthorizeNasIpv6Address
  (const AAA_ScholarAttribute<diameter_octetstring_t> &nasIpv6address)
  {
    return true;
  }

  virtual bool AuthorizeNasPort
  (const AAA_ScholarAttribute<diameter_unsigned32_t> &nasPort)
  {
    return true;
  }

  virtual bool AuthorizeNasPortId
  (const AAA_ScholarAttribute<diameter_utf8string_t> &nasPortId)
  {
    return true;
  }

  virtual bool AuthorizeNasPortType
  (const AAA_ScholarAttribute<diameter_enumerated_t> &nasPortType)
  {
    return true;
  }

  virtual bool AuthorizeOriginStateId
  (const AAA_ScholarAttribute<diameter_unsigned32_t> &nasOriginStateId)
  {
    return true;
  }

  virtual bool AuthorizeFilterId
  (AAA_VectorAttribute<diameter_utf8string_t> &FilterId)
  {
    return true;
  }

  virtual bool AuthorizePortLimit
  (AAA_ScholarAttribute<diameter_unsigned32_t> &portLimit)
  {
    return true;
  }

  virtual bool AuthorizePortLimit
  (const diameter_unsigned32_t &portLimit1,
   AAA_ScholarAttribute<diameter_unsigned32_t> &portLimit2)
  {
    return true;
  }

  virtual bool AuthorizeServiceType
  (AAA_ScholarAttribute<diameter_enumerated_t> &serviceType)
  {
    return true;
  }

  virtual bool AuthorizeServiceType
  (const diameter_enumerated_t &serviceType1,
   AAA_ScholarAttribute<diameter_enumerated_t> &serviceType2)
  {
    return true;
  }

  virtual bool AuthorizeClass
  (AAA_VectorAttribute<diameter_octetstring_t> &Class)
  {
    return true;
  }

  virtual bool AuthorizeConfigurationToken
  (const AAA_VectorAttribute<diameter_octetstring_t> &configurationToken)
  {
    return true;
  }

  virtual bool AuthorizeAcctInterimInterval
  (AAA_ScholarAttribute<diameter_unsigned32_t> &acctInterimInterval)
  {
    return true;
  }

  virtual bool AuthorizeIdleTimeout
  (AAA_ScholarAttribute<diameter_unsigned32_t> &idleTimeout)
  {
    return true;
  }

  virtual bool AuthorizeAuthorizationLifetime
  (AAA_ScholarAttribute<diameter_unsigned32_t> &authorizationLifetime)
  {
    return true;
  }

  virtual bool AuthorizeAuthGracePeriod
  (AAA_ScholarAttribute<diameter_unsigned32_t> &authGracePeriod)
  {
    return true;
  }

  virtual bool AuthorizeAuthSessionState
  (AAA_ScholarAttribute<diameter_enumerated_t> &authSessionState)
  {
    return true;
  }

  virtual bool AuthorizeReAuthRequestType
  (AAA_ScholarAttribute<diameter_enumerated_t> &authReAuthRequestType)
  {
    return true;
  }

  virtual bool AuthorizeSessionTimeout
  (AAA_ScholarAttribute<diameter_unsigned32_t> &authSessionTimeout)
  {
    return true;
  }

  virtual bool AuthorizeCallbackId
  (AAA_ScholarAttribute<diameter_utf8string_t> &callbackId)
  {
    return true;
  }

  virtual bool AuthorizeCallbackNumber
  (AAA_ScholarAttribute<diameter_utf8string_t> &callbackNumber)
  {
    return true;
  }

  virtual bool AuthorizeCallbackNumber
  (const diameter_utf8string_t &callbackNumber1,
   AAA_ScholarAttribute<diameter_utf8string_t> &callbackNumber2)
  {
    return true;
  }
  
  virtual bool AuthorizeCallingStationId
  (const diameter_utf8string_t &callingStationId)
  {
    return true;
  }
  
  virtual bool AuthorizeCalledStationId
  (const diameter_utf8string_t &calledStationId)
  {
    return true;
  }
  
  virtual bool AuthorizeOriginatingLineInfo
  (const AAA_ScholarAttribute<diameter_octetstring_t> &originatingLineInfo)
  {
    return true;
  }

  virtual bool AuthorizeConnectInfo
  (const AAA_ScholarAttribute<diameter_utf8string_t> &connectInfo)
  {
    return true;
  }

  virtual bool AuthorizeFramedAppletalkLink
  (AAA_ScholarAttribute<diameter_unsigned32_t> &framedAppletalkLink)
  {
    return true;
  }
  
  virtual bool AuthorizeFramedAppletalkZone
  (AAA_ScholarAttribute<diameter_octetstring_t> &framedAppletalkZone)
  {
    return true;
  }

  virtual bool AuthorizeFramedAppletalkNetwork
  (AAA_VectorAttribute<diameter_unsigned32_t> &framedAppletalkNetwork)
  {
    return true;
  }
  
  virtual bool AuthorizeFramedCompression
  (AAA_VectorAttribute<diameter_enumerated_t> &framedCompression)
  {
    return true;
  }

  virtual bool AuthorizeFramedCompression
  (const std::vector<diameter_enumerated_t> &framedCompression1,
   AAA_VectorAttribute<diameter_enumerated_t> &framedCompression2)
  {
    return true;
  }

  virtual bool AuthorizeFramedInterfaceId
  (AAA_ScholarAttribute<diameter_unsigned64_t> &framedInterfaceId)
  {
    return true;
  }

  virtual bool AuthorizeFramedInterfaceId
  (const diameter_unsigned64_t &framedInterfaceId1,
   AAA_ScholarAttribute<diameter_unsigned64_t> &framedInterfaceId2)
  {
    return true;
  }

  virtual bool AuthorizeFramedIpAddress
  (AAA_ScholarAttribute<diameter_octetstring_t> &framedIpAddress)
  {
    return true;
  }

  virtual bool AuthorizeFramedIpAddress
  (const diameter_octetstring_t &framedIpAddress1,
   AAA_ScholarAttribute<diameter_octetstring_t> &framedIpAddress2)
  {
    return true;
  }

  virtual bool AuthorizeFramedIpv6Prefix
  (AAA_VectorAttribute<diameter_octetstring_t> &framedIpv6Prefix)
  {
    return true;
  }

  virtual bool AuthorizeFramedIpv6Prefix
  (const std::vector<diameter_octetstring_t> &framedIpv6Prefix1,
   AAA_VectorAttribute<diameter_octetstring_t> &framedIpv6Prefix2)
  {
    return true;
  }

  virtual bool AuthorizeFramedIpv6Pool
  (AAA_ScholarAttribute<diameter_octetstring_t> &framedIpv6Pool)
  {
    return true;
  }

  virtual bool AuthorizeFramedPool
  (AAA_ScholarAttribute<diameter_octetstring_t> &framedPool)
  {
    return true;
  }

  virtual bool AuthorizeFramedIpv6Route
  (AAA_VectorAttribute<diameter_utf8string_t> &framedIpv6Route)
  {
    return true;
  }

  virtual bool AuthorizeFramedRoute
  (AAA_VectorAttribute<diameter_utf8string_t> &framedRoute)
  {
    return true;
  }

  virtual bool AuthorizeFramedIpNetmask
  (AAA_ScholarAttribute<diameter_octetstring_t> &framedIpNetmask)
  {
    return true;
  }

  virtual bool AuthorizeFramedIpNetmask
  (const diameter_octetstring_t &framedIpNetmask1,
   AAA_ScholarAttribute<diameter_octetstring_t> &framedIpNetmask2)
  {
    return true;
  }

  virtual bool AuthorizeFramedIpxNetwork
  (AAA_ScholarAttribute<diameter_utf8string_t> &framedIpxNetwork)
  {
    return true;
  }

  virtual bool AuthorizeFramedMtu
  (AAA_ScholarAttribute<diameter_unsigned32_t> &framedMtu)
  {
    return true;
  }

  virtual bool AuthorizeFramedMtu
  (const diameter_unsigned32_t &framedMtu1,
   AAA_ScholarAttribute<diameter_unsigned32_t> &framedMtu2)
  {
    return true;
  }

  virtual bool AuthorizeFramedProtocol
  (AAA_ScholarAttribute<diameter_enumerated_t> &framedProtocol)
  {
    return true;
  }

  virtual bool AuthorizeFramedProtocol
  (const diameter_enumerated_t &framedProtocol1,
   AAA_ScholarAttribute<diameter_enumerated_t> &framedProtoco2)
  {
    return true;
  }

  virtual bool AuthorizeFramedRouting
  (AAA_ScholarAttribute<diameter_enumerated_t> &framedRouting)
  {
    return true;
  }

  virtual bool AuthorizeLoginIpHost
  (AAA_VectorAttribute<diameter_octetstring_t> &loginIpHost)
  {
    return true;
  }
  virtual bool AuthorizeLoginIpHost
  (const std::vector<diameter_octetstring_t> &loginIpHost1,
   AAA_VectorAttribute<diameter_octetstring_t> &loginIpHost2)
  {
    return true;
  }

  virtual bool AuthorizeLoginIpv6Host
  (AAA_VectorAttribute<diameter_octetstring_t> &loginIpv6Host)
  {
    return true;
  }

  virtual bool AuthorizeLoginIpv6Host
  (const std::vector<diameter_octetstring_t> &loginIpv6Host1,
   AAA_VectorAttribute<diameter_octetstring_t> &loginIpv6Host2)
  {
    return true;
  }

  virtual bool AuthorizeLoginLatGroup
  (AAA_ScholarAttribute<diameter_octetstring_t> &loginLatGroup)
  {
    return true;
  }

  virtual bool AuthorizeLoginLatGroup
  (const AAA_ScholarAttribute<diameter_octetstring_t> &loginLatGroup1,
   AAA_ScholarAttribute<diameter_octetstring_t> &loginLatGroup2)
  {
    return true;
  }

  virtual bool AuthorizeLoginLatNode
  (AAA_ScholarAttribute<diameter_octetstring_t> &loginLatNode)
  {
    return true;
  }

  virtual bool AuthorizeLoginLatNode
  (const AAA_ScholarAttribute<diameter_octetstring_t> &loginLatNode1,
   AAA_ScholarAttribute<diameter_octetstring_t> &loginLatNode2)
  {
    return true;
  }

  virtual bool AuthorizeLoginLatPort
  (AAA_ScholarAttribute<diameter_octetstring_t> &loginLatPort)
  {
    return true;
  }

  virtual bool AuthorizeLoginLatPort
  (const AAA_ScholarAttribute<diameter_octetstring_t> &loginLatPort1,
   AAA_ScholarAttribute<diameter_octetstring_t> &loginLatPort2)
  {
    return true;
  }

  virtual bool AuthorizeLoginLatService
  (AAA_ScholarAttribute<diameter_octetstring_t> &loginLatService2)
  {
    return true;
  }

  virtual bool AuthorizeLoginLatService
  (const AAA_ScholarAttribute<diameter_octetstring_t> &loginLatService1,
   AAA_ScholarAttribute<diameter_octetstring_t> &loginLatService2)
  {
    return true;
  }

  virtual bool AuthorizeLoginTcpPort
  (AAA_ScholarAttribute<diameter_unsigned32_t> &loginTcpPort)
  {
    return true;
  }

  virtual bool AuthorizeNasFilterRule
  (AAA_VectorAttribute<diameter_ipfilter_rule_t> &nasFilterRule)
  {
    return true;
  }

  virtual bool AuthorizeTunneling
  (AAA_VectorAttribute<tunneling_t> &tunneling)
  {
    return true;
  }

  virtual bool AuthorizeTunneling
  (const std::vector<tunneling_t> &tunneling1, 
   AAA_VectorAttribute<tunneling_t> &tunneling2)
  {
    return true;
  }

  virtual void SetReplyMessage
  (AAA_VectorAttribute<diameter_utf8string_t> &replyMessage, 
   const diameter_unsigned32_t &resultCode)
  {}

  virtual bool ValidateAuthRequestType
  (const diameter_enumerated_t &authRequestType)
  {
    if (authRequestType != AUTH_REQUEST_TYPE_AUTHENTICATION_ONLY &&
        authRequestType != AUTH_REQUEST_TYPE_AUTHORIZE_AUTHENTICATE)
      return false;
    return true;
  }

  virtual bool ValidateState
  (const diameter_octetstring_t &stateInDER,
   const diameter_octetstring_t &stateInDEA)
  {
    return false;
  }

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

  virtual void SetArapMultiExchange
  (AAA_ScholarAttribute<diameter_unsigned32_t> &ArapSecurity,
   AAA_VectorAttribute<diameter_octetstring_t> &ArapSecurityData)
  {
  }

  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*, 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;
  }

  DiameterNasreqServerSession& session;

  // Job handle.
  DiameterNasreqJobHandle handle;

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

  bool authorizationDone;

  // Request and Answer data
  AA_RequestData aaRequestData;
  AA_AnswerData aaAnswerData;

};

#endif

---