Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2026-03-31 19:08
📄 boolean_record.h #ifndef _SEPOL_BOOLEAN_RECORD_H_ #define _SEPOL_BOOLEAN_RECORD_H_ #include <stddef.h> #include <sepol/handle.h> #ifdef __cplusplus extern "C" { #endif struct sepol_bool; struct sepol_bool_key; typedef struct sepol_bool sepol_bool_t; typedef struct sepol_bool_key sepol_bool_key_t; /* Key / extern int sepol_bool_key_create(sepol_handle_t handle, const char name, sepol_bool_key_t * key); extern void sepol_bool_key_unpack(const sepol_bool_key_t * key, const char *name); extern int sepol_bool_key_extract(sepol_handle_t handle, const sepol_bool_t * boolean, sepol_bool_key_t ** key_ptr); extern void sepol_bool_key_free(sepol_bool_key_t * key); extern int sepol_bool_compare(const sepol_bool_t * boolean, const sepol_bool_key_t * key); extern int sepol_bool_compare2(const sepol_bool_t * boolean, const sepol_bool_t * boolean2); /* Name / extern const char sepol_bool_get_name(const sepol_bool_t * boolean); extern int sepol_bool_set_name(sepol_handle_t * handle, sepol_bool_t * boolean, const char name); / Value / extern int sepol_bool_get_value(const sepol_bool_t boolean); extern void sepol_bool_set_value(sepol_bool_t * boolean, int value); /* Create/Clone/Destroy / extern int sepol_bool_create(sepol_handle_t handle, sepol_bool_t ** bool_ptr); extern int sepol_bool_clone(sepol_handle_t * handle, const sepol_bool_t * boolean, sepol_bool_t ** bool_ptr); extern void sepol_bool_free(sepol_bool_t * boolean); #ifdef __cplusplus } #endif #endif	1.51 KB	2025-09-21 09:15
📄 booleans.h #ifndef _SEPOL_BOOLEANS_H_ #define _SEPOL_BOOLEANS_H_ #include <stddef.h> #include <sepol/policydb.h> #include <sepol/boolean_record.h> #include <sepol/handle.h> #ifdef __cplusplus extern "C" { #endif /* Set the specified boolean / extern int sepol_bool_set(sepol_handle_t handle, sepol_policydb_t * policydb, const sepol_bool_key_t * key, const sepol_bool_t * data); /* Return the number of booleans / extern int sepol_bool_count(sepol_handle_t handle, const sepol_policydb_t * p, unsigned int response); / Check if the specified boolean exists / extern int sepol_bool_exists(sepol_handle_t handle, const sepol_policydb_t * policydb, const sepol_bool_key_t * key, int response); / Query a boolean - returns the boolean, or NULL if not found / extern int sepol_bool_query(sepol_handle_t handle, const sepol_policydb_t * p, const sepol_bool_key_t * key, sepol_bool_t ** response); /* Iterate the booleans * The handler may return: * -1 to signal an error condition, * 1 to signal successful exit * 0 to signal continue / extern int sepol_bool_iterate(sepol_handle_t handle, const sepol_policydb_t * policydb, int (fn) (const sepol_bool_t boolean, void fn_arg), void arg); #ifdef __cplusplus } #endif #endif	1.3 KB	2025-09-21 09:15
📁 cil	-	2026-03-21 15:44
📄 context.h #ifndef _SEPOL_CONTEXT_H_ #define _SEPOL_CONTEXT_H_ #include <sepol/context_record.h> #include <sepol/policydb.h> #include <sepol/handle.h> #ifdef __cplusplus extern "C" { #endif /* -- Deprecated -- / extern int sepol_check_context(const char context); /* -- End deprecated -- / extern int sepol_context_check(sepol_handle_t handle, const sepol_policydb_t * policydb, const sepol_context_t * context); extern int sepol_mls_contains(sepol_handle_t * handle, const sepol_policydb_t * policydb, const char mls1, const char mls2, int response); extern int sepol_mls_check(sepol_handle_t handle, const sepol_policydb_t * policydb, const char *mls); #ifdef __cplusplus } #endif #endif	752 B	2025-09-21 09:15
📄 context_record.h #ifndef _SEPOL_CONTEXT_RECORD_H_ #define _SEPOL_CONTEXT_RECORD_H_ #include <sepol/handle.h> #ifdef __cplusplus extern "C" { #endif struct sepol_context; typedef struct sepol_context sepol_context_t; /* We don't need a key, because the context is never stored * in a data collection by itself / / User / extern const char sepol_context_get_user(const sepol_context_t * con); extern int sepol_context_set_user(sepol_handle_t * handle, sepol_context_t * con, const char user); / Role / extern const char sepol_context_get_role(const sepol_context_t * con); extern int sepol_context_set_role(sepol_handle_t * handle, sepol_context_t * con, const char role); / Type / extern const char sepol_context_get_type(const sepol_context_t * con); extern int sepol_context_set_type(sepol_handle_t * handle, sepol_context_t * con, const char type); / MLS / extern const char sepol_context_get_mls(const sepol_context_t * con); extern int sepol_context_set_mls(sepol_handle_t * handle, sepol_context_t * con, const char mls_range); / Create/Clone/Destroy / extern int sepol_context_create(sepol_handle_t handle, sepol_context_t ** con_ptr); extern int sepol_context_clone(sepol_handle_t * handle, const sepol_context_t * con, sepol_context_t ** con_ptr); extern void sepol_context_free(sepol_context_t * con); /* Parse to/from string / extern int sepol_context_from_string(sepol_handle_t handle, const char str, sepol_context_t * con); extern int sepol_context_to_string(sepol_handle_t * handle, const sepol_context_t * con, char **str_ptr); #ifdef __cplusplus } #endif #endif	1.63 KB	2025-09-21 09:15
📄 debug.h #ifndef _SEPOL_DEBUG_H_ #define _SEPOL_DEBUG_H_ #include <sepol/handle.h> #ifdef __cplusplus extern "C" { #endif /* Deprecated / extern void sepol_debug(int on); / End deprecated / #define SEPOL_MSG_ERR 1 #define SEPOL_MSG_WARN 2 #define SEPOL_MSG_INFO 3 extern int sepol_msg_get_level(sepol_handle_t handle); extern const char sepol_msg_get_channel(sepol_handle_t handle); extern const char sepol_msg_get_fname(sepol_handle_t handle); /* Set the messaging callback. * By the default, the callback will print * the message on standard output, in a * particular format. Passing NULL here * indicates that messaging should be suppressed / extern void sepol_msg_set_callback(sepol_handle_t handle, #ifdef __GNUC__ __attribute__ ((format(printf, 3, 4))) #endif void (msg_callback) (void varg, sepol_handle_t * handle, const char fmt, ...), void msg_callback_arg); #ifdef __cplusplus } #endif #endif	975 B	2025-09-21 09:15
📄 errcodes.h /* Author: Karl MacMillan <kmacmillan@mentalrootkit.com> / #ifndef __sepol_errno_h__ #define __sepol_errno_h__ #include <errno.h> #ifdef __cplusplus extern "C" { #endif #define SEPOL_OK 0 / These first error codes are defined for compatibility with * previous version of libsepol. In the future, custom error * codes that don't map to system error codes should be defined * outside of the range of system error codes. / #define SEPOL_ERR (-1) #define SEPOL_ENOTSUP (-2) / feature not supported in module language / #define SEPOL_EREQ (-3) / requirements not met / / Error codes that map to system error codes */ #define SEPOL_ENOMEM (-ENOMEM) #define SEPOL_EEXIST (-EEXIST) #define SEPOL_ENOENT (-ENOENT) #ifdef __cplusplus } #endif #endif	826 B	2025-09-21 09:15
📄 handle.h #ifndef _SEPOL_HANDLE_H_ #define _SEPOL_HANDLE_H_ #ifdef __cplusplus extern "C" { #endif struct sepol_handle; typedef struct sepol_handle sepol_handle_t; /* Create and return a sepol handle. / sepol_handle_t sepol_handle_create(void); /* Get whether or not dontaudits will be disabled, same values as * specified by set_disable_dontaudit. This value reflects the state * your system will be set to upon commit, not necessarily its * current state./ int sepol_get_disable_dontaudit(sepol_handle_t sh); /* Set whether or not to disable dontaudits, 0 is default and does * not disable dontaudits, 1 disables them / void sepol_set_disable_dontaudit(sepol_handle_t sh, int disable_dontaudit); /* Set whether module_expand() should consume the base policy passed in. * This should reduce the amount of memory required to expand the policy. / void sepol_set_expand_consume_base(sepol_handle_t sh, int consume_base); /* Destroy a sepol handle. / void sepol_handle_destroy(sepol_handle_t ); /* Get whether or not needless unused branch of tunables would be preserved / int sepol_get_preserve_tunables(sepol_handle_t sh); /* Set whether or not to preserve the needless unused branch of tunables, * 0 is default and discard such branch, 1 preserves them / void sepol_set_preserve_tunables(sepol_handle_t sh, int preserve_tunables); #ifdef __cplusplus } #endif #endif	1.36 KB	2025-09-21 09:15
📄 ibendport_record.h #ifndef _SEPOL_IBENDPORT_RECORD_H_ #define _SEPOL_IBENDPORT_RECORD_H_ #include <stddef.h> #include <sepol/context_record.h> #include <sepol/handle.h> #ifdef __cplusplus extern "C" { #endif struct sepol_ibendport; struct sepol_ibendport_key; typedef struct sepol_ibendport sepol_ibendport_t; typedef struct sepol_ibendport_key sepol_ibendport_key_t; extern int sepol_ibendport_compare(const sepol_ibendport_t ibendport, const sepol_ibendport_key_t key); extern int sepol_ibendport_compare2(const sepol_ibendport_t ibendport, const sepol_ibendport_t ibendport2); extern int sepol_ibendport_key_create(sepol_handle_t handle, const char ibdev_name, int port, sepol_ibendport_key_t *key_ptr); extern void sepol_ibendport_key_unpack(const sepol_ibendport_key_t key, const char *ibdev_name, int port); extern int sepol_ibendport_alloc_ibdev_name(sepol_handle_t handle, char ibdev_name); extern int sepol_ibendport_key_extract(sepol_handle_t handle, const sepol_ibendport_t ibendport, sepol_ibendport_key_t key_ptr); extern void sepol_ibendport_key_free(sepol_ibendport_key_t key); extern void sepol_ibendport_set_port(sepol_ibendport_t ibendport, int port); extern int sepol_ibendport_get_port(const sepol_ibendport_t ibendport); extern int sepol_ibendport_get_ibdev_name(sepol_handle_t handle, const sepol_ibendport_t ibendport, char *ibdev_name); extern int sepol_ibendport_set_ibdev_name(sepol_handle_t handle, sepol_ibendport_t ibendport, const char ibdev_name); extern sepol_context_t sepol_ibendport_get_con(const sepol_ibendport_t ibendport); extern int sepol_ibendport_set_con(sepol_handle_t handle, sepol_ibendport_t ibendport, sepol_context_t con); extern int sepol_ibendport_create(sepol_handle_t handle, sepol_ibendport_t *ibendport_ptr); extern int sepol_ibendport_clone(sepol_handle_t handle, const sepol_ibendport_t ibendport, sepol_ibendport_t ibendport_ptr); extern void sepol_ibendport_free(sepol_ibendport_t ibendport); #ifdef __cplusplus } #endif #endif	2.13 KB	2025-09-21 09:15
📄 ibendports.h #ifndef _SEPOL_IBENDPORTS_H_ #define _SEPOL_IBENDPORTS_H_ #include <sepol/handle.h> #include <sepol/policydb.h> #include <sepol/ibendport_record.h> #ifdef __cplusplus extern "C" { #endif /* Return the number of ibendports / extern int sepol_ibendport_count(sepol_handle_t handle, const sepol_policydb_t p, unsigned int response); /* Check if a ibendport exists / extern int sepol_ibendport_exists(sepol_handle_t handle, const sepol_policydb_t policydb, const sepol_ibendport_key_t key, int response); / Query a ibendport - returns the ibendport, or NULL if not found / extern int sepol_ibendport_query(sepol_handle_t handle, const sepol_policydb_t policydb, const sepol_ibendport_key_t key, sepol_ibendport_t *response); / Modify a ibendport, or add it, if the key is not found / extern int sepol_ibendport_modify(sepol_handle_t handle, sepol_policydb_t policydb, const sepol_ibendport_key_t key, const sepol_ibendport_t data); / Iterate the ibendports * The handler may return: * -1 to signal an error condition, * 1 to signal successful exit * 0 to signal continue / extern int sepol_ibendport_iterate(sepol_handle_t handle, const sepol_policydb_t policydb, int (fn)(const sepol_ibendport_t ibendport, void fn_arg), void *arg); #ifdef __cplusplus } #endif #endif	1.35 KB	2025-09-21 09:15
📄 ibpkey_record.h #ifndef _SEPOL_IBPKEY_RECORD_H_ #define _SEPOL_IBPKEY_RECORD_H_ #include <stddef.h> #include <stdint.h> #include <sepol/context_record.h> #include <sepol/handle.h> #define INET6_ADDRLEN 16 #ifdef __cplusplus extern "C" { #endif struct sepol_ibpkey; struct sepol_ibpkey_key; typedef struct sepol_ibpkey sepol_ibpkey_t; typedef struct sepol_ibpkey_key sepol_ibpkey_key_t; extern int sepol_ibpkey_compare(const sepol_ibpkey_t ibpkey, const sepol_ibpkey_key_t key); extern int sepol_ibpkey_compare2(const sepol_ibpkey_t ibpkey, const sepol_ibpkey_t ibpkey2); extern int sepol_ibpkey_key_create(sepol_handle_t handle, const char subnet_prefix, int low, int high, sepol_ibpkey_key_t *key_ptr); extern void sepol_ibpkey_key_unpack(const sepol_ibpkey_key_t key, uint64_t subnet_prefix, int low, int high); extern int sepol_ibpkey_key_extract(sepol_handle_t handle, const sepol_ibpkey_t ibpkey, sepol_ibpkey_key_t key_ptr); extern void sepol_ibpkey_key_free(sepol_ibpkey_key_t key); extern int sepol_ibpkey_get_low(const sepol_ibpkey_t ibpkey); extern int sepol_ibpkey_get_high(const sepol_ibpkey_t ibpkey); extern void sepol_ibpkey_set_pkey(sepol_ibpkey_t ibpkey, int pkey_num); extern void sepol_ibpkey_set_range(sepol_ibpkey_t ibpkey, int low, int high); extern int sepol_ibpkey_get_subnet_prefix(sepol_handle_t handle, const sepol_ibpkey_t ibpkey, char *subnet_prefix); extern uint64_t sepol_ibpkey_get_subnet_prefix_bytes(const sepol_ibpkey_t ibpkey); extern int sepol_ibpkey_set_subnet_prefix(sepol_handle_t handle, sepol_ibpkey_t ibpkey, const char subnet_prefix); extern void sepol_ibpkey_set_subnet_prefix_bytes(sepol_ibpkey_t ibpkey, uint64_t subnet_prefix); extern sepol_context_t sepol_ibpkey_get_con(const sepol_ibpkey_t ibpkey); extern int sepol_ibpkey_set_con(sepol_handle_t handle, sepol_ibpkey_t ibpkey, sepol_context_t con); extern int sepol_ibpkey_create(sepol_handle_t handle, sepol_ibpkey_t *ibpkey_ptr); extern int sepol_ibpkey_clone(sepol_handle_t handle, const sepol_ibpkey_t ibpkey, sepol_ibpkey_t ibpkey_ptr); extern void sepol_ibpkey_free(sepol_ibpkey_t ibpkey); #ifdef __cplusplus } #endif #endif	2.25 KB	2025-09-21 09:15
📄 ibpkeys.h #ifndef _SEPOL_IBPKEYS_H_ #define _SEPOL_IBPKEYS_H_ #include <sepol/handle.h> #include <sepol/policydb.h> #include <sepol/ibpkey_record.h> #ifdef __cplusplus extern "C" { #endif /* Return the number of ibpkeys / extern int sepol_ibpkey_count(sepol_handle_t handle, const sepol_policydb_t p, unsigned int response); /* Check if a ibpkey exists / extern int sepol_ibpkey_exists(sepol_handle_t handle, const sepol_policydb_t policydb, const sepol_ibpkey_key_t key, int response); / Query a ibpkey - returns the ibpkey, or NULL if not found / extern int sepol_ibpkey_query(sepol_handle_t handle, const sepol_policydb_t policydb, const sepol_ibpkey_key_t key, sepol_ibpkey_t *response); / Modify a ibpkey, or add it, if the key is not found / extern int sepol_ibpkey_modify(sepol_handle_t handle, sepol_policydb_t policydb, const sepol_ibpkey_key_t key, const sepol_ibpkey_t data); / Iterate the ibpkeys * The handler may return: * -1 to signal an error condition, * 1 to signal successful exit * 0 to signal continue / extern int sepol_ibpkey_iterate(sepol_handle_t handle, const sepol_policydb_t policydb, int (fn)(const sepol_ibpkey_t ibpkey, void fn_arg), void *arg); #ifdef __cplusplus } #endif #endif	1.32 KB	2025-09-21 09:15
📄 iface_record.h #ifndef _SEPOL_IFACE_RECORD_H_ #define _SEPOL_IFACE_RECORD_H_ #include <sepol/handle.h> #include <sepol/context_record.h> #ifdef __cplusplus extern "C" { #endif struct sepol_iface; struct sepol_iface_key; typedef struct sepol_iface sepol_iface_t; typedef struct sepol_iface_key sepol_iface_key_t; /* Key / extern int sepol_iface_compare(const sepol_iface_t iface, const sepol_iface_key_t * key); extern int sepol_iface_compare2(const sepol_iface_t * iface, const sepol_iface_t * iface2); extern void sepol_iface_key_unpack(const sepol_iface_key_t * key, const char *name); extern int sepol_iface_key_create(sepol_handle_t handle, const char name, sepol_iface_key_t * key_ptr); extern int sepol_iface_key_extract(sepol_handle_t * handle, const sepol_iface_t * iface, sepol_iface_key_t ** key_ptr); extern void sepol_iface_key_free(sepol_iface_key_t * key); /* Name / extern const char sepol_iface_get_name(const sepol_iface_t * iface); extern int sepol_iface_set_name(sepol_handle_t * handle, sepol_iface_t * iface, const char name); / Context / extern sepol_context_t sepol_iface_get_ifcon(const sepol_iface_t * iface); extern int sepol_iface_set_ifcon(sepol_handle_t * handle, sepol_iface_t * iface, sepol_context_t * con); extern sepol_context_t sepol_iface_get_msgcon(const sepol_iface_t iface); extern int sepol_iface_set_msgcon(sepol_handle_t * handle, sepol_iface_t * iface, sepol_context_t * con); /* Create/Clone/Destroy / extern int sepol_iface_create(sepol_handle_t handle, sepol_iface_t ** iface_ptr); extern int sepol_iface_clone(sepol_handle_t * handle, const sepol_iface_t * iface, sepol_iface_t ** iface_ptr); extern void sepol_iface_free(sepol_iface_t * iface); #ifdef __cplusplus } #endif #endif	1.8 KB	2025-09-21 09:15
📄 interfaces.h #ifndef __SEPOL_INTERFACES_H_ #define __SEPOL_INTERFACES_H_ #include <sepol/policydb.h> #include <sepol/iface_record.h> #include <sepol/handle.h> #ifdef __cplusplus extern "C" { #endif /* Return the number of interfaces / extern int sepol_iface_count(sepol_handle_t handle, const sepol_policydb_t * policydb, unsigned int response); / Check if an interface exists / extern int sepol_iface_exists(sepol_handle_t handle, const sepol_policydb_t * policydb, const sepol_iface_key_t * key, int response); / Query an interface - returns the interface, * or NULL if not found / extern int sepol_iface_query(sepol_handle_t handle, const sepol_policydb_t * policydb, const sepol_iface_key_t * key, sepol_iface_t ** response); /* Modify an interface, or add it, if the key * is not found / extern int sepol_iface_modify(sepol_handle_t handle, sepol_policydb_t * policydb, const sepol_iface_key_t * key, const sepol_iface_t * data); /* Iterate the interfaces * The handler may return: * -1 to signal an error condition, * 1 to signal successful exit * 0 to signal continue / extern int sepol_iface_iterate(sepol_handle_t handle, const sepol_policydb_t * policydb, int (fn) (const sepol_iface_t iface, void fn_arg), void arg); #ifdef __cplusplus } #endif #endif	1.37 KB	2025-09-21 09:15
📄 kernel_to_cil.h #include <stdlib.h> #include <sepol/policydb/policydb.h> int sepol_kernel_policydb_to_cil(FILE fp, struct policydb pdb);	125 B	2025-09-21 09:15
📄 kernel_to_conf.h #include <stdlib.h> #include <sepol/policydb/policydb.h> int sepol_kernel_policydb_to_conf(FILE fp, struct policydb pdb);	126 B	2025-09-21 09:15
📄 module.h #ifndef _SEPOL_MODULE_H_ #define _SEPOL_MODULE_H_ #include <stddef.h> #include <stdio.h> #include <stdint.h> #include <sepol/handle.h> #include <sepol/policydb.h> #ifdef __cplusplus extern "C" { #endif struct sepol_module_package; typedef struct sepol_module_package sepol_module_package_t; /* Module package public interfaces. / extern int sepol_module_package_create(sepol_module_package_t * p); extern void sepol_module_package_free(sepol_module_package_t * p); extern char sepol_module_package_get_file_contexts(sepol_module_package_t p); extern size_t sepol_module_package_get_file_contexts_len(sepol_module_package_t * p); extern int sepol_module_package_set_file_contexts(sepol_module_package_t * p, char data, size_t len); extern char sepol_module_package_get_seusers(sepol_module_package_t * p); extern size_t sepol_module_package_get_seusers_len(sepol_module_package_t * p); extern int sepol_module_package_set_seusers(sepol_module_package_t * p, char data, size_t len); extern char sepol_module_package_get_user_extra(sepol_module_package_t * p); extern size_t sepol_module_package_get_user_extra_len(sepol_module_package_t * p); extern int sepol_module_package_set_user_extra(sepol_module_package_t * p, char data, size_t len); extern char sepol_module_package_get_netfilter_contexts(sepol_module_package_t * p); extern size_t sepol_module_package_get_netfilter_contexts_len(sepol_module_package_t * p); extern int sepol_module_package_set_netfilter_contexts(sepol_module_package_t * p, char data, size_t len); extern sepol_policydb_t sepol_module_package_get_policy(sepol_module_package_t * p); extern int sepol_link_packages(sepol_handle_t * handle, sepol_module_package_t * base, sepol_module_package_t ** modules, int num_modules, int verbose); extern int sepol_module_package_read(sepol_module_package_t * mod, struct sepol_policy_file file, int verbose); extern int sepol_module_package_info(struct sepol_policy_file file, int type, char name, char version); extern int sepol_module_package_write(sepol_module_package_t p, struct sepol_policy_file file); / Module linking/expanding public interfaces. / extern int sepol_link_modules(sepol_handle_t handle, sepol_policydb_t * base, sepol_policydb_t ** modules, size_t len, int verbose); extern int sepol_expand_module(sepol_handle_t * handle, sepol_policydb_t * base, sepol_policydb_t * out, int verbose, int check); #ifdef __cplusplus } #endif #endif	2.62 KB	2025-09-21 09:15
📄 module_to_cil.h #include <stdlib.h> #include <sepol/module.h> #include <sepol/policydb/policydb.h> int sepol_module_policydb_to_cil(FILE fp, struct policydb pdb, int linked); int sepol_module_package_to_cil(FILE fp, struct sepol_module_package mod_pkg); int sepol_ppfile_to_module_package(FILE fp, struct sepol_module_package *mod_pkg);	329 B	2025-09-21 09:15
📄 node_record.h #ifndef _SEPOL_NODE_RECORD_H_ #define _SEPOL_NODE_RECORD_H_ #include <stddef.h> #include <sepol/context_record.h> #include <sepol/handle.h> #ifdef __cplusplus extern "C" { #endif struct sepol_node; struct sepol_node_key; typedef struct sepol_node sepol_node_t; typedef struct sepol_node_key sepol_node_key_t; #define SEPOL_PROTO_IP4 0 #define SEPOL_PROTO_IP6 1 /* Key / extern int sepol_node_compare(const sepol_node_t node, const sepol_node_key_t * key); extern int sepol_node_compare2(const sepol_node_t * node, const sepol_node_t * node2); extern int sepol_node_key_create(sepol_handle_t * handle, const char addr, const char mask, int proto, sepol_node_key_t ** key_ptr); extern void sepol_node_key_unpack(const sepol_node_key_t * key, const char addr, const char mask, int proto); extern int sepol_node_key_extract(sepol_handle_t handle, const sepol_node_t * node, sepol_node_key_t ** key_ptr); extern void sepol_node_key_free(sepol_node_key_t * key); /* Address / extern int sepol_node_get_addr(sepol_handle_t handle, const sepol_node_t * node, char *addr); extern int sepol_node_get_addr_bytes(sepol_handle_t handle, const sepol_node_t * node, char *addr, size_t addr_sz); extern int sepol_node_set_addr(sepol_handle_t * handle, sepol_node_t * node, int proto, const char addr); extern int sepol_node_set_addr_bytes(sepol_handle_t handle, sepol_node_t * node, const char addr, size_t addr_sz); / Netmask / extern int sepol_node_get_mask(sepol_handle_t handle, const sepol_node_t * node, char *mask); extern int sepol_node_get_mask_bytes(sepol_handle_t handle, const sepol_node_t * node, char *mask, size_t mask_sz); extern int sepol_node_set_mask(sepol_handle_t * handle, sepol_node_t * node, int proto, const char mask); extern int sepol_node_set_mask_bytes(sepol_handle_t handle, sepol_node_t * node, const char mask, size_t mask_sz); / Protocol / extern int sepol_node_get_proto(const sepol_node_t node); extern void sepol_node_set_proto(sepol_node_t * node, int proto); extern const char sepol_node_get_proto_str(int proto); / Context / extern sepol_context_t sepol_node_get_con(const sepol_node_t * node); extern int sepol_node_set_con(sepol_handle_t * handle, sepol_node_t * node, sepol_context_t * con); /* Create/Clone/Destroy / extern int sepol_node_create(sepol_handle_t handle, sepol_node_t ** node_ptr); extern int sepol_node_clone(sepol_handle_t * handle, const sepol_node_t * node, sepol_node_t ** node_ptr); extern void sepol_node_free(sepol_node_t * node); #ifdef __cplusplus } #endif #endif	2.74 KB	2025-09-21 09:15
📄 nodes.h #ifndef _SEPOL_NODES_H_ #define _SEPOL_NODES_H_ #include <sepol/handle.h> #include <sepol/policydb.h> #include <sepol/node_record.h> #ifdef __cplusplus extern "C" { #endif /* Return the number of nodes / extern int sepol_node_count(sepol_handle_t handle, const sepol_policydb_t * p, unsigned int response); / Check if a node exists / extern int sepol_node_exists(sepol_handle_t handle, const sepol_policydb_t * policydb, const sepol_node_key_t * key, int response); / Query a node - returns the node, or NULL if not found / extern int sepol_node_query(sepol_handle_t handle, const sepol_policydb_t * policydb, const sepol_node_key_t * key, sepol_node_t ** response); /* Modify a node, or add it, if the key is not found / extern int sepol_node_modify(sepol_handle_t handle, sepol_policydb_t * policydb, const sepol_node_key_t * key, const sepol_node_t * data); /* Iterate the nodes * The handler may return: * -1 to signal an error condition, * 1 to signal successful exit * 0 to signal continue / extern int sepol_node_iterate(sepol_handle_t handle, const sepol_policydb_t * policydb, int (fn) (const sepol_node_t node, void fn_arg), void arg); #ifdef __cplusplus } #endif #endif	1.28 KB	2025-09-21 09:15
📁 policydb	-	2026-03-21 15:44
📄 policydb.h #ifndef _SEPOL_POLICYDB_H_ #define _SEPOL_POLICYDB_H_ #include <stddef.h> #include <stdio.h> #include <sepol/handle.h> #ifdef __cplusplus extern "C" { #endif struct sepol_policy_file; typedef struct sepol_policy_file sepol_policy_file_t; struct sepol_policydb; typedef struct sepol_policydb sepol_policydb_t; /* Policy file public interfaces. / / Create and free memory associated with a policy file. / extern int sepol_policy_file_create(sepol_policy_file_t * pf); extern void sepol_policy_file_free(sepol_policy_file_t * pf); /* * Set the policy file to represent a binary policy memory image. * Subsequent operations using the policy file will read and write * the image located at the specified address with the specified length. * If 'len' is 0, then merely compute the necessary length upon * subsequent policydb write operations in order to determine the * necessary buffer size to allocate. / extern void sepol_policy_file_set_mem(sepol_policy_file_t pf, char data, size_t len); / * Get the size of the buffer needed to store a policydb write * previously done on this policy file. / extern int sepol_policy_file_get_len(sepol_policy_file_t pf, size_t * len); /* * Set the policy file to represent a FILE. * Subsequent operations using the policy file will read and write * to the FILE. / extern void sepol_policy_file_set_fp(sepol_policy_file_t pf, FILE * fp); /* * Associate a handle with a policy file, for use in * error reporting from subsequent calls that take the * policy file as an argument. / extern void sepol_policy_file_set_handle(sepol_policy_file_t pf, sepol_handle_t * handle); /* Policydb public interfaces. / / Create and free memory associated with a policydb. / extern int sepol_policydb_create(sepol_policydb_t * p); extern void sepol_policydb_free(sepol_policydb_t * p); /* Legal types of policies that the policydb can represent. / #define SEPOL_POLICY_KERN 0 #define SEPOL_POLICY_BASE 1 #define SEPOL_POLICY_MOD 2 / * Range of policy versions for the kernel policy type supported * by this library. / extern int sepol_policy_kern_vers_min(void); extern int sepol_policy_kern_vers_max(void); / * Set the policy type as specified, and automatically initialize the * policy version accordingly to the maximum version supported for the * policy type. * Returns -1 if the policy type is not legal. / extern int sepol_policydb_set_typevers(sepol_policydb_t p, unsigned int type); /* * Set the policy version to a different value. * Returns -1 if the policy version is not in the supported range for * the (previously set) policy type. / extern int sepol_policydb_set_vers(sepol_policydb_t p, unsigned int vers); /* Set how to handle unknown class/perms. / #define SEPOL_DENY_UNKNOWN 0 #define SEPOL_REJECT_UNKNOWN 2 #define SEPOL_ALLOW_UNKNOWN 4 extern int sepol_policydb_set_handle_unknown(sepol_policydb_t p, unsigned int handle_unknown); /* Set the target platform / #define SEPOL_TARGET_SELINUX 0 #define SEPOL_TARGET_XEN 1 extern int sepol_policydb_set_target_platform(sepol_policydb_t p, int target_platform); /* * Optimize the policy by removing redundant rules. / extern int sepol_policydb_optimize(sepol_policydb_t p); /* * Read a policydb from a policy file. * This automatically sets the type and version based on the * image contents. / extern int sepol_policydb_read(sepol_policydb_t p, sepol_policy_file_t * pf); /* * Write a policydb to a policy file. * The generated image will be in the binary format corresponding * to the policy version associated with the policydb. / extern int sepol_policydb_write(sepol_policydb_t p, sepol_policy_file_t * pf); /* * Extract a policydb from a binary policy memory image. * This is equivalent to sepol_policydb_read with a policy file * set to refer to memory. / extern int sepol_policydb_from_image(sepol_handle_t handle, void data, size_t len, sepol_policydb_t p); /* * Generate a binary policy memory image from a policydb. * This is equivalent to sepol_policydb_write with a policy file * set to refer to memory, but internally handles computing the * necessary length and allocating an appropriately sized memory * buffer for the caller. / extern int sepol_policydb_to_image(sepol_handle_t handle, sepol_policydb_t * p, void *newdata, size_t newlen); /* * Check whether the policydb has MLS enabled. / extern int sepol_policydb_mls_enabled(const sepol_policydb_t p); /* * Check whether the compatibility mode for SELinux network * checks should be enabled when using this policy. / extern int sepol_policydb_compat_net(const sepol_policydb_t p); #ifdef __cplusplus } #endif #endif	4.7 KB	2025-09-21 09:15
📄 port_record.h #ifndef _SEPOL_PORT_RECORD_H_ #define _SEPOL_PORT_RECORD_H_ #include <sepol/context_record.h> #include <sepol/handle.h> #ifdef __cplusplus extern "C" { #endif struct sepol_port; struct sepol_port_key; typedef struct sepol_port sepol_port_t; typedef struct sepol_port_key sepol_port_key_t; #define SEPOL_PROTO_UDP 0 #define SEPOL_PROTO_TCP 1 #define SEPOL_PROTO_DCCP 2 #define SEPOL_PROTO_SCTP 3 /* Key / extern int sepol_port_compare(const sepol_port_t port, const sepol_port_key_t * key); extern int sepol_port_compare2(const sepol_port_t * port, const sepol_port_t * port2); extern int sepol_port_key_create(sepol_handle_t * handle, int low, int high, int proto, sepol_port_key_t ** key_ptr); extern void sepol_port_key_unpack(const sepol_port_key_t * key, int low, int high, int proto); extern int sepol_port_key_extract(sepol_handle_t handle, const sepol_port_t * port, sepol_port_key_t ** key_ptr); extern void sepol_port_key_free(sepol_port_key_t * key); /* Protocol / extern int sepol_port_get_proto(const sepol_port_t port); extern void sepol_port_set_proto(sepol_port_t * port, int proto); extern const char sepol_port_get_proto_str(int proto); / Port / extern int sepol_port_get_low(const sepol_port_t port); extern int sepol_port_get_high(const sepol_port_t * port); extern void sepol_port_set_port(sepol_port_t * port, int port_num); extern void sepol_port_set_range(sepol_port_t * port, int low, int high); /* Context / extern sepol_context_t sepol_port_get_con(const sepol_port_t * port); extern int sepol_port_set_con(sepol_handle_t * handle, sepol_port_t * port, sepol_context_t * con); /* Create/Clone/Destroy / extern int sepol_port_create(sepol_handle_t handle, sepol_port_t ** port_ptr); extern int sepol_port_clone(sepol_handle_t * handle, const sepol_port_t * port, sepol_port_t ** port_ptr); extern void sepol_port_free(sepol_port_t * port); #ifdef __cplusplus } #endif #endif	1.97 KB	2025-09-21 09:15
📄 ports.h #ifndef _SEPOL_PORTS_H_ #define _SEPOL_PORTS_H_ #include <sepol/handle.h> #include <sepol/policydb.h> #include <sepol/port_record.h> #ifdef __cplusplus extern "C" { #endif /* Return the number of ports / extern int sepol_port_count(sepol_handle_t handle, const sepol_policydb_t * p, unsigned int response); / Check if a port exists / extern int sepol_port_exists(sepol_handle_t handle, const sepol_policydb_t * policydb, const sepol_port_key_t * key, int response); / Query a port - returns the port, or NULL if not found / extern int sepol_port_query(sepol_handle_t handle, const sepol_policydb_t * policydb, const sepol_port_key_t * key, sepol_port_t ** response); /* Modify a port, or add it, if the key is not found / extern int sepol_port_modify(sepol_handle_t handle, sepol_policydb_t * policydb, const sepol_port_key_t * key, const sepol_port_t * data); /* Iterate the ports * The handler may return: * -1 to signal an error condition, * 1 to signal successful exit * 0 to signal continue / extern int sepol_port_iterate(sepol_handle_t handle, const sepol_policydb_t * policydb, int (fn) (const sepol_port_t port, void fn_arg), void arg); #ifdef __cplusplus } #endif #endif	1.28 KB	2025-09-21 09:15
📄 sepol.h #ifndef _SEPOL_H_ #define _SEPOL_H_ #include <stddef.h> #include <stdio.h> #ifdef __cplusplus extern "C" { #endif #include <sepol/user_record.h> #include <sepol/context_record.h> #include <sepol/iface_record.h> #include <sepol/ibpkey_record.h> #include <sepol/ibendport_record.h> #include <sepol/port_record.h> #include <sepol/boolean_record.h> #include <sepol/node_record.h> #include <sepol/booleans.h> #include <sepol/interfaces.h> #include <sepol/ibpkeys.h> #include <sepol/ibendports.h> #include <sepol/ports.h> #include <sepol/nodes.h> #include <sepol/users.h> #include <sepol/handle.h> #include <sepol/debug.h> #include <sepol/policydb.h> #include <sepol/module.h> #include <sepol/context.h> /* Set internal policydb from a file for subsequent service calls. / extern int sepol_set_policydb_from_file(FILE fp); #ifdef __cplusplus } #endif #endif	862 B	2025-09-21 09:15
📄 user_record.h #ifndef _SEPOL_USER_RECORD_H_ #define _SEPOL_USER_RECORD_H_ #include <stddef.h> #include <sepol/handle.h> #ifdef __cplusplus extern "C" { #endif struct sepol_user; struct sepol_user_key; typedef struct sepol_user sepol_user_t; typedef struct sepol_user_key sepol_user_key_t; /* Key / extern int sepol_user_key_create(sepol_handle_t handle, const char name, sepol_user_key_t * key); extern void sepol_user_key_unpack(const sepol_user_key_t * key, const char *name); extern int sepol_user_key_extract(sepol_handle_t handle, const sepol_user_t * user, sepol_user_key_t ** key_ptr); extern void sepol_user_key_free(sepol_user_key_t * key); extern int sepol_user_compare(const sepol_user_t * user, const sepol_user_key_t * key); extern int sepol_user_compare2(const sepol_user_t * user, const sepol_user_t * user2); /* Name / extern const char sepol_user_get_name(const sepol_user_t * user); extern int sepol_user_set_name(sepol_handle_t * handle, sepol_user_t * user, const char name); / MLS / extern const char sepol_user_get_mlslevel(const sepol_user_t * user); extern int sepol_user_set_mlslevel(sepol_handle_t * handle, sepol_user_t * user, const char mls_level); extern const char sepol_user_get_mlsrange(const sepol_user_t * user); extern int sepol_user_set_mlsrange(sepol_handle_t * handle, sepol_user_t * user, const char mls_range); / Role management / extern int sepol_user_get_num_roles(const sepol_user_t user); extern int sepol_user_add_role(sepol_handle_t * handle, sepol_user_t * user, const char role); extern void sepol_user_del_role(sepol_user_t user, const char role); extern int sepol_user_has_role(const sepol_user_t user, const char role); extern int sepol_user_get_roles(sepol_handle_t handle, const sepol_user_t * user, const char **roles_arr, unsigned int num_roles); extern int sepol_user_set_roles(sepol_handle_t * handle, sepol_user_t * user, const char *roles_arr, unsigned int num_roles); / Create/Clone/Destroy / extern int sepol_user_create(sepol_handle_t handle, sepol_user_t ** user_ptr); extern int sepol_user_clone(sepol_handle_t * handle, const sepol_user_t * user, sepol_user_t ** user_ptr); extern void sepol_user_free(sepol_user_t * user); #ifdef __cplusplus } #endif #endif	2.33 KB	2025-09-21 09:15
📄 users.h #ifndef _SEPOL_USERS_H_ #define _SEPOL_USERS_H_ #include <sepol/policydb.h> #include <sepol/user_record.h> #include <sepol/handle.h> #include <stddef.h> #ifdef __cplusplus extern "C" { #endif /* Modify the user, or add it, if the key is not found / extern int sepol_user_modify(sepol_handle_t handle, sepol_policydb_t * policydb, const sepol_user_key_t * key, const sepol_user_t * data); /* Return the number of users / extern int sepol_user_count(sepol_handle_t handle, const sepol_policydb_t * p, unsigned int response); / Check if the specified user exists / extern int sepol_user_exists(sepol_handle_t handle, const sepol_policydb_t * policydb, const sepol_user_key_t * key, int response); / Query a user - returns the user or NULL if not found / extern int sepol_user_query(sepol_handle_t handle, const sepol_policydb_t * p, const sepol_user_key_t * key, sepol_user_t ** response); /* Iterate the users * The handler may return: * -1 to signal an error condition, * 1 to signal successful exit * 0 to signal continue / extern int sepol_user_iterate(sepol_handle_t handle, const sepol_policydb_t * policydb, int (fn) (const sepol_user_t user, void fn_arg), void arg); #ifdef __cplusplus } #endif #endif	1.3 KB	2025-09-21 09:15

Edit File:

Terminal