eap_authfsm.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: eap_authfsm.hxx,v 1.26 2004/06/17 21:13:36 yohba Exp $

// eap_authfsm.hxx:  Authenticator state machine
// Written by Yoshihiro Ohba

#ifndef __EAP_AUTHFSM_HXX__
#define __EAP_AUTHFSM_HXX__

#include <ace/Basic_Types.h>
#include <string>
#include "eap.hxx"
#include "eap_fsm.hxx"
#include "eap_method_registrar.hxx"


class EAP_EXPORTS EapAuthSwitchStateMachine : public EapSwitchStateMachine
{
public:

  void Receive(AAAMessageBlock*);

  virtual void Success(AAAMessageBlock *b)=0;

  virtual void Success()=0;

  virtual void Failure(AAAMessageBlock *b)=0;

  virtual void Failure()=0;

  inline ACE_UINT16& MaxRetransmissionCount() 
  { return maxRetransmissionCount; }

  inline ACE_UINT16& RetransmissionInterval() 
  { return retransmissionInterval; }

  //  inline ACE_Byte CurrentIdentifier() { return currentIdentifier; }

  virtual inline bool IsEapBackend(void) { return false; }

  inline bool RetransmissionEnabled() { return (retransmissionInterval != 0); }

  inline void NeedInitialRequestToSend(bool b) { needInitialRequestToSend=b; }

  inline bool NeedInitialRequestToSend() { return needInitialRequestToSend; }

  inline std::string& NotificationString() { return notificationString; }

  inline ACE_UINT16& RetransmissionCount() { return retransmissionCount; }

  enum EapAuthDecision {
      DecisionSuccess,
      DecisionFailure,
      DecisionContinue,
      DecisionPassthrough
  };

  virtual EapAuthDecision Decision();


  enum EapAuthMethodState {
    PROPOSED=0,
    CONT,
    END,     
  };


  EapAuthMethodState& MethodState();

  enum event {
    EvRxMsg=-1,                 // Message reception event passed from
                                // application via
                                // EapSession::Receive().
    EvSgPortEnabled=-2,         // Port enabled event passed from
                                // application.
    EvSgValidResp=-3,           // Event for integrity check success
                                // with continueing method (passed
                                // from methods).
    EvSgInvalidResp=-4,         // Integrity check failure event
                                // passed from methods.
    EvSgEndMethod=-5,           // Event for integrity check sucess
                                // with end method (passed from
                                // methods).
    EvSgRestart=-6,             // Event generated to start the state
                                // machine as a non-backend server.
    EvSgAaaContinue=-7,         // Event generated when AAA continues.

    EvSgAaaSuccess=-8,          // Event generated when AAA succeeds.

    EvSgAaaFailure=-9,          // Event generated when AAA fails.
  };

protected:


  EapAuthSwitchStateMachine(ACE_Reactor &r, EapJobHandle &h) 
    : EapSwitchStateMachine(r, h),
      discardCount(0),
      retransmissionCount(0),
      maxRetransmissionCount(defaultMaxRetransmissionCount),
      retransmissionInterval(defaultRetransmissionInterval),
      needInitialRequestToSend(true)
  {}

  virtual ~EapAuthSwitchStateMachine() {}

  static const ACE_UINT16 defaultMaxRetransmissionCount;
  static const ACE_UINT16 defaultRetransmissionInterval;

  ACE_UINT16 discardCount;
  ACE_UINT16 retransmissionCount;
  ACE_UINT16 maxRetransmissionCount;
  ACE_UINT16 retransmissionInterval;  // Set this value to zero when
                                      // retransmission is disabled.
  std::string notificationString;     // Used for sending notification
                                      // to the per.
  bool needInitialRequestToSend;

  EapAuthMethodState methodState;
};

class EAP_EXPORTS EapStandAloneAuthSwitchStateMachine : 
    public EapAuthSwitchStateMachine,
    public EapStateMachine<EapStandAloneAuthSwitchStateMachine>
{
 public:

  void Start() throw(AAA_Error)
  {
    // Set the current policy element to point to the initial policy
    // element.
    policy.CurrentPolicyElement(policy.InitialPolicyElement());

    // Delete the last executed method if any.
    DeleteMethodStateMachine();

    // Initialize the state machine.
    EapStateMachine<EapStandAloneAuthSwitchStateMachine>::Start();

    // Initialize key stuff.
    keyData.resize(0);
    keyAvailable=false;

    // Generate the initial event.
    Notify(EapAuthSwitchStateMachine::EvSgRestart);
  }

  inline void Notify(AAA_Event ev)
  {
    try {
      EapStateMachine<EapStandAloneAuthSwitchStateMachine>::Notify(ev);
    }
    catch (int i) {
          ACE_UNUSED_ARG(i);
      EAP_LOG(LM_DEBUG, "Nofify() failed.\n");
      Abort();
    }
  }

protected:
  EapStandAloneAuthSwitchStateMachine(ACE_Reactor &r, EapJobHandle &h);

  virtual ~EapStandAloneAuthSwitchStateMachine();
};

