diameter_eap_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_eap_client_fsm.hxx
   Client Statemachine definition for Diameter EAP Application 
   Written by Yoshihiro Ohba
   Created December 4, 2003.
*/

#ifndef __EAP_CLIENT_FSM_H__
#define __EAP_CLIENT_FSM_H__

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

#ifdef WIN32
   #if defined(DIAMETER_EAP_CLIENT_EXPORT)
       #define DIAMETER_EAP_CLIENT_EXPORTS __declspec(dllexport)
   #else
       #define DIAMETER_EAP_CLIENT_EXPORTS __declspec(dllimport)
   #endif
#else
   #define DIAMETER_EAP_CLIENT_EXPORTS
   #define DIAMETER_EAP_CLIENT_EXPORTS
#endif

typedef AAA_JobHandle<AAA_GroupedJob> DiameterJobHandle;

class DiameterEapClientSession;

class DIAMETER_EAP_CLIENT_EXPORTS DiameterEapClientStateMachine 
  : public AAA_StateMachine<DiameterEapClientStateMachine>,
    public AAA_EventQueueJob
{
  friend class DiameterJobMultiplexor;

 public:
  DiameterEapClientStateMachine(DiameterEapClientSession& s,
                                DiameterJobHandle &h);

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

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

  //  void Start() throw (AAA_Error);

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

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

  inline DiameterEapClientSession& Session() { return session; }

  virtual void Abort()=0;

  void SendDER();

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

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

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

  void ForwardResponse(std::string &eapMsg);

  virtual void SendAA_Request() {}

  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 SetNasPort
  (AAA_ScholarAttribute<diameter_unsigned32_t> &nasPort)
  {
  }

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

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

  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
  SetUserName(AAA_ScholarAttribute<diameter_utf8string_t> &userName)
  {
  }

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

  virtual void
  SetIdleTimeout(AAA_ScholarAttribute<diameter_unsigned32_t> &idleTimeout)
  {
  }

  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
  SetSessionTimeout
  (AAA_ScholarAttribute<diameter_unsigned32_t> &sessionTimeout)
  {
  }

  virtual void SetClass
  (AAA_VectorAttribute<diameter_octetstring_t> &classInDER)
  {
  }

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

  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 SetTunneling
  (AAA_VectorAttribute<tunneling_t> &tunneling)
  {
  }

  // Enforcement member functions.
  
  virtual void EnforceMultiRoundTimeOut
  (const diameter_unsigned32_t &multiRoundTimeout)
  {
  }

  virtual void EnforceServiceType
  (const diameter_enumerated_t &serviceTypeInDEA)
  {
  }

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

  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 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 EnforceTunneling
  (const std::vector<tunneling_t> &tunneling)
  {
  }

  virtual void EnforceEapMasterSessionKey
  (const diameter_octetstring_t &eapMasterSessionKey)
  {
  }

  virtual void EnforceAccountingEapAuthMethod
  (const std::vector<diameter_unsigned64_t> &accountingEapAuthMethodInDEA)
  {
  }
  
  DER_Data& DER() { return derData; }
  DEA_Data& DEA() { return deaData; }

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

  DiameterEapClientSession &session;

  DiameterJobHandle handle;

  DER_Data derData;
  DEA_Data deaData;
  // XXX: AA_AnswerData aaAnswerData;

};

#endif

---