diameter_eap_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 EAP Application 
   Written by Yoshihiro Ohba
   Created December 16, 2003.
*/

#ifndef __EAP_SERVER_FSM_H__
#define __EAP_SERVER_FSM_H__

#include "framework.h"
#include "diameter_eap_parser.hxx"

#ifdef WIN32
   #if defined(DIAMETER_EAP_SERVER_EXPORT)
       #define DIAMETER_EAP_SERVER_EXPORTS __declspec(dllexport)
   #else
       #define DIAMETER_EAP_SERVER_EXPORTS __declspec(dllimport)
   #endif
#else
   #define DIAMETER_EAP_SERVER_EXPORTS
   #define DIAMETER_EAP_SERVER_EXPORTS
#endif

typedef AAA_JobHandle<AAA_GroupedJob> DiameterJobHandle;

class DiameterEapServerSession;

class DIAMETER_EAP_SERVER_EXPORTS DiameterEapServerStateMachine 
  : public AAA_StateMachine<DiameterEapServerStateMachine>,
    public AAA_EventQueueJob
{
  friend class DiameterJobMultiplexor;

 public:
  DiameterEapServerStateMachine(DiameterEapServerSession& s,
                                DiameterJobHandle &h);

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

  enum {
    EvSgStart,
    EvRxEapRequest,
    EvRxEapSuccess,
    EvRxEapFailure,
    EvSgAuthorizationSuccess,
    EvSgAuthorizationFailure,
    EvRxDER,
    EvSgSessionTimeout,
    EvSgAuthLifetimeTimeout,
    EvSgAuthGracePeriodTimeout,
    EvSgTimeout,
    EvSgDisconnect,
    EvSgValidDER,
    EvSgInvalidDER
  };

  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 DiameterEapServerSession& Session() { return session; }

  virtual void Abort()=0;

  virtual void ForwardEapResponse(std::string &eapMsg)=0;

  void SignalContinue(std::string &eapMsg);

  void SignalSuccess(std::string &eapMsg);

  void SignalFailure(std::string &eapMsg);

  void SendDEA();

  bool CheckDER();

  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 AuthorizeMultiRoundTimeOut
  (AAA_ScholarAttribute<diameter_unsigned32_t> &multiRoundTimeout)
  {
    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 AuthorizeClass
  (const std::vector<diameter_octetstring_t> &Class1, 
   AAA_VectorAttribute<diameter_octetstring_t> &Class2)
  {
    return true;
  }

  virtual bool AuthorizeConfigurationToken
  (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> &reAuthRequestType)
  {
    return true;
  }

  virtual bool AuthorizeSessionTimeout
  (AAA_ScholarAttribute<diameter_unsigned32_t> &sessionTimeout)
  {
    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 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 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 AAA_VectorAttribute<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 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 bool AuthorizeEapMasterSessionKey
  (AAA_ScholarAttribute<diameter_octetstring_t> &eapMasterSessionKey)
  {
    return true;
  }

  virtual bool AuthorizeAccountingEapAuthMethod
  (AAA_VectorAttribute<diameter_unsigned64_t> &accountingEapAuthMethod)
  {
    return true;
  }

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

  virtual void SetReissuedEapPayload
  (AAA_ScholarAttribute<diameter_octetstring_t> &reissuedEapPayload)
  {}

  virtual bool ValidateUserName
  (const diameter_utf8string_t &userName)
  {
    return false;
  }

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

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

  DER_Data& DER() { return derData; }
  DEA_Data& DEA() { return deaData; }

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

  DiameterEapServerSession& session;
  DiameterJobHandle handle;

  bool authorizationDone;

  DER_Data derData;
  DEA_Data deaData;
};

#endif

---