securitylevel2.h

支持组件模型CCM的开源中间件-mico

    virtual void *_narrow_helper( const char *repoid );

    virtual ::SecurityLevel2::CredentialsList* accepting_credentials() = 0;
    virtual ::Security::AssociationOptions association_options_used() = 0;
    virtual ::Security::DelegationState delegation_state() = 0;
    virtual ::Security::DelegationMode delegation_mode() = 0;

  protected:
    ReceivedCredentials() {};
  private:
    ReceivedCredentials( const ReceivedCredentials& );
    void operator=( const ReceivedCredentials& );
};



/*
 * Base class and common definitions for interface TargetCredentials
 */

class TargetCredentials : 
  virtual public ::SecurityLevel2::Credentials
{
  public:
    virtual ~TargetCredentials();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef TargetCredentials_ptr _ptr_type;
    typedef TargetCredentials_var _var_type;
    #endif

    static TargetCredentials_ptr _narrow( CORBA::Object_ptr obj );
    static TargetCredentials_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static TargetCredentials_ptr _duplicate( TargetCredentials_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static TargetCredentials_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::SecurityLevel2::CredentialsList* initiating_credentials() = 0;
    virtual ::Security::AssociationOptions association_options_used() = 0;

  protected:
    TargetCredentials() {};
  private:
    TargetCredentials( const TargetCredentials& );
    void operator=( const TargetCredentials& );
};



/*
 * Base class and common definitions for interface PrincipalAuthenticator
 */

class PrincipalAuthenticator : 
  virtual public CORBA::Object
{
  public:
    virtual ~PrincipalAuthenticator();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef PrincipalAuthenticator_ptr _ptr_type;
    typedef PrincipalAuthenticator_var _var_type;
    #endif

    static PrincipalAuthenticator_ptr _narrow( CORBA::Object_ptr obj );
    static PrincipalAuthenticator_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static PrincipalAuthenticator_ptr _duplicate( PrincipalAuthenticator_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static PrincipalAuthenticator_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::Security::AuthenticationStatus authenticate( ::Security::AuthenticationMethod method, const char* mechanism, const char* security_name, const CORBA::Any& auth_data, const ::Security::AttributeList& privileges, Credentials_out creds, CORBA::Any_out continuation_data, CORBA::Any_out auth_specific_data ) = 0;
    virtual ::Security::AuthenticationMethodList* get_supported_authen_methods( const char* mechanism ) = 0;
    virtual ::Security::AuthenticationStatus continue_authentication( const CORBA::Any& response_data, Credentials_ptr creds, CORBA::Any_out continuation_data, CORBA::Any_out auth_specific_data ) = 0;

  protected:
    PrincipalAuthenticator() {};
  private:
    PrincipalAuthenticator( const PrincipalAuthenticator& );
    void operator=( const PrincipalAuthenticator& );
};



/*
 * Base class and common definitions for interface PolicyCurrent
 */

class PolicyCurrent : 
  virtual public ::CORBA::Current
{
  public:
    virtual ~PolicyCurrent();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef PolicyCurrent_ptr _ptr_type;
    typedef PolicyCurrent_var _var_type;
    #endif

    static PolicyCurrent_ptr _narrow( CORBA::Object_ptr obj );
    static PolicyCurrent_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static PolicyCurrent_ptr _duplicate( PolicyCurrent_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static PolicyCurrent_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual void set_policy_overrides( const ::CORBA::PolicyList& policies, ::CORBA::SetOverrideType override_type ) = 0;
    virtual ::CORBA::PolicyList* get_policy_overrides( const ::CORBA::PolicyTypeSeq& policy_types ) = 0;

  protected:
    PolicyCurrent() {};
  private:
    PolicyCurrent( const PolicyCurrent& );
    void operator=( const PolicyCurrent& );
};



/*
 * Base class and common definitions for interface MechanismPolicy
 */

class MechanismPolicy : 
  virtual public ::CORBA::Policy
{
  public:
    virtual ~MechanismPolicy();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef MechanismPolicy_ptr _ptr_type;
    typedef MechanismPolicy_var _var_type;
    #endif

    static MechanismPolicy_ptr _narrow( CORBA::Object_ptr obj );
    static MechanismPolicy_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static MechanismPolicy_ptr _duplicate( MechanismPolicy_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static MechanismPolicy_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::Security::MechanismTypeList* mechanisms() = 0;

  protected:
    MechanismPolicy() {};
  private:
    MechanismPolicy( const MechanismPolicy& );
    void operator=( const MechanismPolicy& );
};



/*
 * Base class and common definitions for interface InvocationCredentialsPolicy
 */

class InvocationCredentialsPolicy : 
  virtual public ::CORBA::Policy
{
  public:
    virtual ~InvocationCredentialsPolicy();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef InvocationCredentialsPolicy_ptr _ptr_type;
    typedef InvocationCredentialsPolicy_var _var_type;
    #endif

    static InvocationCredentialsPolicy_ptr _narrow( CORBA::Object_ptr obj );
    static InvocationCredentialsPolicy_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static InvocationCredentialsPolicy_ptr _duplicate( InvocationCredentialsPolicy_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static InvocationCredentialsPolicy_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::SecurityLevel2::CredentialsList* creds() = 0;

  protected:
    InvocationCredentialsPolicy() {};
  private:
    InvocationCredentialsPolicy( const InvocationCredentialsPolicy& );
    void operator=( const InvocationCredentialsPolicy& );
};



/*
 * Base class and common definitions for interface QOPPolicy
 */

class QOPPolicy : 
  virtual public ::CORBA::Policy
{
  public:
    virtual ~QOPPolicy();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef QOPPolicy_ptr _ptr_type;
    typedef QOPPolicy_var _var_type;
    #endif

    static QOPPolicy_ptr _narrow( CORBA::Object_ptr obj );
    static QOPPolicy_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static QOPPolicy_ptr _duplicate( QOPPolicy_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static QOPPolicy_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::Security::QOP qop() = 0;

  protected:
    QOPPolicy() {};
  private:
    QOPPolicy( const QOPPolicy& );
    void operator=( const QOPPolicy& );
};



/*
 * Base class and common definitions for interface DelegationDirectivePolicy
 */

class DelegationDirectivePolicy : 
  virtual public ::CORBA::Policy
{
  public:
    virtual ~DelegationDirectivePolicy();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef DelegationDirectivePolicy_ptr _ptr_type;
    typedef DelegationDirectivePolicy_var _var_type;
    #endif

    static DelegationDirectivePolicy_ptr _narrow( CORBA::Object_ptr obj );
    static DelegationDirectivePolicy_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static DelegationDirectivePolicy_ptr _duplicate( DelegationDirectivePolicy_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static DelegationDirectivePolicy_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::Security::DelegationDirective delegation_mode() = 0;

  protected:
    DelegationDirectivePolicy() {};
  private:
    DelegationDirectivePolicy( const DelegationDirectivePolicy& );
    void operator=( const DelegationDirectivePolicy& );
};



/*
 * Base class and common definitions for interface EstablishTrustPolicy
 */

class EstablishTrustPolicy : 
  virtual public ::CORBA::Policy
{
  public:
    virtual ~EstablishTrustPolicy();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef EstablishTrustPolicy_ptr _ptr_type;
    typedef EstablishTrustPolicy_var _var_type;
    #endif

    static EstablishTrustPolicy_ptr _narrow( CORBA::Object_ptr obj );
    static EstablishTrustPolicy_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static EstablishTrustPolicy_ptr _duplicate( EstablishTrustPolicy_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static EstablishTrustPolicy_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::Security::EstablishTrust trust() = 0;

  protected:
    EstablishTrustPolicy() {};
  private:
    EstablishTrustPolicy( const EstablishTrustPolicy& );
    void operator=( const EstablishTrustPolicy& );
};



/*
 * Base class and common definitions for interface SecurityManager
 */

class SecurityManager : 
  virtual public CORBA::Object
{
  public:
    virtual ~SecurityManager();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef SecurityManager_ptr _ptr_type;
    typedef SecurityManager_var _var_type;
    #endif

    static SecurityManager_ptr _narrow( CORBA::Object_ptr obj );
    static SecurityManager_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static SecurityManager_ptr _duplicate( SecurityManager_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static SecurityManager_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::Security::MechandOptionsList* supported_mechanisms() = 0;
    virtual ::SecurityLevel2::PrincipalAuthenticator_ptr principal_authenticator() = 0;
    virtual ::SecurityLevel2::AuditDecision_ptr audit_decision() = 0;
    virtual ::SecurityLevel2::CredentialsList* own_credentials() = 0;
    virtual ::SecurityLevel2::AccessRights_ptr access_rights() = 0;
    virtual ::SecurityLevel2::AccessDecision_ptr access_decision() = 0;

    virtual void remove_own_credentials( Credentials_ptr creds ) = 0;
    virtual void set_own_credentials( const CredentialsList& creds ) = 0;
    virtual TargetCredentials_ptr get_target_credentials( CORBA::Object_ptr target ) = 0;
    virtual ::CORBA::Policy_ptr get_security_policy( ::CORBA::PolicyType policy_type ) = 0;
    virtual CORBA::Any* get_method_data( ::Security::AuthenticationMethod method ) = 0;

  protected:
    SecurityManager() {};
  private:
    SecurityManager( const SecurityManager& );
    void operator=( const SecurityManager& );
};



/*
 * Base class and common definitions for interface AuditChannel
 */

class AuditChannel : 
  virtual public CORBA::Object
{
  public:
    virtual ~AuditChannel();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef AuditChannel_ptr _ptr_type;
    typedef AuditChannel_var _var_type;
    #endif

    static AuditChannel_ptr _narrow( CORBA::Object_ptr obj );
    static AuditChannel_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static AuditChannel_ptr _duplicate( AuditChannel_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static AuditChannel_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::Security::AuditChannelId audit_channel_id() = 0;

    virtual void audit_write( const ::Security::AuditEventType& event_type, const CredentialsList& creds, const ::Security::UtcT& time, const ::Security::SelectorValueList& descriptors, const ::Security::Opaque& event_specific_data ) = 0;

  protected:
    AuditChannel() {};
  private:
    AuditChannel( const AuditChannel& );
    void operator=( const AuditChannel& );
};


}


#ifndef MICO_CONF_NO_POA

#endif // MICO_CONF_NO_POA

#endif