sl3aqargs_p.h

MICO2.3.13 corba 环境平台

  CORBA::Long high_port;
  CORBA::Long backlog;
  CORBA::Boolean numeric;
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_TCPIPAcceptorOptions;

const char* const TCPIPAcceptorArgumentType = "TCPIPAcceptorArgument";

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

class TCPIPAcceptorArgument : 
  virtual public ::SL3AQArgs::Argument
{
  public:
    virtual ~TCPIPAcceptorArgument();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef TCPIPAcceptorArgument_ptr _ptr_type;
    typedef TCPIPAcceptorArgument_var _var_type;
    #endif

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

    static TCPIPAcceptorArgument_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::SL3AQArgs::TCPIPAcceptorOptions* options() = 0;

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


const char* const TLSX509IdentityVerifierInitiatorArgumentType = "TLSX509IdentityVerifierInitiatorArgument";

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

class TLSX509IdentityVerifierInitiatorArgument : 
  virtual public ::SL3AQArgs::Argument
{
  public:
    virtual ~TLSX509IdentityVerifierInitiatorArgument();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef TLSX509IdentityVerifierInitiatorArgument_ptr _ptr_type;
    typedef TLSX509IdentityVerifierInitiatorArgument_var _var_type;
    #endif

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

    static TLSX509IdentityVerifierInitiatorArgument_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::SL3TLS::TLSX509IdentityVerifier_ptr verifier() = 0;

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


const char* const TLSX509IdentityVerifierAcceptorArgumentType = "TLSX509IdentityVerifierAcceptorArgument";

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

class TLSX509IdentityVerifierAcceptorArgument : 
  virtual public ::SL3AQArgs::Argument
{
  public:
    virtual ~TLSX509IdentityVerifierAcceptorArgument();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef TLSX509IdentityVerifierAcceptorArgument_ptr _ptr_type;
    typedef TLSX509IdentityVerifierAcceptorArgument_var _var_type;
    #endif

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

    static TLSX509IdentityVerifierAcceptorArgument_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::SL3TLS::TLSX509IdentityVerifier_ptr verifier() = 0;

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


struct OpenSSLConfig;
typedef TVarVar< OpenSSLConfig > OpenSSLConfig_var;
typedef TVarOut< OpenSSLConfig > OpenSSLConfig_out;


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

  CORBA::String_var cert_file;
  CORBA::String_var key_file;
  CORBA::String_var ca_file;
  CORBA::String_var ca_path;
  CORBA::String_var cipher;
  CORBA::Boolean use_passphrase;
  CORBA::String_var passphrase;
  CORBA::Long verify_depth;
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_OpenSSLConfig;

const char* const OpenSSLInitiatorArgumentType = "OpenSSLInitiatorArgument";

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

class OpenSSLInitiatorArgument : 
  virtual public ::SL3AQArgs::Argument
{
  public:
    virtual ~OpenSSLInitiatorArgument();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef OpenSSLInitiatorArgument_ptr _ptr_type;
    typedef OpenSSLInitiatorArgument_var _var_type;
    #endif

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

    static OpenSSLInitiatorArgument_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::SL3AQArgs::OpenSSLConfig* config() = 0;

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


const char* const OpenSSLAcceptorArgumentType = "OpenSSLAcceptorArgument";

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

class OpenSSLAcceptorArgument : 
  virtual public ::SL3AQArgs::Argument
{
  public:
    virtual ~OpenSSLAcceptorArgument();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef OpenSSLAcceptorArgument_ptr _ptr_type;
    typedef OpenSSLAcceptorArgument_var _var_type;
    #endif

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

    static OpenSSLAcceptorArgument_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::SL3AQArgs::OpenSSLConfig* config() = 0;

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


const char* const TransportCredentialsArgumentType = "TransportCredentialsArgument";

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

class TransportCredentialsArgument : 
  virtual public ::SL3AQArgs::Argument
{
  public:
    virtual ~TransportCredentialsArgument();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef TransportCredentialsArgument_ptr _ptr_type;
    typedef TransportCredentialsArgument_var _var_type;
    #endif

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

    static TransportCredentialsArgument_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::TransportSecurity::OwnCredentials_ptr creds() = 0;

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


const char* const DeciderArgumentType = "LocalTrustInServerDeciderArgument";

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

class DeciderArgument : 
  virtual public ::SL3AQArgs::Argument
{
  public:
    virtual ~DeciderArgument();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef DeciderArgument_ptr _ptr_type;
    typedef DeciderArgument_var _var_type;
    #endif

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

    static DeciderArgument_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::Trust::LocalTrustInServerDecider_ptr decider() = 0;

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


const char* const GeneratorArgumentType = "UserPasswordGenerator";

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

class GeneratorArgument : 
  virtual public ::SL3AQArgs::Argument
{
  public:
    virtual ~GeneratorArgument();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef GeneratorArgument_ptr _ptr_type;
    typedef GeneratorArgument_var _var_type;
    #endif

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

    static GeneratorArgument_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::UserPassword::PasswordGenerator_ptr generator() = 0;

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