class EAP_EXPORTS EapBackendAuthSwitchStateMachine :
    public EapAuthSwitchStateMachine,
    public EapStateMachine<EapBackendAuthSwitchStateMachine>
{
public:

  void Start() throw(AAA_Error)
  {
    // Set the current policy element to point to the initial policy
    // element.
    policy.CurrentPolicyElement(policy.InitialPolicyElement());

    // Initialize the state machine.
    EapStateMachine<EapBackendAuthSwitchStateMachine>::Start();

    // Initialize key stuff.
    keyData.resize(0);
    keyAvailable=false;

    // Generate the initial event.
    Notify(EapAuthSwitchStateMachine::EvSgRestart);
  }

  inline void Notify(AAA_Event ev)
  {
    try {
      EapStateMachine<EapBackendAuthSwitchStateMachine>::Notify(ev);
    }
    catch (int i) {
          ACE_UNUSED_ARG(i);
      EAP_LOG(LM_DEBUG, "Nofify() failed.\n");
      Abort();
    }
  }

  void Start(AAAMessageBlock *msg);

  inline bool IsEapBackend(void) { return true; }

protected:
  EapBackendAuthSwitchStateMachine(ACE_Reactor &r, EapJobHandle &h);

  virtual ~EapBackendAuthSwitchStateMachine();
};

class EAP_EXPORTS EapPassThroughAuthSwitchStateMachine : 
    public EapAuthSwitchStateMachine,
    public EapStateMachine<EapPassThroughAuthSwitchStateMachine>
{
public:

  void Start() throw(AAA_Error)
  {
    // Set the current policy element to point to the initial policy
    // element.
    policy.CurrentPolicyElement(policy.InitialPolicyElement());

    // Initialize the state machine.
    EapStateMachine<EapPassThroughAuthSwitchStateMachine>::Start();

    // Initialize key stuff.
    keyData.resize(0);
    keyAvailable=false;

    // Generate the initial event.
    Notify(EapAuthSwitchStateMachine::EvSgRestart);
  }

  inline void Notify(AAA_Event ev)
  {
    try {
      EapStateMachine<EapPassThroughAuthSwitchStateMachine>::Notify(ev);
    }
    catch (int i) {
      ACE_UNUSED_ARG(i);
      EAP_LOG(LM_DEBUG, "Nofify() failed.\n");
      Abort();
    }
  }

  virtual void ForwardResponse(AAAMessageBlock *msg)=0;

  inline EapMessageQueue& AAARxQueue() throw() { return aaaRxQueue; }

  ACE_Byte GetNextIdentifier(ACE_Byte id) { return id; }

  EapAuthDecision Decision();

  void AAA_Success(AAAMessageBlock *msg) throw(int)
  {
    // Check if this is operating in passthorugh mode.
    if (Decision() != DecisionPassthrough)
      {
        EAP_LOG(LM_ERROR, "Not operating in pass-through mode");
        throw -1;
      }

    if (msg)
      AAARxQueue().enqueue_tail(AAAMessageBlock::Acquire(msg));

    Notify(EvSgAaaSuccess);
  }

  void AAA_Failure(AAAMessageBlock *msg) throw(int)
  {
    // Check if this is operating in passthorugh mode.
    if (Decision() != DecisionPassthrough)
      {
        EAP_LOG(LM_ERROR, "Not operating in pass-through mode.\n");
        throw -1;
      }

    if (msg)
      AAARxQueue().enqueue_tail(AAAMessageBlock::Acquire(msg));

    Notify(EvSgAaaFailure);
  }

  void AAA_Continue(AAAMessageBlock *msg) throw(int)
  {
    // Check if this is operating in passthorugh mode.
    if (Decision() != DecisionPassthrough)
      {
        EAP_LOG(LM_ERROR, "Not operating in pass-through mode.\n");
        throw -1;
      }

    if (!msg)
      {
        EAP_LOG(LM_ERROR, "AAAContinue must contain non-null msg.\n");
        throw -1;
      }
    AAARxQueue().enqueue_tail(AAAMessageBlock::Acquire(msg));
    Notify(EvSgAaaContinue);
  }

protected:
  EapPassThroughAuthSwitchStateMachine(ACE_Reactor &r, EapJobHandle &h);
  virtual ~EapPassThroughAuthSwitchStateMachine();

  EapMessageQueue aaaRxQueue;
};

#endif // __EAP_AUTHFSM_HXX__

---