am.h

Go to the documentation of this file.

/*==============================================================================
                Copyright (c) 2003-2005 UGS Corporation
                   Unpublished - All Rights Reserved
 ==============================================================================*/

/*  */

#ifndef AM_INCLUDED
#define AM_INCLUDED

#ifdef __lint
    #pragma uginclude needed
#endif

#include <unidefs.h>
#include <pom/am/am_errors.h>

#include <sa/libsa_exports.h>

#define AM_acl_name_len       128
#define AM_rule_name_len       32
#define AM_rule_arg_len       128
#define AM_priv_name_len       32
#define AM_named_tag_name_len  32

#define AM_MODE_UNSET          0
#define AM_MODE_ALL_GROUPS     (1 << 0)
#define AM_MODE_RULES          (1 << 1)

#define AM_ACLClassName        "AM_ACL"
#define AM_REASONPropertyName  "reason"

#ifdef __cplusplus
    extern "C"{
#endif

SA_API int AM_find_acl(
    const char*     acl_name,   
    tag_t*          acl_id      
    );

SA_API int AM_list_acls(
    int*        n_acls,     
    tag_t**     acl_ids     
    );

SA_API int AM_create_acl(
    const char*     acl_name,   
    tag_t*          acl_id      
    );

SA_API int AM_save_acl(
    tag_t  acl_id   
    );

SA_API int AM_unload_acl(
    tag_t  acl_id   
    );

SA_API int AM_delete_acl(
    tag_t  acl_id   
    );

SA_API int AM_set_acl_name(
    tag_t           acl_id,     
    const char*     acl_name    
    );

SA_API int AM_ask_acl_name(
    tag_t       acl_id,     
    char**      acl_name    
    );

SA_API int AM_ask_acl_display_name(
    tag_t       acl_id,             
    char**      acl_display_name    
    );

SA_API int AM_set_default_acl_flag(
    tag_t  acl_id   
    );

SA_API int AM_set_acl_flag(
    tag_t           acl_id,     
    const char*     acl_flag    
    );

SA_API int AM_ask_acl_flag(
    tag_t  acl_id,      
    char** acl_flag     
    );

SA_API int AM_list_acls_by_type(
    int*            n_acls,     
    tag_t**         acl_ids,    
    const char*     acl_flag    
    );

SA_API int AM_list_accessors(
    tag_t       acl_id,         
    int*        n_accessors,    
    tag_t**     accessors       
    );

SA_API int AM_grant_privilege(
    tag_t  acl_id,          
    tag_t  accessor_id,     
    tag_t  privilege        
    );

SA_API int AM_revoke_privilege(
    tag_t  acl_id,          
    tag_t  accessor_id,     
    tag_t  privilege        
    );

SA_API int AM_unset_privilege(
    tag_t  acl_id,          
    tag_t  accessor_id,     
    tag_t  privilege        
    );

SA_API int AM_list_accessor_privileges(
    tag_t       acl_id,         
    tag_t       accessor_id,    
    int*        n_granted,      
    tag_t**     granted,        
    int*        n_revoked,      
    tag_t**     revoked         
    );

SA_API int AM_evaluate_privilege(
    tag_t           object,         
    const char*     privilege,      
    logical*        verdict,        
    int*            n_rules,        
    char***         rules,          
    char***         args,           
    tag_t*          acl,            
    tag_t*          accessor        
    );

SA_API int AM_check_privilege(
    tag_t           object,     
    const char*     privilege,  
    logical*        verdict     
    );

SA_API int AM_check_users_privilege(
    tag_t           user,           
    tag_t           object,         
    const char*     privilege,      
    logical*        verdict         
    );

SA_API int AM_evaluate_users_privilege(
    tag_t           user,           
    tag_t           object,         
    const char*     privilege,      
    logical*        verdict,        
    int*            n_rules,        
    char***         rules,          
    char***         args,           
    tag_t*          acl,            
    tag_t*          accessor        
    );

SA_API int AM_get_effective_acl(
    tag_t  object,          
    tag_t* eff_acl_tag,     
    int*   length           
    );

SA_API int AM_effective_acl_line(
    tag_t       eff_acl_tag,    
    int         index,          
    tag_t*      source_acl,     
    tag_t*      accessor,       
    int*        n_granted,      
    tag_t**     granted,        
    int*        n_revoked,      
    tag_t**     revoked         
    );

SA_API int AM_free_effective_acl(
    tag_t  eff_acl_tag      
    );


SA_API int AM_get_combined_read_expression( 
    int     count,                  
    const char**  read_expressions, 
    char**  cumulative_re           
    );

SA_API int AM_ask_read_expressions(
    int         count,           
    tag_t*      objs,            
    char***     read_expressions 
    );

SA_API int AM_ask_session_info(
    int*        count,          
    char***     keys,           
    char***     values          
    );

SA_API int AM_check_sites_privilege(
    tag_t           site,           
    tag_t           object,         
    const char*     privilege,      
    logical*        verdict         
    );

SA_API int AM_check_suppliers_privilege_in_bulk (
    tag_t           vendor_contact,        
    int             n_objects,             
    const tag_t*    objects,               
    const char*     privilege,             
    logical**       verdicts               
    );


SA_API int AM_check_accessors_privilege(
    int             n_accessors,    
    tag_t*          accessors,      
    tag_t           object,         
    const char*     privilege,      
    logical*        verdict         
    );

SA_API int AM_remove_accessor(
    tag_t  acl_id,          
    tag_t  accessor_id      
    );

SA_API int AM_clear_acl(
    tag_t  acl_id   
    );

SA_API int AM_delete_accessor(
    tag_t  accessor_id      
    );

SA_API int AM_find_privilege(
    const char*     name,           
    tag_t*          privilege_id    
    );

SA_API int AM_privilege_of_offset(
    int    offset,          
    tag_t* privilege_id     
    );

SA_API int AM_list_privileges(
    int*        n_privileges,       
    tag_t**     privilege_ids       
    );

SA_API int AM_create_privilege(
    const char*     privilege_name,     
    tag_t*          privilege_id        
    );

SA_API int AM_delete_privilege(
    tag_t  privilege_id     
    );

SA_API int AM_ask_priv_name(
    tag_t  privilege_id,    
    char** privilege_name   
    );

SA_API int AM_set_priv_name(
    tag_t           privilege_id,       
    const char*     privilege_name      
    );

SA_API int AM_ask_priv_offset(
    tag_t  privilege_id,    
    int*   offset           
    );

SA_API int AM_find_named_tag(
    const char*     named_tag_name,     
    tag_t*          named_tag_id        
    );

SA_API int AM_create_named_tag(
    const char*     named_tag_name,     
    tag_t*          named_tag_id        
    );

SA_API int AM_delete_named_tag(
    tag_t  named_tag_id     
    );

SA_API int AM_ask_named_tag_name(
    tag_t  named_tag_id,        
    char** named_tag_name       
    );

SA_API int AM_set_named_tag_name(
    tag_t           named_tag_id,       
    const char*     named_tag_name      
    );

SA_API int AM_list_named_tags(
    int*        n_named_tags,   
    tag_t**     named_tags      
    );

SA_API int AM_node_ask_root(
    tag_t* root     
    );

SA_API int AM_node_ask_parent(
    tag_t  node,    
    tag_t* parent   
    );

SA_API int AM_node_ask_children(
    tag_t       node,           
    int*        no_children,    
    tag_t**     children        
    );

SA_API int AM_node_ask_rule_name(
    tag_t  node,        
    char** rule_name    
    );

SA_API int AM_node_set_rule_name(
    tag_t           node,       
    const char*     rule_name   
    );

SA_API int AM_node_ask_rule_arg(
    tag_t  node,        
    char** rule_arg     
    );

SA_API int AM_node_set_rule_arg(
    tag_t           node,       
    const char*     rule_arg    
    );

SA_API int AM_node_ask_acl(
    tag_t  node,    
    tag_t* acl      
    );

SA_API int AM_node_set_acl(
    tag_t  node,    
    tag_t  acl      
    );

SA_API int AM_node_ask_expanded(
    tag_t       node,       
    logical*    expanded    
    );

SA_API int AM_node_set_expanded(
    tag_t       node,       
    logical     expanded    
    );

SA_API int AM_node_ask_children_editable(
    tag_t       node,       
    logical*    editable    
    );

SA_API int AM_node_set_children_editable(
    tag_t       node,       
    logical     editable    
    );

SA_API int AM_create_node(
    const char*     rule_name,      
    const char*     rule_arg,       
    tag_t           parent,         
    tag_t           prev,           
    tag_t           acl,            
    tag_t*          node            
    );

SA_API int AM_node_paste(
    tag_t  node,        
    tag_t  parent,      
    tag_t  prev         
    );

SA_API int AM_node_cut(
    tag_t  node     
    );

SA_API int AM_node_move_up(
    tag_t  node     
    );

SA_API int AM_node_move_down(
    tag_t  node     
    );

SA_API int AM_save_tree(void);

SA_API int AM_unload_tree(void);

SA_API int AM_refresh_tree(void);

SA_API int AM_tree_discard_changes(void);

SA_API int AM_tree_find_nodes(
    tag_t       parent,     
    char*       ruleName,   
    char*       ruleArg,    
    int*        count,      
    tag_t**     nodes       
    );

SA_API int AM_list_rules(
    int*        no_rules,   
    char***     rules       
    );

SA_API int AM_list_rule_args(
    const char*     rule_name,      
    int*            no_args,        
    char***         args            
    );

SA_API int AM_validate_rule_arg(
    const char*     rule_name,      
    const char*     rule_arg,       
    logical*        is_valid        
    );

SA_API int AM_accessor_info(
    tag_t  accessor,    
    char** type,        
    char** name         
    );

SA_API int AM_find_accessor(
    const char*     type,   
    const char*     name,   
    tag_t*          acc     
    );

SA_API int AM_list_accessors_by_type(
    const char*     type,       
    int*            n_accs,     
    tag_t**         accs        
    );

SA_API int AM_list_accessor_types(
    int*        n_types,    
    char***     types       
    );

SA_API int AM_list_session_accessors(
    int*        n_accessors,    
    tag_t**     accessors       
    );

SA_API int AM_set_mode(
    int    mode     
    );

SA_API int AM_ask_mode(
    int*   mode     
    );

SA_API int AM_set_journalling(
    logical     flag    
    );

SA_API int AM_init_module ( void );

SA_API void AM_preload_rule_tree ( void );

SA_API int AM_exit_module ( void );

SA_API int AM_check_read_privilege_in_bulk(
    int n_objects,           
    const tag_t* objects,    
    logical** decisions      
    );

SA_API int AM_log_statistics(
    logical     clear   
    );

/*<AO><29-Oct-2007> added these for supporting delegation for forms/named references
 */
SA_API int AM_record_object_parent ( int n_tags, tag_t *ref_tag, tag_t parent_tag );
SA_API int AM_remove_parent_from_cache ( int n_tags, tag_t *ref_tag, tag_t parent_tag );
SA_API int AM_record_delegation_classes ( int n_strings, const char **class_names, const char *parent_class );
SA_API int AM_lookup_delegation_class ( const char *class_name, int *cid );

SA_API int AM_check_privilege_in_bulk(
    int n_instances,                   
    const tag_t* instances,            
    const char* privilege_name,        
    const logical* are_loaded,         
    logical** decisions                
    );


#ifdef __cplusplus
}
#endif
#include <sa/libsa_undef.h>

#endif