# security_compute_av

## NAME



           security_compute_av, security_compute_av_flags,
           security_compute_create, security_compute_create_name,
           security_compute_relabel, security_compute_member,
           security_compute_user, security_validatetrans,
           security_get_initial_context - query the SELinux policy database
           in the kernel
    


## SYNOPSIS



           **#include <selinux/selinux.h>**
    
           **int security_compute_av(const char ***_scon_**, const char ***_tcon_**,**
           **security_class_t** _tclass_**, access_vector_t** _requested_**, struct**
           **av_decision ***_avd_**);**
    
           **int security_compute_av_raw(const char ***_scon_**, const char ***_tcon_**,**
           **security_class_t** _tclass_**, access_vector_t** _requested_**, struct**
           **av_decision ***_avd_**);**
    
           **int security_compute_av_flags(const char ***_scon_**, const char ***_tcon_**,**
           **security_class_t** _tclass_**, access_vector_t** _requested_**, struct**
           **av_decision ***_avd_**);**
    
           **int security_compute_av_flags_raw(const char ***_scon_**, const char**
           *****_tcon_**, security_class_t** _tclass_**, access_vector_t** _requested_**, struct**
           **av_decision ***_avd_**);**
    
           **int security_compute_create(const char ***_scon_**, const char ***_tcon_**,**
           **security_class_t** _tclass_**, char ****_newcon_**);**
    
           **int security_compute_create_raw(const char ***_scon_**, const char**
           *****_tcon_**, security_class_t** _tclass_**, char ****_newcon_**);**
    
           **int security_compute_create_name(const char ***_scon_**, const char**
           *****_tcon_**, security_class_t** _tclass_**, const char ***_objname_**, char**
           ******_newcon_**);**
    
           **int security_compute_create_name_raw(const char ***_scon_**, const char**
           *****_tcon_**, security_class_t** _tclass_**, const char ***_objname_**, char**
           ******_newcon_**);**
    
           **int security_compute_relabel(const char ***_scon_**, const char ***_tcon_**,**
           **security_class_t** _tclass_**, char ****_newcon_**);**
    
           **int security_compute_relabel_raw(const char ***_scon_**, const char**
           *****_tcon_**, security_class_t** _tclass_**, char ****_newcon_**);**
    
           **int security_compute_member(const char ***_scon_**, const char ***_tcon_**,**
           **security_class_t** _tclass_**, char ****_newcon_**);**
    
           **int security_compute_member_raw(const char ***_scon_**, const char**
           *****_tcon_**, security_class_t** _tclass_**, char ****_newcon_**);**
    
           **int security_compute_user(const char ***_scon_**, const char ***_username_**,**
           **char *****_con_**);**
    
           **int security_compute_user_raw(const char ***_scon_**, const char**
           *****_username_**, char *****_con_**);**
    
           **int security_validatetrans(const char ***_scon_**, const char ***_tcon_**,**
           **security_class_t** _tclass_**, const char ***_newcon_**);**
    
           **int security_validatetrans_raw(const char ***_scon_**, const char ***_tcon_**,**
           **security_class_t** _tclass_**, const char ***_newcon_**);**
    
           **int security_get_initial_context(const char ***_name_**, char ****_con_**);**
    
           **int security_get_initial_context_raw(const char ***_name_**, char**
           ******_con_**);**
    
           **int selinux_check_access(const char ***_scon_**, const char ***_tcon_**, const**
           **char ***_class_**, const char ***_perm_**, void ***_auditdata);_
    
           **int selinux_check_passwd_access(access_vector_t** _requested_**);**
    
           **int checkPasswdAccess(access_vector_t** _requested_**);**
    


## DESCRIPTION



           This family of functions is used to obtain policy decisions from
           the SELinux kernel security server (policy engine).  In general,
           direct use of **security_compute_av**() and its variant interfaces is
           discouraged in favor of using **selinux_check_access**() since the
           latter automatically handles the dynamic mapping of class and
           permission names to their policy values, initialization and use of
           the Access Vector Cache (AVC), and proper handling of per-domain
           and global permissive mode and allow_unknown.
    
           When using any of the functions that take policy integer values
           for classes or permissions as inputs, use
           string_to_security_class(3) and string_to_av_perm(3) to map the
           class and permission names to their policy values.  These values
           may change across a policy reload, so they should be re-acquired
           on every use or using a **SELINUX_CB_POLICYLOAD** callback set via
           selinux_set_callback(3).
    
           An alternative approach is to use selinux_set_mapping(3) to create
           a mapping from class and permission index values used by the
           application to the policy values, thereby allowing the application
           to pass its own fixed constants for the classes and permissions to
           these functions and internally mapping them on demand.  However,
           this also requires setting up a callback as above to address
           policy reloads.
    
           **security_compute_av**() queries whether the policy permits the
           source context _scon_ to access the target context _tcon_ via class
           _tclass_ with the _requested_ access vector.  The decision is returned
           in _avd_.
    
           **security_compute_av_flags**() is identical to **security_compute_av**
           but additionally sets the _flags_ field of _avd_.  Currently one flag
           is supported: **SELINUX_AVD_FLAGS_PERMISSIVE** , which indicates the
           decision is computed on a permissive domain.
    
           **security_compute_create**() is used to compute a context to use for
           labeling a new object in a particular class based on a SID pair.
    
           **security_compute_create_name**() is identical to
           **security_compute_create**() but also takes name of the new object in
           creation as an argument.  When **TYPE_TRANSITION** rule on the given
           class and a SID pair has object name extension, we shall be able
           to obtain a correct _newcon_ according to the security policy. Note
           that this interface is only supported on the linux 2.6.40 or
           later.  In the older kernel, the object name will be simply
           ignored.
    
           **security_compute_relabel**() is used to compute the new context to
           use when relabeling an object, it is used in the pam_selinux.so
           source and the newrole source to determine the correct label for
           the tty at login time, but can be used for other things.
    
           **security_compute_member**() is used to compute the context to use
           when labeling a polyinstantiated object instance.
    
           **security_compute_user**() is used to determine the set of user
           contexts that can be reached from a source context. This function
           is deprecated; use get_ordered_context_list(3) instead.
    
           **security_validatetrans**() is used to determine if a transition from
           scon to newcon using tcon as the object is valid for object class
           tclass. This checks against the mlsvalidatetrans and validatetrans
           constraints in the loaded policy. Returns 0 if allowed, and -1 if
           an error occurred with errno set.
    
           **security_get_initial_context**() is used to get the context of a
           kernel initial security identifier specified by _name_
    
           **security_compute_av_raw**(), **security_compute_av_flags_raw**(),
           **security_compute_create_raw**(), **security_compute_create_name_raw**(),
           **security_compute_relabel_raw**(), **security_compute_member_raw**(),
           **security_compute_user_raw**() **security_validatetrans_raw**() and
           **security_get_initial_context_raw**() behave identically to their
           non-raw counterparts but do not perform context translation.
    
           **selinux_check_access**() is used to check if the source context has
           the access permission for the specified class on the target
           context.
    
           **selinux_check_passwd_access**() is used to check for a permission in
           the _passwd_ class.  **selinux_check_passwd_access**() uses
           getprevcon(3) for the source and target security contexts.
    
           **checkPasswdAccess**() is a deprecated alias of the
           **selinux_check_passwd_access**() function.
    


## RETURN VALUE



           Returns zero on success or -1 on error.
    


## CAVEATS



           These functions are not thread-safe, you have to protect them from
           concurrent calls using exclusive locks when multiple threads are
           executing.
    


* * *