securitylevel3.h

MICO2.3.13 corba 环境平台

/*
 *  MICO --- an Open Source CORBA implementation
 *  Copyright (c) 1997-2006 by The Mico Team
 *
 *  This file was automatically generated. DO NOT EDIT!
 */

#include <CORBA.h>

#ifndef __SECURITYLEVEL3_H__
#define __SECURITYLEVEL3_H__


#ifdef _WIN32
#ifdef BUILD_MICO_DLL
#define MICO_EXPORT /**/
#else // BUILD_MICO_DLL
#define MICO_EXPORT __declspec(dllimport)
#endif // BUILD_MICO_DLL
#else // _WIN32
#define MICO_EXPORT /**/
#endif // _WIN32




namespace SecurityLevel3
{

class CredsInitiator;
typedef CredsInitiator *CredsInitiator_ptr;
typedef CredsInitiator_ptr CredsInitiatorRef;
typedef ObjVar< CredsInitiator > CredsInitiator_var;
typedef ObjOut< CredsInitiator > CredsInitiator_out;

class CredsAcceptor;
typedef CredsAcceptor *CredsAcceptor_ptr;
typedef CredsAcceptor_ptr CredsAcceptorRef;
typedef ObjVar< CredsAcceptor > CredsAcceptor_var;
typedef ObjOut< CredsAcceptor > CredsAcceptor_out;

class Credentials;
typedef Credentials *Credentials_ptr;
typedef Credentials_ptr CredentialsRef;
typedef ObjVar< Credentials > Credentials_var;
typedef ObjOut< Credentials > Credentials_out;

class OwnCredentials;
typedef OwnCredentials *OwnCredentials_ptr;
typedef OwnCredentials_ptr OwnCredentialsRef;
typedef ObjVar< OwnCredentials > OwnCredentials_var;
typedef ObjOut< OwnCredentials > OwnCredentials_out;

class ClientCredentials;
typedef ClientCredentials *ClientCredentials_ptr;
typedef ClientCredentials_ptr ClientCredentialsRef;
typedef ObjVar< ClientCredentials > ClientCredentials_var;
typedef ObjOut< ClientCredentials > ClientCredentials_out;

class TargetCredentials;
typedef TargetCredentials *TargetCredentials_ptr;
typedef TargetCredentials_ptr TargetCredentialsRef;
typedef ObjVar< TargetCredentials > TargetCredentials_var;
typedef ObjOut< TargetCredentials > TargetCredentials_out;

class ContextEstablishmentPolicy;
typedef ContextEstablishmentPolicy *ContextEstablishmentPolicy_ptr;
typedef ContextEstablishmentPolicy_ptr ContextEstablishmentPolicyRef;
typedef ObjVar< ContextEstablishmentPolicy > ContextEstablishmentPolicy_var;
typedef ObjOut< ContextEstablishmentPolicy > ContextEstablishmentPolicy_out;

class ObjectCredentialsPolicy;
typedef ObjectCredentialsPolicy *ObjectCredentialsPolicy_ptr;
typedef ObjectCredentialsPolicy_ptr ObjectCredentialsPolicyRef;
typedef ObjVar< ObjectCredentialsPolicy > ObjectCredentialsPolicy_var;
typedef ObjOut< ObjectCredentialsPolicy > ObjectCredentialsPolicy_out;

class CredentialsAcquirer;
typedef CredentialsAcquirer *CredentialsAcquirer_ptr;
typedef CredentialsAcquirer_ptr CredentialsAcquirerRef;
typedef ObjVar< CredentialsAcquirer > CredentialsAcquirer_var;
typedef ObjOut< CredentialsAcquirer > CredentialsAcquirer_out;

class CredentialsCurator;
typedef CredentialsCurator *CredentialsCurator_ptr;
typedef CredentialsCurator_ptr CredentialsCuratorRef;
typedef ObjVar< CredentialsCurator > CredentialsCurator_var;
typedef ObjOut< CredentialsCurator > CredentialsCurator_out;

class SecurityManager;
typedef SecurityManager *SecurityManager_ptr;
typedef SecurityManager_ptr SecurityManagerRef;
typedef ObjVar< SecurityManager > SecurityManager_var;
typedef ObjOut< SecurityManager > SecurityManager_out;

class SecurityCurrent;
typedef SecurityCurrent *SecurityCurrent_ptr;
typedef SecurityCurrent_ptr SecurityCurrentRef;
typedef ObjVar< SecurityCurrent > SecurityCurrent_var;
typedef ObjOut< SecurityCurrent > SecurityCurrent_out;

}






