transportsecurity.h

MICO2.3.13 corba 环境平台

    virtual ::SL3PM::ResourceNameList* client_restricted_resources() = 0;
    virtual ::SL3PM::Principal* target_principal() = 0;
    virtual ::SL3PM::StatementList* target_supporting_statements() = 0;
    virtual ::SL3PM::ResourceNameList* target_restricted_resources() = 0;
    virtual ::SL3PM::PrinAttributeList* environmental_attributes() = 0;
    virtual ::TransportSecurity::OwnCredentials_ptr parent_credentials() = 0;
    virtual CORBA::Boolean client_authentication() = 0;
    virtual CORBA::Boolean target_authentication() = 0;
    virtual CORBA::Boolean confidentiality() = 0;
    virtual CORBA::Boolean integrity() = 0;
    virtual CORBA::Boolean impersonable() = 0;
    virtual CORBA::Boolean endorseable() = 0;
    virtual CORBA::Boolean quotable() = 0;

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



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

class TargetCredentials : 
  virtual public ::TransportSecurity::TransportCredentials
{
  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 char* context_id() = 0;
    virtual ::SL3PM::Principal* client_principal() = 0;
    virtual ::SL3PM::StatementList* client_supporting_statements() = 0;
    virtual ::SL3PM::ResourceNameList* client_restricted_resources() = 0;
    virtual ::SL3PM::Principal* target_principal() = 0;
    virtual ::SL3PM::StatementList* target_supporting_statements() = 0;
    virtual ::SL3PM::ResourceNameList* target_restricted_resources() = 0;
    virtual ::SL3PM::PrinAttributeList* environmental_attributes() = 0;
    virtual ::TransportSecurity::OwnCredentials_ptr parent_credentials() = 0;
    virtual CORBA::Boolean client_authentication() = 0;
    virtual CORBA::Boolean target_authentication() = 0;
    virtual CORBA::Boolean confidentiality() = 0;
    virtual CORBA::Boolean integrity() = 0;
    virtual CORBA::Boolean target_embodied() = 0;
    virtual CORBA::Boolean target_endorsed() = 0;

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



/*
 * Base class and common definitions for local interface CredentialsAcquirer
 */

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

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CredentialsAcquirer_ptr _ptr_type;
    typedef CredentialsAcquirer_var _var_type;
    #endif

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

    static CredentialsAcquirer_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::TransportSecurity::OwnCredentials_ptr get_credentials( CORBA::Boolean on_list ) = 0;
    virtual void destroy() = 0;

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



/*
 * Base class and common definitions for local interface CredentialsCurator
 */

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

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CredentialsCurator_ptr _ptr_type;
    typedef CredentialsCurator_var _var_type;
    #endif

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

    static CredentialsCurator_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::TransportSecurity::OwnCredentialsList* default_creds_list() = 0;

    virtual ::TransportSecurity::CredentialsAcquirer_ptr acquire_credentials( ::SL3AQArgs::Argument_ptr acquisition_arguments ) = 0;
    virtual ::TransportSecurity::OwnCredentials_ptr get_own_credentials( const char* creds_id ) = 0;
    virtual void remove_credentials( const char* creds_id ) = 0;
    virtual void release_credentials( const char* creds_id ) = 0;

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



/*
 * Base class and common definitions for local interface ContextEstablishmentPolicy
 */

class ContextEstablishmentPolicy : 
  virtual public CORBA::Object,
  virtual public ::CORBA::Policy
{
  public:
    virtual ~ContextEstablishmentPolicy();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef ContextEstablishmentPolicy_ptr _ptr_type;
    typedef ContextEstablishmentPolicy_var _var_type;
    #endif

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

    static ContextEstablishmentPolicy_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::TransportSecurity::OwnCredentialsList* creds_list() = 0;
    virtual ::SL3CM::CredsDirective creds_directive() = 0;
    virtual ::SL3CM::FeatureDirective use_client_auth() = 0;
    virtual ::SL3CM::FeatureDirective use_target_auth() = 0;
    virtual ::SL3CM::FeatureDirective use_confidentiality() = 0;
    virtual ::SL3CM::FeatureDirective use_integrity() = 0;

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



/*
 * Base class and common definitions for local interface ObjectCredentialsPolicy
 */

class ObjectCredentialsPolicy : 
  virtual public CORBA::Object,
  virtual public ::CORBA::Policy
{
  public:
    virtual ~ObjectCredentialsPolicy();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef ObjectCredentialsPolicy_ptr _ptr_type;
    typedef ObjectCredentialsPolicy_var _var_type;
    #endif

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

    static ObjectCredentialsPolicy_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::TransportSecurity::OwnCredentialsList* creds_list() = 0;

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



/*
 * Base class and common definitions for local 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 ::TransportSecurity::CredentialsCurator_ptr credentials_curator() = 0;

    virtual ::TransportSecurity::TargetCredentials_ptr get_target_credentials( CORBA::Object_ptr the_object ) = 0;
    virtual ::TransportSecurity::ContextEstablishmentPolicy_ptr create_context_estab_policy( ::SL3CM::CredsDirective creds_directive, const ::TransportSecurity::OwnCredentialsList& creds_list, ::SL3CM::FeatureDirective use_client_auth, ::SL3CM::FeatureDirective use_target_auth, ::SL3CM::FeatureDirective use_confidentiality, ::SL3CM::FeatureDirective use_integrity ) = 0;
    virtual ::TransportSecurity::ObjectCredentialsPolicy_ptr create_object_creds_policy( const ::TransportSecurity::OwnCredentialsList& creds_list ) = 0;

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



/*
 * Base class and common definitions for local interface SecurityCurrent
 */

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

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef SecurityCurrent_ptr _ptr_type;
    typedef SecurityCurrent_var _var_type;
    #endif

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

    static SecurityCurrent_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::TransportSecurity::ClientCredentials_ptr client_credentials() = 0;

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


const ::CORBA::PolicyType ContextEstablishmentPolicyType = 168937425;
const ::CORBA::PolicyType ObjectCredentialsPolicyType = 168937426;
}


#ifndef MICO_CONF_NO_POA

#endif // MICO_CONF_NO_POA

#endif