security.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 __SECURITY_H__
#define __SECURITY_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 Security
{

typedef char* SecurityName;
typedef CORBA::String_var SecurityName_var;
typedef CORBA::String_out SecurityName_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_SecurityName;

typedef SequenceTmpl< CORBA::Octet,MICO_TID_OCTET> Opaque;
typedef TSeqVar< SequenceTmpl< CORBA::Octet,MICO_TID_OCTET> > Opaque_var;
typedef TSeqOut< SequenceTmpl< CORBA::Octet,MICO_TID_OCTET> > Opaque_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_Opaque;

const ::CORBA::ServiceOption SecurityLevel1 = 1;
const ::CORBA::ServiceOption SecurityLevel2 = 2;
const ::CORBA::ServiceOption NonRepudiation = 3;
const ::CORBA::ServiceOption SecurityORBServiceReady = 4;
const ::CORBA::ServiceOption SecurityServiceReady = 5;
const ::CORBA::ServiceOption ReplaceORBServices = 6;
const ::CORBA::ServiceOption ReplaceSecurityServices = 7;
const ::CORBA::ServiceOption StandardSecureInteroperability = 8;
const ::CORBA::ServiceOption DCESecureInteroperability = 9;
const ::CORBA::ServiceOption CommonInteroperabilityLevel0 = 10;
const ::CORBA::ServiceOption CommonInteroperabilityLevel1 = 11;
const ::CORBA::ServiceOption CommonInteroperabilityLevel2 = 12;
const ::CORBA::ServiceDetailType SecurityMechanismType = 1;
const ::CORBA::ServiceDetailType SecurityAttribute = 2;
struct ExtensibleFamily;
typedef TFixVar< ExtensibleFamily > ExtensibleFamily_var;
typedef ExtensibleFamily& ExtensibleFamily_out;


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

  CORBA::UShort family_definer;
  CORBA::UShort family;
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_ExtensibleFamily;

typedef CORBA::ULong SecurityAttributeType;
typedef SecurityAttributeType& SecurityAttributeType_out;
extern MICO_EXPORT CORBA::TypeCodeConst _tc_SecurityAttributeType;

const SecurityAttributeType AuditId = 1;
const SecurityAttributeType AccountingId = 2;
const SecurityAttributeType NonRepudiationId = 3;
const SecurityAttributeType Public = 1;
const SecurityAttributeType AccessId = 2;
const SecurityAttributeType PrimaryGroupId = 3;
const SecurityAttributeType GroupId = 4;
const SecurityAttributeType Role = 5;
const SecurityAttributeType AttributeSet = 6;
const SecurityAttributeType Clearance = 7;
const SecurityAttributeType Capability = 8;
const SecurityAttributeType X509Subject = 1;
const SecurityAttributeType X509Issuer = 2;
const SecurityAttributeType X509Cipher = 3;
const SecurityAttributeType X509Subject_CN = 4;
const SecurityAttributeType X509Subject_C = 5;
const SecurityAttributeType X509Subject_L = 6;
const SecurityAttributeType X509Subject_ST = 7;
const SecurityAttributeType X509Subject_O = 8;
const SecurityAttributeType X509Subject_OU = 9;
const SecurityAttributeType X509Issuer_CN = 10;
const SecurityAttributeType X509Issuer_C = 11;
const SecurityAttributeType X509Issuer_L = 12;
const SecurityAttributeType X509Issuer_ST = 13;
const SecurityAttributeType X509Issuer_O = 14;
const SecurityAttributeType X509Issuer_OU = 15;
const SecurityAttributeType AuthMethod = 1;
const SecurityAttributeType PeerAddress = 2;
struct AttributeType;
typedef TFixVar< AttributeType > AttributeType_var;
typedef AttributeType& AttributeType_out;


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

  ExtensibleFamily attribute_family;
  SecurityAttributeType attribute_type;
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_AttributeType;

typedef SequenceTmpl< AttributeType,MICO_TID_DEF> AttributeTypeList;
typedef TSeqVar< SequenceTmpl< AttributeType,MICO_TID_DEF> > AttributeTypeList_var;
typedef TSeqOut< SequenceTmpl< AttributeType,MICO_TID_DEF> > AttributeTypeList_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_AttributeTypeList;

struct SecAttribute;
typedef TVarVar< SecAttribute > SecAttribute_var;
typedef TVarOut< SecAttribute > SecAttribute_out;


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

  AttributeType attribute_type;
  ::CSI::OID defining_authority;
  Opaque value;
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_SecAttribute;

typedef SequenceTmpl< SecAttribute,MICO_TID_DEF> AttributeList;
typedef TSeqVar< SequenceTmpl< SecAttribute,MICO_TID_DEF> > AttributeList_var;
typedef TSeqOut< SequenceTmpl< SecAttribute,MICO_TID_DEF> > AttributeList_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_AttributeList;

enum AuthenticationStatus {
  SecAuthSuccess = 0,
  SecAuthFailure,
  SecAuthContinue,
  SecAuthExpired
};

typedef AuthenticationStatus& AuthenticationStatus_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_AuthenticationStatus;

enum AssociationStatus {
  SecAssocSuccess = 0,
  SecAssocFailure,
  SecAssocContinue
};

typedef AssociationStatus& AssociationStatus_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_AssociationStatus;

typedef CORBA::ULong AuthenticationMethod;
typedef AuthenticationMethod& AuthenticationMethod_out;
extern MICO_EXPORT CORBA::TypeCodeConst _tc_AuthenticationMethod;

typedef SequenceTmpl< AuthenticationMethod,MICO_TID_DEF> AuthenticationMethodList;
typedef TSeqVar< SequenceTmpl< AuthenticationMethod,MICO_TID_DEF> > AuthenticationMethodList_var;
typedef TSeqOut< SequenceTmpl< AuthenticationMethod,MICO_TID_DEF> > AuthenticationMethodList_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_AuthenticationMethodList;

enum CredentialsType {
  SecOwnCredentials = 0,
  SecReceivedCredentials,
  SecTargetCredentials
};

typedef CredentialsType& CredentialsType_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_CredentialsType;

struct ChannelBindings;
typedef TVarVar< ChannelBindings > ChannelBindings_var;
typedef TVarOut< ChannelBindings > ChannelBindings_out;


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

  CORBA::ULong initiator_addrtype;
  typedef SequenceTmpl< CORBA::Octet,MICO_TID_OCTET> _initiator_address_seq;
  _initiator_address_seq initiator_address;
  CORBA::ULong acceptor_addrtype;
  typedef SequenceTmpl< CORBA::Octet,MICO_TID_OCTET> _acceptor_address_seq;
  _acceptor_address_seq acceptor_address;
  typedef SequenceTmpl< CORBA::Octet,MICO_TID_OCTET> _application_data_seq;
  _application_data_seq application_data;
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_ChannelBindings;

struct Right;
typedef TVarVar< Right > Right_var;
typedef TVarOut< Right > Right_out;


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

  ExtensibleFamily rights_family;
  CORBA::String_var rights_list;
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_Right;

typedef SequenceTmpl< Right,MICO_TID_DEF> RightsList;
typedef TSeqVar< SequenceTmpl< Right,MICO_TID_DEF> > RightsList_var;
typedef TSeqOut< SequenceTmpl< Right,MICO_TID_DEF> > RightsList_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_RightsList;

enum RightsCombinator {
  SecAllRights = 0,
  SecAnyRight
};

typedef RightsCombinator& RightsCombinator_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_RightsCombinator;

enum DelegationState {
  SecInitiator = 0,
  SecDelegate
};

typedef DelegationState& DelegationState_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_DelegationState;

enum DelegationDirective {
  Delegate = 0,
  NoDelegate
};

typedef DelegationDirective& DelegationDirective_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_DelegationDirective;

typedef ::TimeBase::UtcT UtcT;
typedef ::TimeBase::UtcT_var UtcT_var;
typedef ::TimeBase::UtcT_out UtcT_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_UtcT;

typedef ::TimeBase::IntervalT IntervalT;
typedef ::TimeBase::IntervalT_var IntervalT_var;
typedef ::TimeBase::IntervalT_out IntervalT_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_IntervalT;

typedef ::TimeBase::TimeT TimeT;
typedef TimeT& TimeT_out;
extern MICO_EXPORT CORBA::TypeCodeConst _tc_TimeT;

enum SecurityFeature {
  SecNoDelegation = 0,
  SecSimpleDelegation,
  SecCompositeDelegation,
  SecNoProtection,
  SecIntegrity,