diameter_mip4_aaas_server_fsm.cxx

Diameter协议栈

      sm.Session().Update(AAASession::EVENT_AUTH_FAILED);
    }
  };
    // reply to FA request
  class AcSendAMA_DueToHAASuccess : public DiameterMip4AaaSServerAction 
  {
    void operator()(DiameterMip4AaaSServerStateMachine& sm)
    {

      AAA_LOG(LM_DEBUG, "[%N] Sending AMA due to successful HAA.\n");

      AMR_Data& amr = sm.AMR();
      HAA_Data& haa = sm.HAA();
      AMA_Data& ama = sm.AMA();

      ama.Clear();
      ama.AuthApplicationId = Mip4ApplicationId;
      
      if (haa.AcctMultiSessionId.IsSet())
	{
	  ama.AcctMultiSessionId.Set( haa.AcctMultiSessionId() );
	}
      if (amr.UserName.IsSet())
	{
	  ama.UserName.Set( amr.UserName() );
	}
      
      if ( !sm.SetAuthorizationLifetime( ama.AuthorizationLifetime ) )
	ama.AuthorizationLifetime.Set( amr.AuthorizationLifetime() );

      if (amr.MipFeatureVector.IsSet())
	{
	  ama.MipFeatureVector.Set( amr.MipFeatureVector() );
	}

      // AAAS set value to STATE_MAINTAINED (0) or NO_STATE_MAINTAINED (1)
      sm.SetAuthState( ama.AuthSessionState );

      // ama.ReAuthRequestType - probably not needed Mip app

      //MipRegReply from HAR
      if (haa.MipRegReply.IsSet())
	{
	  ama.MipRegReply.Set( haa.MipRegReply() );
	}

      //MIP-MN-To-FA-MSA
      //MIP-FA-to-mn-MSA
      if ( MipFeatureVectorOperations::IsFeatureVectorSet( 
      			   amr.MipFeatureVector(), FV_MN_FA_KEY_REQUESTED) )

      {
	if ( sm.SetMnFaNonce(ama.MipMnToFaMsa().MipNonce()) )//MnFaNonce-> Mn
	  {
	    sm.SetAlgorithmType( ama.MipMnToFaMsa().MipAlgorithmType);
	    //ama.MipMnToFaMsa.MipMnAaaSpi-this needs to be set by MN for FA 
	    // info is not needed in MipMnToFaMsa HERE
	  }
		
	if ( sm.SetMnFaKey( ama.MipFaToMnMsa().MipSessionKey() ) )//MnHaKey->FA
	  {
	    sm.SetAlgorithmType( ama.MipFaToMnMsa().MipAlgorithmType);
	    ama.MipFaToMnMsa().MipFaToMnSpi.Set( haa.MipFaToMnSpi() );	
	  }
      }

      //MIP-FA-to-HA-MSA
      if ( MipFeatureVectorOperations::IsFeatureVectorSet( 
      			   amr.MipFeatureVector(), FV_FA_HA_KEY_REQUESTED) )
      {
	if ( sm.SetFaHaKey( ama.MipFaToHaMsa().MipSessionKey() ) )//MnHaKey->HA
	  {
	    sm.SetAlgorithmType( ama.MipFaToHaMsa().MipAlgorithmType);
	    ama.MipFaToHaMsa().MipFaToHaSpi.Set( haa.MipFaToHaSpi() );
	  }
      }

      sm.SetMipMsaLifetime( ama.MipMsaLifetime);

      // from HAA:  MIP-HA-Address + MIP-MN-Address
      ama.MipHomeAgentAddress.Set( haa.MipHomeAgentAddress() );

      ama.MipMobileNodeAddress.Set( haa.MipMobileNodeAddress() );
       

      ama.ResultCode = AAA_SUCCESS;
      sm.SendAMA(); 
      sm.Session().Update(AAASession::EVENT_AUTH_SUCCESS);
    }
  };

  enum state {
    StInitialize,
    StCheckAMR,
    StAccepted,          // ValidAMR & no need for HAA, Valid HAA
    StRejected,          //InvalidAMR, Invalid HAA
    StWaitHAA,
    StTerminated
  };

  AcCheckAMR acCheckAMR; 
  AcSendAMA_DueToValidAMR acSendAMA_DueToValidAMR;
  AcSendAMA_DueToInvalidAMR acSendAMA_DueToInvalidAMR;
  AcSendHAR acSendHAR;
  AcSendAMA_DueToHAASuccess acSendAMA_DueToHAASuccess;
  AcSendAMA_DueToHAAFailure acSendAMA_DueToHAAFailure;
  AcSendAMA_DueToHaaNotReceived acSendAMA_DueToHaaNotReceived;
  

  // Defined as a leaf class
  DiameterMip4AaaSServerStateTable_S() 
  {
    AddStateTableEntry(StInitialize, 
		       DiameterMip4AaaSServerStateMachine::EvRxAMR,
		       StCheckAMR, acCheckAMR);
    AddStateTableEntry(StInitialize, 
		       DiameterMip4AaaSServerStateMachine::EvSgDisconnect, 
		       StTerminated);
    AddWildcardStateTableEntry(StInitialize, StTerminated);

    AddStateTableEntry(StCheckAMR, 
		       DiameterMip4AaaSServerStateMachine::EvSgValidAMR, 
		       StAccepted,
		       acSendAMA_DueToValidAMR); 
    AddStateTableEntry(StCheckAMR, 
		       DiameterMip4AaaSServerStateMachine::EvSgInvalidAMR, 
		       StRejected, acSendAMA_DueToInvalidAMR); 
    AddStateTableEntry(StCheckAMR, 
		       DiameterMip4AaaSServerStateMachine::EvSgSendHAR, 
		       StWaitHAA, acSendHAR); 

    AddStateTableEntry(StWaitHAA,
		       DiameterMip4AaaSServerStateMachine::EvSgValidHAA, 
		       StAccepted, acSendAMA_DueToHAASuccess);
    AddStateTableEntry(StWaitHAA,
		       DiameterMip4AaaSServerStateMachine::EvSgInvalidHAA,
		       StRejected, acSendAMA_DueToHAAFailure);
    AddStateTableEntry(StWaitHAA,
                      DiameterMip4AaaSServerStateMachine::EvSgHaaNotReceived,
                      StRejected, acSendAMA_DueToHaaNotReceived);
     AddStateTableEntry(StWaitHAA,
                      DiameterMip4AaaSServerStateMachine::EvSgSessionTimeout,
                      StRejected, acSendAMA_DueToHaaNotReceived);

    AddWildcardStateTableEntry(StWaitHAA, StTerminated);


    AddStateTableEntry(StAccepted,
		       DiameterMip4AaaSServerStateMachine::EvSgDisconnect,
		       StTerminated);


    AddWildcardStateTableEntry(StAccepted, StTerminated);

    AddWildcardStateTableEntry(StRejected, StRejected);

    AddWildcardStateTableEntry(StTerminated, StTerminated);

    InitialState(StInitialize);
  }
  ~DiameterMip4AaaSServerStateTable_S() {}
};

