security.h

MICO2.3.13 corba 环境平台

  SecConfidentiality,
  SecIntegrityAndConfidentiality,
  SecDetectReplay,
  SecDetectMisordering,
  SecEstablishTrustInTarget,
  SecEstablishTrustInClient
};

typedef SecurityFeature& SecurityFeature_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_SecurityFeature;

enum QOP {
  SecQOPNoProtection = 0,
  SecQOPIntegrity,
  SecQOPConfidentiality,
  SecQOPIntegrityAndConfidentiality
};

typedef QOP& QOP_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_QOP;

enum SecurityContextType {
  ClientSecurityContext = 0,
  ServerSecurityContext
};

typedef SecurityContextType& SecurityContextType_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_SecurityContextType;

enum SecurityContextState {
  SecContextInitialized = 0,
  SecContextContinued,
  SecContextClientEstablished,
  SecContextEstablished,
  SecContextEstablishExpired,
  SecContextExpired,
  SecContextInvalid
};

typedef SecurityContextState& SecurityContextState_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_SecurityContextState;

struct OpaqueBuffer;
typedef TVarVar< OpaqueBuffer > OpaqueBuffer_var;
typedef TVarOut< OpaqueBuffer > OpaqueBuffer_out;


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

  Opaque buffer;
  CORBA::ULong startpos;
  CORBA::ULong endpos;
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_OpaqueBuffer;

typedef CORBA::UShort AssociationOptions;
typedef AssociationOptions& AssociationOptions_out;
extern MICO_EXPORT CORBA::TypeCodeConst _tc_AssociationOptions;

const AssociationOptions NoProtection = 1;
const AssociationOptions Integrity = 2;
const AssociationOptions Confidentiality = 4;
const AssociationOptions DetectReplay = 8;
const AssociationOptions DetectMisordering = 16;
const AssociationOptions EstablishTrustInTarget = 32;
const AssociationOptions EstablishTrustInClient = 64;
const AssociationOptions NoDelegation = 128;
const AssociationOptions SimpleDelegation = 256;
const AssociationOptions CompositeDelegation = 512;
enum RequiresSupports {
  SecRequires = 0,
  SecSupports
};

typedef RequiresSupports& RequiresSupports_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_RequiresSupports;

enum CommunicationDirection {
  SecDirectionBoth = 0,
  SecDirectionRequest,
  SecDirectionReply
};

typedef CommunicationDirection& CommunicationDirection_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_CommunicationDirection;

struct OptionsDirectionPair;
typedef TFixVar< OptionsDirectionPair > OptionsDirectionPair_var;
typedef OptionsDirectionPair& OptionsDirectionPair_out;


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

  AssociationOptions options;
  CommunicationDirection direction;
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_OptionsDirectionPair;

typedef SequenceTmpl< OptionsDirectionPair,MICO_TID_DEF> OptionsDirectionPairList;
typedef TSeqVar< SequenceTmpl< OptionsDirectionPair,MICO_TID_DEF> > OptionsDirectionPairList_var;
typedef TSeqOut< SequenceTmpl< OptionsDirectionPair,MICO_TID_DEF> > OptionsDirectionPairList_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_OptionsDirectionPairList;

enum DelegationMode {
  SecDelModeNoDelegation = 0,
  SecDelModeSimpleDelegation,
  SecDelModeCompositeDelegation
};

typedef DelegationMode& DelegationMode_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_DelegationMode;

typedef char* MechanismType;
typedef CORBA::String_var MechanismType_var;
typedef CORBA::String_out MechanismType_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_MechanismType;

typedef StringSequenceTmpl<CORBA::String_var> MechanismTypeList;
typedef TSeqVar< StringSequenceTmpl<CORBA::String_var> > MechanismTypeList_var;
typedef TSeqOut< StringSequenceTmpl<CORBA::String_var> > MechanismTypeList_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_MechanismTypeList;