namespace SecurityLevel3
{

const CORBA::ULong ADIRON_VMCID = 168935424UL;
typedef CORBA::ULong InitiatorType;
typedef InitiatorType& InitiatorType_out;
extern MICO_EXPORT CORBA::TypeCodeConst _tc_InitiatorType;

const InitiatorType IT_None = 0;
const InitiatorType IT_Simple = 1;
const InitiatorType IT_Quoting = 2;
const InitiatorType IT_Proxy = 3;

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

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

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CredsInitiator_ptr _ptr_type;
    typedef CredsInitiator_var _var_type;
    #endif

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

    static CredsInitiator_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::SL3PM::Principal* the_principal() = 0;
    virtual ::SL3PM::StatementList* supporting_statements() = 0;
    virtual ::SL3PM::ResourceNameList* restricted_resources() = 0;
    virtual ::SL3PM::PrinAttributeList* environmental_attributes() = 0;
    virtual ::SecurityLevel3::InitiatorType initiator_type() = 0;
    virtual CORBA::Boolean supports_embodiment() = 0;
    virtual CORBA::Boolean supports_endorsement() = 0;
    virtual CORBA::Boolean supports_quoting() = 0;
    virtual ::TimeBase::UtcT expiry_time() = 0;

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



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

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

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CredsAcceptor_ptr _ptr_type;
    typedef CredsAcceptor_var _var_type;
    #endif

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

    static CredsAcceptor_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::SL3PM::Principal* the_principal() = 0;
    virtual ::SL3PM::StatementList* supporting_statements() = 0;
    virtual ::SL3PM::ResourceNameList* restricted_resources() = 0;
    virtual ::SL3PM::PrinAttributeList* environmental_attributes() = 0;
    virtual CORBA::Boolean accepts_endorsement() = 0;
    virtual CORBA::Boolean accepts_quoting() = 0;
    virtual ::TimeBase::UtcT expiry_time() = 0;

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



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

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

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef Credentials_ptr _ptr_type;
    typedef Credentials_var _var_type;
    #endif

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

    static Credentials_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual char* creds_id() = 0;
    virtual ::SL3CM::CredentialsType creds_type() = 0;
    virtual ::SL3CM::CredentialsUsage creds_usage() = 0;
    virtual ::SL3CM::CredentialsState creds_state() = 0;

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


typedef IfaceSequenceTmpl< Credentials_var,Credentials_ptr> CredentialsList;
typedef TSeqVar< IfaceSequenceTmpl< Credentials_var,Credentials_ptr> > CredentialsList_var;
typedef TSeqOut< IfaceSequenceTmpl< Credentials_var,Credentials_ptr> > CredentialsList_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_CredentialsList;


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

class OwnCredentials : 
  virtual public ::SecurityLevel3::Credentials
{
  public:
    virtual ~OwnCredentials();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef OwnCredentials_ptr _ptr_type;
    typedef OwnCredentials_var _var_type;
    #endif

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

    static OwnCredentials_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::SecurityLevel3::CredsInitiator_ptr creds_initiator() = 0;
    virtual ::SecurityLevel3::CredsAcceptor_ptr creds_acceptor() = 0;

    virtual void release_credentials() = 0;

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


typedef IfaceSequenceTmpl< OwnCredentials_var,OwnCredentials_ptr> OwnCredentialsList;
typedef TSeqVar< IfaceSequenceTmpl< OwnCredentials_var,OwnCredentials_ptr> > OwnCredentialsList_var;
typedef TSeqOut< IfaceSequenceTmpl< OwnCredentials_var,OwnCredentials_ptr> > OwnCredentialsList_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_OwnCredentialsList;


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

class ClientCredentials : 
  virtual public ::SecurityLevel3::Credentials
{
  public:
    virtual ~ClientCredentials();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef ClientCredentials_ptr _ptr_type;
    typedef ClientCredentials_var _var_type;
    #endif

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

    static ClientCredentials_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;