transportsecurity_p.h

MICO2.3.13 corba 环境平台

    }

    virtual void *_narrow_helper( const char *repoid );

    virtual void enable_transport_acceptors() = 0;

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



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

class TransportOwnCredentials : 
  virtual public ::TransportSecurity::OwnCredentials
{
  public:
    virtual ~TransportOwnCredentials();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef TransportOwnCredentials_ptr _ptr_type;
    typedef TransportOwnCredentials_var _var_type;
    #endif

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

    static TransportOwnCredentials_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

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



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

class TransportInitiator : 
  virtual public ::TransportSecurity::CredentialsInitiator
{
  public:
    virtual ~TransportInitiator();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef TransportInitiator_ptr _ptr_type;
    typedef TransportInitiator_var _var_type;
    #endif

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

    static TransportInitiator_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::TransportSecurity::ContextEstablisherList* context_establishers() = 0;
    virtual char* host() = 0;
    virtual CORBA::ULong low_port() = 0;
    virtual CORBA::ULong high_port() = 0;

    virtual void increment_work() = 0;
    virtual void decrement_work() = 0;
    virtual CORBA::Boolean supports_invoc_options( ::CSIIOP::AssociationOptions invocation_options_supported, ::CSIIOP::AssociationOptions invocation_options_required ) = 0;
    virtual CORBA::Boolean supports_csi_version( ::TransportSecurity::CSIVersion csi_version ) = 0;
    virtual CORBA::Boolean is_usable( const char* host, CORBA::ULong port, ::SL3CM::CredsDirective creds_directive, ::SL3CM::FeatureDirective client_authentication, ::SL3CM::FeatureDirective target_authentication, ::SL3CM::FeatureDirective confidentiality, ::SL3CM::FeatureDirective integrity, ::TransportSecurity::CSIVersion csi_version, const ::IOP::TaggedComponentSeq& transport_components ) = 0;
    virtual ::TransportSecurity::ContextEstablisherList* create_context_establishers( const char* host, CORBA::ULong port, ::SL3CM::CredsDirective creds_directive, ::SL3CM::FeatureDirective client_authentication, ::SL3CM::FeatureDirective target_authentication, ::SL3CM::FeatureDirective confidentiality, ::SL3CM::FeatureDirective integrity, ::TransportSecurity::CSIVersion csi_version, const ::IOP::TaggedComponentSeq& transport_components ) = 0;
    virtual ::TransportSecurity::ContextEstablisher_ptr get_context_establisher( const char* id ) = 0;

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



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

class TransportAcceptor : 
  virtual public ::TransportSecurity::CredentialsAcceptor
{
  public:
    virtual ~TransportAcceptor();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef TransportAcceptor_ptr _ptr_type;
    typedef TransportAcceptor_var _var_type;
    #endif

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

    static TransportAcceptor_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::CORBA::StringSeq* hosts() = 0;
    virtual CORBA::ULong port() = 0;
    virtual ::CSIIOP::AssociationOptions options_required() = 0;
    virtual ::CSIIOP::AssociationOptions options_supported() = 0;

    virtual void increment_work() = 0;
    virtual void decrement_work() = 0;
    virtual ::IOP::TaggedComponentSeq* transport_components( ::TransportSecurity::CSIVersion csi_version ) = 0;
    virtual CORBA::Boolean transport_matches( const char* host, CORBA::ULong port, const ::IOP::TaggedComponentSeq& transport_components ) = 0;
    virtual ::TransportSecurity::AcceptingContext_ptr accept( CORBA::Boolean block ) = 0;
    virtual void shutdown() = 0;
    virtual void enable() = 0;

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


struct IdentityTokenInfo;
typedef TVarVar< IdentityTokenInfo > IdentityTokenInfo_var;
typedef TVarOut< IdentityTokenInfo > IdentityTokenInfo_out;


struct IdentityTokenInfo {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef IdentityTokenInfo_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  IdentityTokenInfo();
  ~IdentityTokenInfo();
  IdentityTokenInfo( const IdentityTokenInfo& s );
  IdentityTokenInfo& operator=( const IdentityTokenInfo& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  CORBA::Boolean is_absent;
  CORBA::Boolean is_anonymous;
  ::CSI::IdentityToken the_token;
  ::SL3PM::SimplePrincipal_var the_principal;
  ::SL3PM::IdentityStatement_var the_statement;
  // we contain a valuetype
  CORBA::Long _count_refs (CORBA::ValueBase::visited * = 0);
  void _release_members ();
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_IdentityTokenInfo;


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

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

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef IdentityTokenGenerator_ptr _ptr_type;
    typedef IdentityTokenGenerator_var _var_type;
    #endif

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

    static IdentityTokenGenerator_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::SL3PM::SimplePrincipal* the_principal() = 0;
    virtual ::SL3PM::IdentityStatement* the_statement() = 0;
    virtual CORBA::Boolean generate_identity( ::CSI::IdentityTokenType id_token_types, const ::CSI::OIDList& gss_naming_mechs, ::TransportSecurity::IdentityTokenInfo_out identity_token_info ) = 0;
    virtual void destroy() = 0;

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



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

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

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CredentialsAcquirerFactory_ptr _ptr_type;
    typedef CredentialsAcquirerFactory_var _var_type;
    #endif

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

    static CredentialsAcquirerFactory_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::TransportSecurity::CredentialsAcquirer_ptr create( ::SL3AQArgs::Argument_ptr value ) = 0;
    virtual CORBA::Boolean supports_all_args( ::SL3AQArgs::Argument_ptr value ) = 0;

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


}


#ifndef MICO_CONF_NO_POA

#endif // MICO_CONF_NO_POA

void operator<<=( CORBA::Any &_a, const ::TransportSecurity::IdentityTokenInfo &_s );
void operator<<=( CORBA::Any &_a, ::TransportSecurity::IdentityTokenInfo *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::TransportSecurity::IdentityTokenInfo &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::TransportSecurity::IdentityTokenInfo *&_s );

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_TransportSecurity_IdentityTokenInfo;

#endif