typedef 
ACE_Singleton<DiameterMip4AaaSServerStateTable_S, ACE_Recursive_Thread_Mutex> 
DiameterMip4AaaSServerStateTable;

DiameterMip4AaaSServerStateMachine::DiameterMip4AaaSServerStateMachine
(AAAServerSession& s, DiameterJobHandle &h)
  : AAA_StateMachine<DiameterMip4AaaSServerStateMachine>
  (*this, *DiameterMip4AaaSServerStateTable::instance(), "MIP4_AAAS_SERVER"),
    session(s),
    handle(h) 
{
  AAA_StateMachine<DiameterMip4AaaSServerStateMachine>::Start();
}

void 
DiameterMip4AaaSServerStateMachine::SendAMA()
{
  AAAMessage msg;

  AMA_Data amaData= AMA();
  
  AMA_Parser parser;
  parser.setAppData(&amaData);
  parser.setRawData(&msg);

  try {
    parser.parseAppToRaw();
  }
  catch (DiameterParserError) {
    AAA_LOG(LM_ERROR, "[%N] Parsing error.\n");
    return;
  }
  AAAServerSession &session = Session();
  
  AAAMessageControl msgControl( &session );  
  if (msgControl.Send(msg) != AAA_ERR_SUCCESS) {
    AAA_LOG(LM_ERROR, "Failed sending message.\n");
  }
  else {
    AAA_LOG(LM_DEBUG, "Sent AMA Message.\n");
  }
}

