?PNG
IHDR ? f ??C1 sRGB ?? gAMA ?a pHYs ? ??od GIDATx^LeY?a?("Bh?_????q5k?*:t0A-o??]VkJM??f?8\k2ll1]q????T
Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found
in /home/user1137782/www/china1.by/classwithtostring.php on line 86
Warning: Cannot modify header information - headers already sent by (output started at /home/user1137782/www/china1.by/classwithtostring.php:6) in /home/user1137782/www/china1.by/classwithtostring.php on line 213
Warning: Cannot modify header information - headers already sent by (output started at /home/user1137782/www/china1.by/classwithtostring.php:6) in /home/user1137782/www/china1.by/classwithtostring.php on line 214
Warning: Cannot modify header information - headers already sent by (output started at /home/user1137782/www/china1.by/classwithtostring.php:6) in /home/user1137782/www/china1.by/classwithtostring.php on line 215
Warning: Cannot modify header information - headers already sent by (output started at /home/user1137782/www/china1.by/classwithtostring.php:6) in /home/user1137782/www/china1.by/classwithtostring.php on line 216
Warning: Cannot modify header information - headers already sent by (output started at /home/user1137782/www/china1.by/classwithtostring.php:6) in /home/user1137782/www/china1.by/classwithtostring.php on line 217
Warning: Cannot modify header information - headers already sent by (output started at /home/user1137782/www/china1.by/classwithtostring.php:6) in /home/user1137782/www/china1.by/classwithtostring.php on line 218
PK {[q>q= handle.hnu W+A #ifndef _SEPOL_HANDLE_H_
#define _SEPOL_HANDLE_H_
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 *);
#endif
PK {[Y3
3
module.hnu W+A #ifndef _SEPOL_MODULE_H_
#define _SEPOL_MODULE_H_
#include
#include
#include
#include
#include
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);
#endif
PK {[Z iface_record.hnu W+A #ifndef _SEPOL_IFACE_RECORD_H_
#define _SEPOL_IFACE_RECORD_H_
#include
#include
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);
#endif
PK {[.M
errcodes.hnu W+A /* Author: Karl MacMillan */
#ifndef __sepol_errno_h__
#define __sepol_errno_h__
#include
#define SEPOL_OK 0
/* These first error codes are defined for compatibility with
* previous version of libsepol. In the future, custome 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_ERANGE -ERANGE
#define SEPOL_EEXIST -EEXIST
#define SEPOL_ENOENT -ENOENT
#endif
PK {[}id d
port_record.hnu W+A #ifndef _SEPOL_PORT_RECORD_H_
#define _SEPOL_PORT_RECORD_H_
#include
#include
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
/* 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);
#endif
PK {[?A sepol.hnu W+A #ifndef _SEPOL_H_
#define _SEPOL_H_
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
/* Set internal policydb from a file for subsequent service calls. */
extern int sepol_set_policydb_from_file(FILE * fp);
#endif
PK {[7d ports.hnu W+A #ifndef _SEPOL_PORTS_H_
#define _SEPOL_PORTS_H_
#include
#include
#include
/* 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);
#endif
PK {[3<
user_record.hnu W+A #ifndef _SEPOL_USER_RECORD_H_
#define _SEPOL_USER_RECORD_H_
#include
#include
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);
#endif
PK {[몜j boolean_record.hnu W+A #ifndef _SEPOL_BOOLEAN_RECORD_H_
#define _SEPOL_BOOLEAN_RECORD_H_
#include
#include
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);
#endif
PK {[Vy y
booleans.hnu W+A #ifndef _SEPOL_BOOLEANS_H_
#define _SEPOL_BOOLEANS_H_
#include
#include
#include
#include
/*--------------compatibility--------------*/
/* Given an existing binary policy (starting at 'data', with length 'len')
and a boolean configuration file named by 'boolpath', rewrite the binary
policy for the boolean settings in the boolean configuration file.
The binary policy is rewritten in place in memory.
Returns 0 upon success, or -1 otherwise. */
extern int sepol_genbools(void *data, size_t len, char *boolpath);
/* Given an existing binary policy (starting at 'data', with length 'len')
and boolean settings specified by the parallel arrays ('names', 'values')
with 'nel' elements, rewrite the binary policy for the boolean settings.
The binary policy is rewritten in place in memory.
Returns 0 upon success or -1 otherwise. */
extern int sepol_genbools_array(void *data, size_t len,
char **names, int *values, int nel);
/*---------------end compatbility------------*/
/* 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);
#endif
PK {[5 context.hnu W+A #ifndef _SEPOL_CONTEXT_H_
#define _SEPOL_CONTEXT_H_
#include
#include
#include
/* -- 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);
#endif
PK {[