securitylevel2_impl.h

MICO2.3.13 corba 环境平台

	: public ::SecurityLevel2::QOPPolicy,
	  virtual public MICO::Policy_impl
    {
    public:
	QOPPolicy_impl(Security::QOP qop);
	QOPPolicy_impl();
	virtual ~QOPPolicy_impl();

	CORBA::PolicyType
	policy_type()
	{ return Security::SecQOPPolicy; }

	CORBA::Policy_ptr
	copy();

	Security::QOP
	qop();
    
    private:
	Security::QOP qop_;
    };

  
    class DelegationDirectivePolicy_impl
	: public ::SecurityLevel2::DelegationDirectivePolicy,
	  virtual public MICO::Policy_impl
    {
    public:
	DelegationDirectivePolicy_impl();
	DelegationDirectivePolicy_impl(Security::DelegationDirective);
	virtual ~DelegationDirectivePolicy_impl();

	CORBA::PolicyType
	policy_type()
	{ return Security::SecDelegationDirectivePolicy; }

	virtual Security::DelegationDirective
	delegation_mode();

	CORBA::Policy_ptr
	copy();

    private:
	Security::DelegationDirective deleg_mode_;
    };
  

    class EstablishTrustPolicy_impl
	: virtual public ::SecurityLevel2::EstablishTrustPolicy,
	  virtual public MICO::Policy_impl
    {
    public:
	EstablishTrustPolicy_impl();
	EstablishTrustPolicy_impl(Security::EstablishTrust);
	virtual ~EstablishTrustPolicy_impl();

	CORBA::PolicyType
	policy_type()
	{ return Security::SecEstablishTrustPolicy; }

	Security::EstablishTrust
	trust();
    
	//CORBA::Boolean constr_policy (CORBA::Object_ptr object);
	CORBA::Policy_ptr
	copy ();
    
    private:
	Security::EstablishTrust trust_;
    };
  
    class PolicyCurrent_impl
	: public SecurityLevel2::PolicyCurrent
    {
	CORBA::ORB_ptr orb_;
    public:
	PolicyCurrent_impl();
	PolicyCurrent_impl(CORBA::ORB_ptr _orb);
	virtual ~PolicyCurrent_impl();

	virtual void
	set_policy_overrides
	(const CORBA::PolicyList& policies,
	 CORBA::SetOverrideType override_type);

	virtual CORBA::PolicyList*
	get_policy_overrides(const CORBA::PolicyTypeSeq& policy_types);
    private:
	CORBA::PolicyList policies_;

	CORBA::Boolean
	policy_type_allowed(const CORBA::Policy_var policy);

	void
	create_default_policy_list();
  };
  
  
    /////////////////////
    // Required Rights //
    /////////////////////
    // for new mapping
    /*
      struct RightsRecord {
      RightsRecord() {}
      ~RightsRecord() {}
      RightsRecord( const RightsRecord& s );
      RightsRecord& operator=( const RightsRecord& s );
      
      Security::RightsList rightslist;        // List of required rights
      string opname;                          // operation name
      Security::RightsCombinator combinator;  // Rights combinator
      };

      typedef map<string, RightsRecord *, less<string> > RightsMap;

      class RequiredRights_impl : virtual public SecurityLevel2::RequiredRights
      {
      public:
      RequiredRights_impl();
      ~RequiredRights_impl();
    
      virtual void get_required_rights( CORBA::Object_ptr obj, const char* operation_name, const char* interface_name, Security::RightsList*& rights, Security::RightsCombinator& rights_combinator );
      virtual void set_required_rights( const char* operation_name, const char* interface_name, const Security::RightsList& rights, Security::RightsCombinator rights_combinator );
      virtual CORBA::Boolean loadConfigFile(const char* filename);
      
      private:
      RightsMap rightsmap;
      };
    */
    // for new mapping

    typedef std::map<std::string, Security::RightsList *, std::less<std::string> > SecAttrMap;
  
    class AccessRights_impl
	: virtual public SecurityLevel2::AccessRights
    {
    public:
	AccessRights_impl();
	virtual ~AccessRights_impl();
    
	virtual void
	grant_rights
	(const Security::SecAttribute& priv_attr,
	 Security::DelegationState del_state,
	 const Security::RightsList& rights);

	virtual void
	revoke_rights
	(const Security::SecAttribute& priv_attr,
	 Security::DelegationState del_state,
	 const Security::RightsList& rights);

	virtual void
	replace_rights
	(const Security::SecAttribute& priv_attr,
	 Security::DelegationState del_state,
	 const Security::RightsList& rights);

	virtual Security::RightsList*
	get_rights
	(const Security::SecAttribute& priv_attr,
	 Security::DelegationState del_state,
	 const Security::ExtensibleFamily& rights_family);

	virtual Security::RightsList*
	get_all_rights
	(const Security::SecAttribute& priv_attr,
	 Security::DelegationState del_state);

	virtual Security::RightsList*
	get_effective_rights
	(const Security::AttributeList& attribute_list,
	 const Security::ExtensibleFamily& rights_family);

	virtual Security::RightsList*
	get_all_effective_rights
	(const Security::AttributeList& attrib_list);
    
	virtual CORBA::Boolean
	load_config_file(const char* filename);
    
    protected:
	std::string key_;
	SecAttrMap atrmap_;

	void
	attribute_to_key(const Security::SecAttribute& attr);
    };
  
  
    //
    // Access Decision
    //
    class AccessDecision_impl
	: virtual public SecurityLevel2::AccessDecision {
    public:
	AccessDecision_impl();
	virtual ~AccessDecision_impl();
    
	virtual CORBA::Boolean
	access_allowed
	(const SecurityLevel2::CredentialsList& cred_list,
	 CORBA::Object_ptr target,
	 const char* operation_name,
	 const char* target_interface_name);
    protected:
	// for new mapping
	void
	policy_combinator
	(CORBA::Object_ptr obj,
	 const char* operation_name,
	 const char* interface_name,
	 SecurityDomain::DomainManagerAdmin_ptr adm,
	 SecurityDomain::PolicyCombinator comb,
	 Security::RightsCombinator& rcomb);

	//  void policy_combinator(const SecurityLevel2::CredentialsList& cred_list,
	//	  					   SecurityDomain::DomainManagerAdmin_ptr dm,
	//	  					   SecurityDomain::PolicyCombinator comb);
	
	void
	combin_union(Security::RightsList* irights);

	void
	combin_intersection(Security::RightsList* irights);

	void
	combin_negation(Security::RightsList* irights);

	CORBA::Boolean
	check_all_rights(Security::RightsList* irights);

	CORBA::Boolean
	check_any_rights(Security::RightsList* irights);
  
    private:
	Security::RightsList result_rights_;
	CORBA::Boolean fl_;
	CORBA::Boolean map_flag_;
    };

    //
    // Security Manager
    //
    class SecurityManager_impl
	: public SecurityLevel2::SecurityManager
    {
    private:
	CORBA::ORB_ptr orb_;
	PrincipalAuthenticator_impl prin_auth_;
	CORBA::Any any_;
	SecurityLevel2::CredentialsList cred_list_;
	Security::MechandOptionsList mech_list_;
	MICOSL2::AttributeManager* attr_man_;
	MICOSL2::AuditDecision_impl* audit_des_;
	// for new mapping
	//MICOSL2::RequiredRights_impl * rrights;
	MICOSL2::AccessRights_impl* rrights_;
	MICOSL2::AccessDecision_impl* adecision_;
    public:
	SecurityManager_impl(CORBA::ORB_ptr _orb);
	SecurityManager_impl();
	virtual ~SecurityManager_impl();
  
	virtual Security::MechandOptionsList*
	supported_mechanisms();

	virtual SecurityLevel2::CredentialsList*
	own_credentials();

	virtual SecurityLevel2::AuditDecision_ptr
	audit_decision();

	virtual void
	remove_own_credentials(SecurityLevel2::Credentials_ptr creds);

	virtual void
	set_own_credentials(const SecurityLevel2::CredentialsList& creds);

	virtual SecurityLevel2::TargetCredentials_ptr
	get_target_credentials(CORBA::Object_ptr target);

	virtual CORBA::Policy_ptr
	get_security_policy(CORBA::PolicyType policy_type);

	virtual SecurityLevel2::PrincipalAuthenticator_ptr
	principal_authenticator();

	virtual CORBA::Any*
	get_method_data(Security::AuthenticationMethod method);

	MICOSL2::AttributeManager*
	attribute_manager();

	// for new mapping
	// SecurityLevel2::RequiredRights_ptr required_rights();

	virtual SecurityLevel2::AccessRights_ptr
	access_rights();

	virtual SecurityLevel2::AccessDecision_ptr
	access_decision();
    };


    class Current_impl
	: public SecurityLevel2::Current,
	  public virtual MICOSL1::Current_impl
    {
	CORBA::ORB_ptr orb_;
    public:
	Current_impl(CORBA::ORB_ptr _orb);
	Current_impl();  // Needed ??
	virtual ~Current_impl();

	SecurityLevel2::ReceivedCredentials_ptr
	received_credentials();

	//    Security::MechandOptionsList* supported_mechanisms();
	//    SecurityLevel2::CredentialsList* own_credentials();
	
	//    CORBA::Policy_ptr get_policy( CORBA::PolicyType policy_type );
	//    void remove_own_credentials(SecurityLevel2:: Credentials_ptr creds );

	SecurityLevel2::TargetCredentials_ptr
	get_target_credentials(CORBA::Object_ptr target);
    };
 
    extern char MICO_defining_authority[];
    extern MICOSL2::AttributeManager* S_attr_man;
    extern CORBA::Boolean paranoid;
 
} // MICOSL2

#endif // __SECURITYLEVEL2_IMPL_H__