struct SecurityMechanismData;
typedef TVarVar< SecurityMechanismData > SecurityMechanismData_var;
typedef TVarOut< SecurityMechanismData > SecurityMechanismData_out;


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

  MechanismType_var mechanism;
  SecurityName_var security_name;
  AssociationOptions options_supported;
  AssociationOptions options_required;
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_SecurityMechanismData;

typedef SequenceTmpl< SecurityMechanismData,MICO_TID_DEF> SecurityMechanismDataList;
typedef TSeqVar< SequenceTmpl< SecurityMechanismData,MICO_TID_DEF> > SecurityMechanismDataList_var;
typedef TSeqOut< SequenceTmpl< SecurityMechanismData,MICO_TID_DEF> > SecurityMechanismDataList_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_SecurityMechanismDataList;

struct MechandOptions;
typedef TVarVar< MechandOptions > MechandOptions_var;
typedef TVarOut< MechandOptions > MechandOptions_out;


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

  MechanismType_var mechanism_type;
  AssociationOptions options_supported;
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_MechandOptions;

typedef SequenceTmpl< MechandOptions,MICO_TID_DEF> MechandOptionsList;
typedef TSeqVar< SequenceTmpl< MechandOptions,MICO_TID_DEF> > MechandOptionsList_var;
typedef TSeqOut< SequenceTmpl< MechandOptions,MICO_TID_DEF> > MechandOptionsList_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_MechandOptionsList;

struct EstablishTrust;
typedef TFixVar< EstablishTrust > EstablishTrust_var;
typedef EstablishTrust& EstablishTrust_out;


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

  CORBA::Boolean trust_in_client;
  CORBA::Boolean trust_in_target;
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_EstablishTrust;

typedef CORBA::ULong AuditChannelId;
typedef AuditChannelId& AuditChannelId_out;
extern MICO_EXPORT CORBA::TypeCodeConst _tc_AuditChannelId;

typedef CORBA::UShort EventType;
typedef EventType& EventType_out;
extern MICO_EXPORT CORBA::TypeCodeConst _tc_EventType;

const EventType AuditAll = 0;
const EventType AuditPrincipalAuth = 1;
const EventType AuditSessionAuth = 2;
const EventType AuditAuthorization = 3;
const EventType AuditInvocation = 4;
const EventType AuditSecEnvChange = 5;
const EventType AuditPolicyChange = 6;
const EventType AuditObjectCreation = 7;
const EventType AuditObjectDestruction = 8;
const EventType AuditNonRepudiation = 9;
enum DayOfTheWeek {
  Monday = 0,
  Tuesday,
  Wednesday,
  Thursday,
  Friday,
  Saturday,
  Sunday
};

typedef DayOfTheWeek& DayOfTheWeek_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_DayOfTheWeek;

enum AuditCombinator {
  SecAllSelectors = 0,
  SecAnySelector
};

typedef AuditCombinator& AuditCombinator_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_AuditCombinator;

struct AuditEventType;
typedef TFixVar< AuditEventType > AuditEventType_var;
typedef AuditEventType& AuditEventType_out;


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

  ExtensibleFamily event_family;
  CORBA::UShort event_type;
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_AuditEventType;

typedef SequenceTmpl< AuditEventType,MICO_TID_DEF> AuditEventTypeList;
typedef TSeqVar< SequenceTmpl< AuditEventType,MICO_TID_DEF> > AuditEventTypeList_var;
typedef TSeqOut< SequenceTmpl< AuditEventType,MICO_TID_DEF> > AuditEventTypeList_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_AuditEventTypeList;

typedef CORBA::ULong SelectorType;
typedef SelectorType& SelectorType_out;
extern MICO_EXPORT CORBA::TypeCodeConst _tc_SelectorType;

const SelectorType InterfaceName = 1;
const SelectorType ObjectRef = 2;
const SelectorType Operation = 3;
const SelectorType Initiator = 4;
const SelectorType SuccessFailure = 5;
const SelectorType Time = 6;
const SelectorType DayOfWeek = 7;
struct SelectorValue;
typedef TVarVar< SelectorValue > SelectorValue_var;