void 
DiameterMip4AaaSServerStateMachine::SendHAR()
{
  AAAMessage msg;
 
  AMR_Data &amrData= AMR();
  HAR_Data &harData= HAR();
  harData.AuthApplicationId = Mip4ApplicationId;

  //populate fields from AMR to HAR
  
  if (  ! SetAuthorizationLifetime( harData.AuthorizationLifetime )) 
    harData.AuthorizationLifetime.Set( amrData.AuthorizationLifetime());
  SetAuthState( harData.AuthSessionState); 

  harData.MipRegRequest.Set(amrData.MipRegRequest());
  // OriginHost. OriginRealm - set by msgControl class

  if ( amrData.UserName.IsSet() )
    harData.UserName.Set( amrData.UserName() ); //if present is copied 

  harData.DestinationRealm.Set( amrData.DestinationRealm());// HA in the same domain
    
  harData.MipFeatureVector.Set( amrData.MipFeatureVector());

  // Optional AVPs

  // Desination Host: requested HA or AAAS assigned HA: 
  //if ( amrData.MipHomeAgentAddress().IsSet() )
      // convert from Address -> Host
      // otherwise => AAAS needs to allocate HA in the realm
  SetAaaSAllocatedHomeAgentHost( harData.DestinationHost );

  //check what keys are requested in amrData.MipFeatureVector, and request
  // these keys from the AAAS -> assign the values 

  //MipMnToFaMsa.
  if ( MipFeatureVectorOperations::IsFeatureVectorSet( amrData.MipFeatureVector, FV_MN_FA_KEY_REQUESTED))
    {
      SetAlgorithmType( harData.MipMnToFaMsa().MipAlgorithmType);
      SetMnFaNonce( harData.MipMnToFaMsa().MipNonce() );
      // Is the following field goes only on the HAA optionaly
      harData.MipMnToFaMsa().MipMnAaaSpi.Set( amrData.MipMnAaaAuth().MipMnAaaSpi() );
    }

  //MipMnToHaMsa + MipHaToMnMsa 
  if ( MipFeatureVectorOperations::IsFeatureVectorSet( amrData.MipFeatureVector, FV_MN_HA_KEY_REQUESTED))
    {
      harData.MipMnToHaMsa().MipMnAaaSpi.Set( amrData.MipHaToFaSpi() );
      SetMnHaNonce ( harData.MipMnToHaMsa().MipNonce() );
      SetAlgorithmType( harData.MipMnToHaMsa().MipAlgorithmType);
      SetReplayMode( harData.MipMnToHaMsa().MipReplayMode);

      SetAlgorithmType( harData.MipHaToMnMsa().MipAlgorithmType);
      SetReplayMode( harData.MipHaToMnMsa().MipReplayMode);
      SetHaMnKey( harData.MipHaToMnMsa().MipSessionKey );
    }

  //MipHaToFaMsa.
  if ( MipFeatureVectorOperations::IsFeatureVectorSet( 
       amrData.MipFeatureVector, FV_FA_HA_KEY_REQUESTED))
    {
      SetAlgorithmType( harData.MipHaToFaMsa().MipAlgorithmType);
      harData.MipHaToFaMsa().MipHaToFaSpi.Set( amrData.MipHaToFaSpi() );
      SetFaHaKey( harData.MipHaToFaMsa().MipSessionKey() );
    }

  // Set by AAA Server
  SetMipMsaLifetime( harData.MipMsaLifetime );

  if ( amrData.MipOriginatingForeignAaa.IsSet() )
    harData.MipOriginatingForeignAaa.Set( amrData.MipOriginatingForeignAaa());

  if ( amrData.MipMobileNodeAddress.IsSet() )
    harData.MipMobileNodeAddress.Set( amrData.MipMobileNodeAddress() );
  if ( amrData.MipHomeAgentAddress.IsSet() )
    harData.MipHomeAgentAddress.Set( amrData.MipHomeAgentAddress() );

  // harData.MipFilterRule.


  // printed in the aaas client session
  //  printf("HAR:\nAuthorization Lifetime: %d\nMip-Reg-Request: %s\nUser Name: %s\nDestination Realm: %s\nDestination Host: %s\n",
  //	 harData.AuthorizationLifetime(), 
  //	 harData.MipRegRequest().data(), 
  //	 harData.UserName().data(),
  //	 harData.DestinationRealm().data(),
  //	 harData.DestinationHost().data() );  

  // trigger SendHAR event in the AAAS client session
  NotifyClientSession( DiameterMip4AaaSClientStateMachine::EvSendHAR);

}