From dbb0f81588cc28d5a5fc39d291f00d6e4754c7eb Mon Sep 17 00:00:00 2001 From: Daniel J Walsh Date: Apr 14 2008 18:54:09 +0000 Subject: - Add avc.h to swig code --- diff --git a/libselinux-rhat.patch b/libselinux-rhat.patch index 2954302..e3a919a 100644 --- a/libselinux-rhat.patch +++ b/libselinux-rhat.patch @@ -1,6 +1,6 @@ -diff --exclude-from=exclude -N -u -r nsalibselinux/src/label.c libselinux-2.0.59/src/label.c +diff --exclude-from=exclude -N -u -r nsalibselinux/src/label.c libselinux-2.0.61/src/label.c --- nsalibselinux/src/label.c 2007-07-16 14:20:46.000000000 -0400 -+++ libselinux-2.0.59/src/label.c 2008-03-13 19:40:24.000000000 -0400 ++++ libselinux-2.0.61/src/label.c 2008-04-09 08:54:15.000000000 -0400 @@ -95,7 +95,7 @@ if (compat_validate(rec, lr, "file_contexts", 0)) return NULL; @@ -18,9 +18,48 @@ diff --exclude-from=exclude -N -u -r nsalibselinux/src/label.c libselinux-2.0.59 free(rec); } -diff --exclude-from=exclude -N -u -r nsalibselinux/src/matchpathcon.c libselinux-2.0.59/src/matchpathcon.c +diff --exclude-from=exclude -N -u -r nsalibselinux/src/load_policy.c libselinux-2.0.61/src/load_policy.c +--- nsalibselinux/src/load_policy.c 2008-04-08 09:37:21.000000000 -0400 ++++ libselinux-2.0.61/src/load_policy.c 2008-04-09 09:02:16.000000000 -0400 +@@ -43,6 +43,9 @@ + + int load_setlocaldefs hidden = 1; + ++#undef max ++#define max(a, b) (((a) > (b)) ? (a) : (b)) ++ + int selinux_mkload_policy(int preservebools) + { + int kernvers = security_policyvers(); +@@ -127,11 +130,6 @@ + + #endif + +- if (usesepol) { +- maxvers = vers_max(); +- minvers = vers_min(); +- } +- + /* + * Check whether we need to support local boolean and user definitions. + */ +@@ -157,6 +155,13 @@ + if (preservebools && uname(&uts) == 0 && strverscmp(uts.release, "2.6.22") >= 0) + preservebools = 0; + ++ if (usesepol) { ++ maxvers = vers_max(); ++ minvers = vers_min(); ++ if (!setlocaldefs && !preservebools) ++ maxvers = max(kernvers, maxvers); ++ } ++ + vers = maxvers; + search: + snprintf(path, sizeof(path), "%s.%d", +diff --exclude-from=exclude -N -u -r nsalibselinux/src/matchpathcon.c libselinux-2.0.61/src/matchpathcon.c --- nsalibselinux/src/matchpathcon.c 2007-09-28 09:48:58.000000000 -0400 -+++ libselinux-2.0.59/src/matchpathcon.c 2008-03-13 19:23:39.000000000 -0400 ++++ libselinux-2.0.61/src/matchpathcon.c 2008-04-09 08:54:15.000000000 -0400 @@ -2,6 +2,7 @@ #include #include @@ -38,3 +77,2607 @@ diff --exclude-from=exclude -N -u -r nsalibselinux/src/matchpathcon.c libselinux va_end(ap); } +diff --exclude-from=exclude -N -u -r nsalibselinux/src/selinux.py libselinux-2.0.61/src/selinux.py +--- nsalibselinux/src/selinux.py 2008-01-23 14:36:29.000000000 -0500 ++++ libselinux-2.0.61/src/selinux.py 2008-04-10 16:21:08.000000000 -0400 +@@ -300,6 +300,204 @@ + selinux_file_context_cmp = _selinux.selinux_file_context_cmp + selinux_file_context_verify = _selinux.selinux_file_context_verify + selinux_lsetfilecon_default = _selinux.selinux_lsetfilecon_default ++class security_id(_object): ++ __swig_setmethods__ = {} ++ __setattr__ = lambda self, name, value: _swig_setattr(self, security_id, name, value) ++ __swig_getmethods__ = {} ++ __getattr__ = lambda self, name: _swig_getattr(self, security_id, name) ++ __repr__ = _swig_repr ++ __swig_setmethods__["ctx"] = _selinux.security_id_ctx_set ++ __swig_getmethods__["ctx"] = _selinux.security_id_ctx_get ++ if _newclass:ctx = _swig_property(_selinux.security_id_ctx_get, _selinux.security_id_ctx_set) ++ __swig_setmethods__["refcnt"] = _selinux.security_id_refcnt_set ++ __swig_getmethods__["refcnt"] = _selinux.security_id_refcnt_get ++ if _newclass:refcnt = _swig_property(_selinux.security_id_refcnt_get, _selinux.security_id_refcnt_set) ++ def __init__(self, *args): ++ this = _selinux.new_security_id(*args) ++ try: self.this.append(this) ++ except: self.this = this ++ __swig_destroy__ = _selinux.delete_security_id ++ __del__ = lambda self : None; ++security_id_swigregister = _selinux.security_id_swigregister ++security_id_swigregister(security_id) ++ ++avc_sid_to_context = _selinux.avc_sid_to_context ++avc_sid_to_context_raw = _selinux.avc_sid_to_context_raw ++avc_context_to_sid = _selinux.avc_context_to_sid ++avc_context_to_sid_raw = _selinux.avc_context_to_sid_raw ++sidget = _selinux.sidget ++sidput = _selinux.sidput ++avc_get_initial_sid = _selinux.avc_get_initial_sid ++class avc_entry_ref(_object): ++ __swig_setmethods__ = {} ++ __setattr__ = lambda self, name, value: _swig_setattr(self, avc_entry_ref, name, value) ++ __swig_getmethods__ = {} ++ __getattr__ = lambda self, name: _swig_getattr(self, avc_entry_ref, name) ++ __repr__ = _swig_repr ++ __swig_setmethods__["ae"] = _selinux.avc_entry_ref_ae_set ++ __swig_getmethods__["ae"] = _selinux.avc_entry_ref_ae_get ++ if _newclass:ae = _swig_property(_selinux.avc_entry_ref_ae_get, _selinux.avc_entry_ref_ae_set) ++ def __init__(self, *args): ++ this = _selinux.new_avc_entry_ref(*args) ++ try: self.this.append(this) ++ except: self.this = this ++ __swig_destroy__ = _selinux.delete_avc_entry_ref ++ __del__ = lambda self : None; ++avc_entry_ref_swigregister = _selinux.avc_entry_ref_swigregister ++avc_entry_ref_swigregister(avc_entry_ref) ++ ++class avc_memory_callback(_object): ++ __swig_setmethods__ = {} ++ __setattr__ = lambda self, name, value: _swig_setattr(self, avc_memory_callback, name, value) ++ __swig_getmethods__ = {} ++ __getattr__ = lambda self, name: _swig_getattr(self, avc_memory_callback, name) ++ __repr__ = _swig_repr ++ __swig_setmethods__["func_malloc"] = _selinux.avc_memory_callback_func_malloc_set ++ __swig_getmethods__["func_malloc"] = _selinux.avc_memory_callback_func_malloc_get ++ if _newclass:func_malloc = _swig_property(_selinux.avc_memory_callback_func_malloc_get, _selinux.avc_memory_callback_func_malloc_set) ++ __swig_setmethods__["func_free"] = _selinux.avc_memory_callback_func_free_set ++ __swig_getmethods__["func_free"] = _selinux.avc_memory_callback_func_free_get ++ if _newclass:func_free = _swig_property(_selinux.avc_memory_callback_func_free_get, _selinux.avc_memory_callback_func_free_set) ++ def __init__(self, *args): ++ this = _selinux.new_avc_memory_callback(*args) ++ try: self.this.append(this) ++ except: self.this = this ++ __swig_destroy__ = _selinux.delete_avc_memory_callback ++ __del__ = lambda self : None; ++avc_memory_callback_swigregister = _selinux.avc_memory_callback_swigregister ++avc_memory_callback_swigregister(avc_memory_callback) ++ ++class avc_log_callback(_object): ++ __swig_setmethods__ = {} ++ __setattr__ = lambda self, name, value: _swig_setattr(self, avc_log_callback, name, value) ++ __swig_getmethods__ = {} ++ __getattr__ = lambda self, name: _swig_getattr(self, avc_log_callback, name) ++ __repr__ = _swig_repr ++ __swig_setmethods__["func_log"] = _selinux.avc_log_callback_func_log_set ++ __swig_getmethods__["func_log"] = _selinux.avc_log_callback_func_log_get ++ if _newclass:func_log = _swig_property(_selinux.avc_log_callback_func_log_get, _selinux.avc_log_callback_func_log_set) ++ __swig_setmethods__["func_audit"] = _selinux.avc_log_callback_func_audit_set ++ __swig_getmethods__["func_audit"] = _selinux.avc_log_callback_func_audit_get ++ if _newclass:func_audit = _swig_property(_selinux.avc_log_callback_func_audit_get, _selinux.avc_log_callback_func_audit_set) ++ def __init__(self, *args): ++ this = _selinux.new_avc_log_callback(*args) ++ try: self.this.append(this) ++ except: self.this = this ++ __swig_destroy__ = _selinux.delete_avc_log_callback ++ __del__ = lambda self : None; ++avc_log_callback_swigregister = _selinux.avc_log_callback_swigregister ++avc_log_callback_swigregister(avc_log_callback) ++ ++class avc_thread_callback(_object): ++ __swig_setmethods__ = {} ++ __setattr__ = lambda self, name, value: _swig_setattr(self, avc_thread_callback, name, value) ++ __swig_getmethods__ = {} ++ __getattr__ = lambda self, name: _swig_getattr(self, avc_thread_callback, name) ++ __repr__ = _swig_repr ++ __swig_setmethods__["func_create_thread"] = _selinux.avc_thread_callback_func_create_thread_set ++ __swig_getmethods__["func_create_thread"] = _selinux.avc_thread_callback_func_create_thread_get ++ if _newclass:func_create_thread = _swig_property(_selinux.avc_thread_callback_func_create_thread_get, _selinux.avc_thread_callback_func_create_thread_set) ++ __swig_setmethods__["func_stop_thread"] = _selinux.avc_thread_callback_func_stop_thread_set ++ __swig_getmethods__["func_stop_thread"] = _selinux.avc_thread_callback_func_stop_thread_get ++ if _newclass:func_stop_thread = _swig_property(_selinux.avc_thread_callback_func_stop_thread_get, _selinux.avc_thread_callback_func_stop_thread_set) ++ def __init__(self, *args): ++ this = _selinux.new_avc_thread_callback(*args) ++ try: self.this.append(this) ++ except: self.this = this ++ __swig_destroy__ = _selinux.delete_avc_thread_callback ++ __del__ = lambda self : None; ++avc_thread_callback_swigregister = _selinux.avc_thread_callback_swigregister ++avc_thread_callback_swigregister(avc_thread_callback) ++ ++class avc_lock_callback(_object): ++ __swig_setmethods__ = {} ++ __setattr__ = lambda self, name, value: _swig_setattr(self, avc_lock_callback, name, value) ++ __swig_getmethods__ = {} ++ __getattr__ = lambda self, name: _swig_getattr(self, avc_lock_callback, name) ++ __repr__ = _swig_repr ++ __swig_setmethods__["func_alloc_lock"] = _selinux.avc_lock_callback_func_alloc_lock_set ++ __swig_getmethods__["func_alloc_lock"] = _selinux.avc_lock_callback_func_alloc_lock_get ++ if _newclass:func_alloc_lock = _swig_property(_selinux.avc_lock_callback_func_alloc_lock_get, _selinux.avc_lock_callback_func_alloc_lock_set) ++ __swig_setmethods__["func_get_lock"] = _selinux.avc_lock_callback_func_get_lock_set ++ __swig_getmethods__["func_get_lock"] = _selinux.avc_lock_callback_func_get_lock_get ++ if _newclass:func_get_lock = _swig_property(_selinux.avc_lock_callback_func_get_lock_get, _selinux.avc_lock_callback_func_get_lock_set) ++ __swig_setmethods__["func_release_lock"] = _selinux.avc_lock_callback_func_release_lock_set ++ __swig_getmethods__["func_release_lock"] = _selinux.avc_lock_callback_func_release_lock_get ++ if _newclass:func_release_lock = _swig_property(_selinux.avc_lock_callback_func_release_lock_get, _selinux.avc_lock_callback_func_release_lock_set) ++ __swig_setmethods__["func_free_lock"] = _selinux.avc_lock_callback_func_free_lock_set ++ __swig_getmethods__["func_free_lock"] = _selinux.avc_lock_callback_func_free_lock_get ++ if _newclass:func_free_lock = _swig_property(_selinux.avc_lock_callback_func_free_lock_get, _selinux.avc_lock_callback_func_free_lock_set) ++ def __init__(self, *args): ++ this = _selinux.new_avc_lock_callback(*args) ++ try: self.this.append(this) ++ except: self.this = this ++ __swig_destroy__ = _selinux.delete_avc_lock_callback ++ __del__ = lambda self : None; ++avc_lock_callback_swigregister = _selinux.avc_lock_callback_swigregister ++avc_lock_callback_swigregister(avc_lock_callback) ++ ++AVC_OPT_UNUSED = _selinux.AVC_OPT_UNUSED ++AVC_OPT_SETENFORCE = _selinux.AVC_OPT_SETENFORCE ++avc_init = _selinux.avc_init ++avc_open = _selinux.avc_open ++avc_cleanup = _selinux.avc_cleanup ++avc_reset = _selinux.avc_reset ++avc_destroy = _selinux.avc_destroy ++avc_has_perm_noaudit = _selinux.avc_has_perm_noaudit ++avc_has_perm = _selinux.avc_has_perm ++avc_audit = _selinux.avc_audit ++avc_compute_create = _selinux.avc_compute_create ++avc_compute_member = _selinux.avc_compute_member ++AVC_CALLBACK_GRANT = _selinux.AVC_CALLBACK_GRANT ++AVC_CALLBACK_TRY_REVOKE = _selinux.AVC_CALLBACK_TRY_REVOKE ++AVC_CALLBACK_REVOKE = _selinux.AVC_CALLBACK_REVOKE ++AVC_CALLBACK_RESET = _selinux.AVC_CALLBACK_RESET ++AVC_CALLBACK_AUDITALLOW_ENABLE = _selinux.AVC_CALLBACK_AUDITALLOW_ENABLE ++AVC_CALLBACK_AUDITALLOW_DISABLE = _selinux.AVC_CALLBACK_AUDITALLOW_DISABLE ++AVC_CALLBACK_AUDITDENY_ENABLE = _selinux.AVC_CALLBACK_AUDITDENY_ENABLE ++AVC_CALLBACK_AUDITDENY_DISABLE = _selinux.AVC_CALLBACK_AUDITDENY_DISABLE ++AVC_CACHE_STATS = _selinux.AVC_CACHE_STATS ++class avc_cache_stats(_object): ++ __swig_setmethods__ = {} ++ __setattr__ = lambda self, name, value: _swig_setattr(self, avc_cache_stats, name, value) ++ __swig_getmethods__ = {} ++ __getattr__ = lambda self, name: _swig_getattr(self, avc_cache_stats, name) ++ __repr__ = _swig_repr ++ __swig_setmethods__["entry_lookups"] = _selinux.avc_cache_stats_entry_lookups_set ++ __swig_getmethods__["entry_lookups"] = _selinux.avc_cache_stats_entry_lookups_get ++ if _newclass:entry_lookups = _swig_property(_selinux.avc_cache_stats_entry_lookups_get, _selinux.avc_cache_stats_entry_lookups_set) ++ __swig_setmethods__["entry_hits"] = _selinux.avc_cache_stats_entry_hits_set ++ __swig_getmethods__["entry_hits"] = _selinux.avc_cache_stats_entry_hits_get ++ if _newclass:entry_hits = _swig_property(_selinux.avc_cache_stats_entry_hits_get, _selinux.avc_cache_stats_entry_hits_set) ++ __swig_setmethods__["entry_misses"] = _selinux.avc_cache_stats_entry_misses_set ++ __swig_getmethods__["entry_misses"] = _selinux.avc_cache_stats_entry_misses_get ++ if _newclass:entry_misses = _swig_property(_selinux.avc_cache_stats_entry_misses_get, _selinux.avc_cache_stats_entry_misses_set) ++ __swig_setmethods__["entry_discards"] = _selinux.avc_cache_stats_entry_discards_set ++ __swig_getmethods__["entry_discards"] = _selinux.avc_cache_stats_entry_discards_get ++ if _newclass:entry_discards = _swig_property(_selinux.avc_cache_stats_entry_discards_get, _selinux.avc_cache_stats_entry_discards_set) ++ __swig_setmethods__["cav_lookups"] = _selinux.avc_cache_stats_cav_lookups_set ++ __swig_getmethods__["cav_lookups"] = _selinux.avc_cache_stats_cav_lookups_get ++ if _newclass:cav_lookups = _swig_property(_selinux.avc_cache_stats_cav_lookups_get, _selinux.avc_cache_stats_cav_lookups_set) ++ __swig_setmethods__["cav_hits"] = _selinux.avc_cache_stats_cav_hits_set ++ __swig_getmethods__["cav_hits"] = _selinux.avc_cache_stats_cav_hits_get ++ if _newclass:cav_hits = _swig_property(_selinux.avc_cache_stats_cav_hits_get, _selinux.avc_cache_stats_cav_hits_set) ++ __swig_setmethods__["cav_probes"] = _selinux.avc_cache_stats_cav_probes_set ++ __swig_getmethods__["cav_probes"] = _selinux.avc_cache_stats_cav_probes_get ++ if _newclass:cav_probes = _swig_property(_selinux.avc_cache_stats_cav_probes_get, _selinux.avc_cache_stats_cav_probes_set) ++ __swig_setmethods__["cav_misses"] = _selinux.avc_cache_stats_cav_misses_set ++ __swig_getmethods__["cav_misses"] = _selinux.avc_cache_stats_cav_misses_get ++ if _newclass:cav_misses = _swig_property(_selinux.avc_cache_stats_cav_misses_get, _selinux.avc_cache_stats_cav_misses_set) ++ def __init__(self, *args): ++ this = _selinux.new_avc_cache_stats(*args) ++ try: self.this.append(this) ++ except: self.this = this ++ __swig_destroy__ = _selinux.delete_avc_cache_stats ++ __del__ = lambda self : None; ++avc_cache_stats_swigregister = _selinux.avc_cache_stats_swigregister ++avc_cache_stats_swigregister(avc_cache_stats) ++ ++avc_av_stats = _selinux.avc_av_stats ++avc_sid_stats = _selinux.avc_sid_stats + selinux_default_type_path = _selinux.selinux_default_type_path + get_default_type = _selinux.get_default_type + SELINUX_DEFAULTUSER = _selinux.SELINUX_DEFAULTUSER +diff --exclude-from=exclude -N -u -r nsalibselinux/src/selinuxswig.i libselinux-2.0.61/src/selinuxswig.i +--- nsalibselinux/src/selinuxswig.i 2008-01-23 14:36:29.000000000 -0500 ++++ libselinux-2.0.61/src/selinuxswig.i 2008-04-10 16:20:59.000000000 -0400 +@@ -5,6 +5,7 @@ + %module selinux + %{ + #include "selinux/selinux.h" ++ #include "../include/selinux/avc.h" + #include "../include/selinux/selinux.h" + #include "../include/selinux/get_default_type.h" + #include "../include/selinux/get_context_list.h" +@@ -47,6 +48,10 @@ + %ignore set_matchpathcon_invalidcon; + %ignore set_matchpathcon_canoncon; + ++%ignore avc_add_callback; ++ + %include "../include/selinux/selinux.h" ++%include "../include/selinux/avc.h" + %include "../include/selinux/get_default_type.h" + %include "../include/selinux/get_context_list.h" ++ +diff --exclude-from=exclude -N -u -r nsalibselinux/src/selinuxswig_wrap.c libselinux-2.0.61/src/selinuxswig_wrap.c +--- nsalibselinux/src/selinuxswig_wrap.c 2008-01-23 14:36:29.000000000 -0500 ++++ libselinux-2.0.61/src/selinuxswig_wrap.c 2008-04-10 16:21:08.000000000 -0400 +@@ -2458,21 +2458,36 @@ + + #define SWIGTYPE_p_SELboolean swig_types[0] + #define SWIGTYPE_p_av_decision swig_types[1] +-#define SWIGTYPE_p_char swig_types[2] +-#define SWIGTYPE_p_f_int_p_q_const__char_v_______int swig_types[3] +-#define SWIGTYPE_p_f_p_p_char__int swig_types[4] +-#define SWIGTYPE_p_f_p_void_unsigned_short_p_char_size_t__int swig_types[5] +-#define SWIGTYPE_p_ino_t swig_types[6] +-#define SWIGTYPE_p_int swig_types[7] +-#define SWIGTYPE_p_p_char swig_types[8] +-#define SWIGTYPE_p_p_p_char swig_types[9] +-#define SWIGTYPE_p_security_class_mapping swig_types[10] +-#define SWIGTYPE_p_selinux_callback swig_types[11] +-#define SWIGTYPE_p_selinux_opt swig_types[12] +-#define SWIGTYPE_p_unsigned_int swig_types[13] +-#define SWIGTYPE_p_unsigned_short swig_types[14] +-static swig_type_info *swig_types[16]; +-static swig_module_info swig_module = {swig_types, 15, 0, 0, 0, 0}; ++#define SWIGTYPE_p_avc_cache_stats swig_types[2] ++#define SWIGTYPE_p_avc_entry swig_types[3] ++#define SWIGTYPE_p_avc_entry_ref swig_types[4] ++#define SWIGTYPE_p_avc_lock_callback swig_types[5] ++#define SWIGTYPE_p_avc_log_callback swig_types[6] ++#define SWIGTYPE_p_avc_memory_callback swig_types[7] ++#define SWIGTYPE_p_avc_thread_callback swig_types[8] ++#define SWIGTYPE_p_char swig_types[9] ++#define SWIGTYPE_p_f_int_p_q_const__char_v_______int swig_types[10] ++#define SWIGTYPE_p_f_p_f_void__void__p_void swig_types[11] ++#define SWIGTYPE_p_f_p_p_char__int swig_types[12] ++#define SWIGTYPE_p_f_p_q_const__char_v_______void swig_types[13] ++#define SWIGTYPE_p_f_p_void__void swig_types[14] ++#define SWIGTYPE_p_f_p_void_unsigned_short_p_char_size_t__int swig_types[15] ++#define SWIGTYPE_p_f_p_void_unsigned_short_p_char_size_t__void swig_types[16] ++#define SWIGTYPE_p_f_size_t__p_void swig_types[17] ++#define SWIGTYPE_p_f_void__p_void swig_types[18] ++#define SWIGTYPE_p_ino_t swig_types[19] ++#define SWIGTYPE_p_int swig_types[20] ++#define SWIGTYPE_p_p_char swig_types[21] ++#define SWIGTYPE_p_p_p_char swig_types[22] ++#define SWIGTYPE_p_p_security_id swig_types[23] ++#define SWIGTYPE_p_security_class_mapping swig_types[24] ++#define SWIGTYPE_p_security_id swig_types[25] ++#define SWIGTYPE_p_selinux_callback swig_types[26] ++#define SWIGTYPE_p_selinux_opt swig_types[27] ++#define SWIGTYPE_p_unsigned_int swig_types[28] ++#define SWIGTYPE_p_unsigned_short swig_types[29] ++static swig_type_info *swig_types[31]; ++static swig_module_info swig_module = {swig_types, 30, 0, 0, 0, 0}; + #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) + #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) + +@@ -2503,6 +2518,7 @@ + + + #include "selinux/selinux.h" ++ #include "../include/selinux/avc.h" + #include "../include/selinux/selinux.h" + #include "../include/selinux/get_default_type.h" + #include "../include/selinux/get_context_list.h" +@@ -7461,6 +7477,2079 @@ + } + + ++SWIGINTERN PyObject *_wrap_security_id_ctx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct security_id *arg1 = (struct security_id *) 0 ; ++ security_context_t arg2 = (security_context_t) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ int res2 ; ++ char *buf2 = 0 ; ++ int alloc2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:security_id_ctx_set",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_id_ctx_set" "', argument " "1"" of type '" "struct security_id *""'"); ++ } ++ arg1 = (struct security_id *)(argp1); ++ res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_id_ctx_set" "', argument " "2"" of type '" "security_context_t""'"); ++ } ++ arg2 = (security_context_t)(buf2); ++ if (arg1->ctx) free((char*)arg1->ctx); ++ if (arg2) { ++ size_t size = strlen((const char *)(arg2)) + 1; ++ arg1->ctx = (security_context_t)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size)); ++ } else { ++ arg1->ctx = 0; ++ } ++ resultobj = SWIG_Py_Void(); ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return resultobj; ++fail: ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_security_id_ctx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct security_id *arg1 = (struct security_id *) 0 ; ++ security_context_t result; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:security_id_ctx_get",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_id_ctx_get" "', argument " "1"" of type '" "struct security_id *""'"); ++ } ++ arg1 = (struct security_id *)(argp1); ++ result = (security_context_t) ((arg1)->ctx); ++ resultobj = SWIG_FromCharPtr((const char *)result); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_security_id_refcnt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct security_id *arg1 = (struct security_id *) 0 ; ++ unsigned int arg2 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ unsigned int val2 ; ++ int ecode2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:security_id_refcnt_set",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_id_refcnt_set" "', argument " "1"" of type '" "struct security_id *""'"); ++ } ++ arg1 = (struct security_id *)(argp1); ++ ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); ++ if (!SWIG_IsOK(ecode2)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "security_id_refcnt_set" "', argument " "2"" of type '" "unsigned int""'"); ++ } ++ arg2 = (unsigned int)(val2); ++ if (arg1) (arg1)->refcnt = arg2; ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_security_id_refcnt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct security_id *arg1 = (struct security_id *) 0 ; ++ unsigned int result; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:security_id_refcnt_get",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_id_refcnt_get" "', argument " "1"" of type '" "struct security_id *""'"); ++ } ++ arg1 = (struct security_id *)(argp1); ++ result = (unsigned int) ((arg1)->refcnt); ++ resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_new_security_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct security_id *result = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)":new_security_id")) SWIG_fail; ++ result = (struct security_id *)(struct security_id *) calloc(1, sizeof(struct security_id)); ++ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_security_id, SWIG_POINTER_NEW | 0 ); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_delete_security_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct security_id *arg1 = (struct security_id *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:delete_security_id",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, SWIG_POINTER_DISOWN | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_security_id" "', argument " "1"" of type '" "struct security_id *""'"); ++ } ++ arg1 = (struct security_id *)(argp1); ++ free((char *) arg1); ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *security_id_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *obj; ++ if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL; ++ SWIG_TypeNewClientData(SWIGTYPE_p_security_id, SWIG_NewClientData(obj)); ++ return SWIG_Py_Void(); ++} ++ ++SWIGINTERN PyObject *_wrap_avc_sid_to_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ security_id_t arg1 = (security_id_t) 0 ; ++ security_context_t *arg2 = (security_context_t *) 0 ; ++ int result; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ security_context_t temp2 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ arg2 = &temp2; ++ if (!PyArg_ParseTuple(args,(char *)"O:avc_sid_to_context",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_sid_to_context" "', argument " "1"" of type '" "security_id_t""'"); ++ } ++ arg1 = (security_id_t)(argp1); ++ result = (int)avc_sid_to_context(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ if (*arg2) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg2)); ++ freecon(*arg2); ++ } ++ else { ++ Py_INCREF(Py_None); ++ resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); ++ } ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_sid_to_context_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ security_id_t arg1 = (security_id_t) 0 ; ++ security_context_t *arg2 = (security_context_t *) 0 ; ++ int result; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ security_context_t temp2 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ arg2 = &temp2; ++ if (!PyArg_ParseTuple(args,(char *)"O:avc_sid_to_context_raw",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_sid_to_context_raw" "', argument " "1"" of type '" "security_id_t""'"); ++ } ++ arg1 = (security_id_t)(argp1); ++ result = (int)avc_sid_to_context_raw(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ if (*arg2) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg2)); ++ freecon(*arg2); ++ } ++ else { ++ Py_INCREF(Py_None); ++ resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); ++ } ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_context_to_sid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ security_context_t arg1 = (security_context_t) 0 ; ++ security_id_t *arg2 = (security_id_t *) 0 ; ++ int result; ++ int res1 ; ++ char *buf1 = 0 ; ++ int alloc1 = 0 ; ++ void *argp2 = 0 ; ++ int res2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:avc_context_to_sid",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_context_to_sid" "', argument " "1"" of type '" "security_context_t""'"); ++ } ++ arg1 = (security_context_t)(buf1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_security_id, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "avc_context_to_sid" "', argument " "2"" of type '" "security_id_t *""'"); ++ } ++ arg2 = (security_id_t *)(argp2); ++ result = (int)avc_context_to_sid(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); ++ return resultobj; ++fail: ++ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_context_to_sid_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ security_context_t arg1 = (security_context_t) 0 ; ++ security_id_t *arg2 = (security_id_t *) 0 ; ++ int result; ++ int res1 ; ++ char *buf1 = 0 ; ++ int alloc1 = 0 ; ++ void *argp2 = 0 ; ++ int res2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:avc_context_to_sid_raw",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_context_to_sid_raw" "', argument " "1"" of type '" "security_context_t""'"); ++ } ++ arg1 = (security_context_t)(buf1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_security_id, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "avc_context_to_sid_raw" "', argument " "2"" of type '" "security_id_t *""'"); ++ } ++ arg2 = (security_id_t *)(argp2); ++ result = (int)avc_context_to_sid_raw(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); ++ return resultobj; ++fail: ++ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_sidget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ security_id_t arg1 = (security_id_t) 0 ; ++ int result; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:sidget",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sidget" "', argument " "1"" of type '" "security_id_t""'"); ++ } ++ arg1 = (security_id_t)(argp1); ++ result = (int)sidget(arg1); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_sidput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ security_id_t arg1 = (security_id_t) 0 ; ++ int result; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:sidput",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sidput" "', argument " "1"" of type '" "security_id_t""'"); ++ } ++ arg1 = (security_id_t)(argp1); ++ result = (int)sidput(arg1); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_get_initial_sid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ char *arg1 = (char *) 0 ; ++ security_id_t *arg2 = (security_id_t *) 0 ; ++ int result; ++ int res1 ; ++ char *buf1 = 0 ; ++ int alloc1 = 0 ; ++ void *argp2 = 0 ; ++ int res2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:avc_get_initial_sid",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_get_initial_sid" "', argument " "1"" of type '" "char const *""'"); ++ } ++ arg1 = (char *)(buf1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_security_id, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "avc_get_initial_sid" "', argument " "2"" of type '" "security_id_t *""'"); ++ } ++ arg2 = (security_id_t *)(argp2); ++ result = (int)avc_get_initial_sid((char const *)arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); ++ return resultobj; ++fail: ++ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_entry_ref_ae_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_entry_ref *arg1 = (struct avc_entry_ref *) 0 ; ++ struct avc_entry *arg2 = (struct avc_entry *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ void *argp2 = 0 ; ++ int res2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:avc_entry_ref_ae_set",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_entry_ref, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_entry_ref_ae_set" "', argument " "1"" of type '" "struct avc_entry_ref *""'"); ++ } ++ arg1 = (struct avc_entry_ref *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_avc_entry, SWIG_POINTER_DISOWN | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "avc_entry_ref_ae_set" "', argument " "2"" of type '" "struct avc_entry *""'"); ++ } ++ arg2 = (struct avc_entry *)(argp2); ++ if (arg1) (arg1)->ae = arg2; ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_entry_ref_ae_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_entry_ref *arg1 = (struct avc_entry_ref *) 0 ; ++ struct avc_entry *result = 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:avc_entry_ref_ae_get",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_entry_ref, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_entry_ref_ae_get" "', argument " "1"" of type '" "struct avc_entry_ref *""'"); ++ } ++ arg1 = (struct avc_entry_ref *)(argp1); ++ result = (struct avc_entry *) ((arg1)->ae); ++ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_avc_entry, 0 | 0 ); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_new_avc_entry_ref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_entry_ref *result = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)":new_avc_entry_ref")) SWIG_fail; ++ result = (struct avc_entry_ref *)(struct avc_entry_ref *) calloc(1, sizeof(struct avc_entry_ref)); ++ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_avc_entry_ref, SWIG_POINTER_NEW | 0 ); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_delete_avc_entry_ref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_entry_ref *arg1 = (struct avc_entry_ref *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:delete_avc_entry_ref",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_entry_ref, SWIG_POINTER_DISOWN | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_avc_entry_ref" "', argument " "1"" of type '" "struct avc_entry_ref *""'"); ++ } ++ arg1 = (struct avc_entry_ref *)(argp1); ++ free((char *) arg1); ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *avc_entry_ref_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *obj; ++ if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL; ++ SWIG_TypeNewClientData(SWIGTYPE_p_avc_entry_ref, SWIG_NewClientData(obj)); ++ return SWIG_Py_Void(); ++} ++ ++SWIGINTERN PyObject *_wrap_avc_memory_callback_func_malloc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_memory_callback *arg1 = (struct avc_memory_callback *) 0 ; ++ void *(*arg2)(size_t) = (void *(*)(size_t)) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:avc_memory_callback_func_malloc_set",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_memory_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_memory_callback_func_malloc_set" "', argument " "1"" of type '" "struct avc_memory_callback *""'"); ++ } ++ arg1 = (struct avc_memory_callback *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_size_t__p_void); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "avc_memory_callback_func_malloc_set" "', argument " "2"" of type '" "void *(*)(size_t)""'"); ++ } ++ } ++ if (arg1) (arg1)->func_malloc = arg2; ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_memory_callback_func_malloc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_memory_callback *arg1 = (struct avc_memory_callback *) 0 ; ++ void *(*result)(size_t) = 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:avc_memory_callback_func_malloc_get",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_memory_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_memory_callback_func_malloc_get" "', argument " "1"" of type '" "struct avc_memory_callback *""'"); ++ } ++ arg1 = (struct avc_memory_callback *)(argp1); ++ result = (void *(*)(size_t)) ((arg1)->func_malloc); ++ resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_size_t__p_void); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_memory_callback_func_free_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_memory_callback *arg1 = (struct avc_memory_callback *) 0 ; ++ void (*arg2)(void *) = (void (*)(void *)) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:avc_memory_callback_func_free_set",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_memory_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_memory_callback_func_free_set" "', argument " "1"" of type '" "struct avc_memory_callback *""'"); ++ } ++ arg1 = (struct avc_memory_callback *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__void); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "avc_memory_callback_func_free_set" "', argument " "2"" of type '" "void (*)(void *)""'"); ++ } ++ } ++ if (arg1) (arg1)->func_free = arg2; ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_memory_callback_func_free_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_memory_callback *arg1 = (struct avc_memory_callback *) 0 ; ++ void (*result)(void *) = 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:avc_memory_callback_func_free_get",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_memory_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_memory_callback_func_free_get" "', argument " "1"" of type '" "struct avc_memory_callback *""'"); ++ } ++ arg1 = (struct avc_memory_callback *)(argp1); ++ result = (void (*)(void *)) ((arg1)->func_free); ++ resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__void); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_new_avc_memory_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_memory_callback *result = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)":new_avc_memory_callback")) SWIG_fail; ++ result = (struct avc_memory_callback *)(struct avc_memory_callback *) calloc(1, sizeof(struct avc_memory_callback)); ++ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_avc_memory_callback, SWIG_POINTER_NEW | 0 ); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_delete_avc_memory_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_memory_callback *arg1 = (struct avc_memory_callback *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:delete_avc_memory_callback",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_memory_callback, SWIG_POINTER_DISOWN | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_avc_memory_callback" "', argument " "1"" of type '" "struct avc_memory_callback *""'"); ++ } ++ arg1 = (struct avc_memory_callback *)(argp1); ++ free((char *) arg1); ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *avc_memory_callback_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *obj; ++ if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL; ++ SWIG_TypeNewClientData(SWIGTYPE_p_avc_memory_callback, SWIG_NewClientData(obj)); ++ return SWIG_Py_Void(); ++} ++ ++SWIGINTERN PyObject *_wrap_avc_log_callback_func_log_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_log_callback *arg1 = (struct avc_log_callback *) 0 ; ++ void (*arg2)(char const *,...) = (void (*)(char const *,...)) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:avc_log_callback_func_log_set",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_log_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_log_callback_func_log_set" "', argument " "1"" of type '" "struct avc_log_callback *""'"); ++ } ++ arg1 = (struct avc_log_callback *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__char_v_______void); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "avc_log_callback_func_log_set" "', argument " "2"" of type '" "void (*)(char const *,...)""'"); ++ } ++ } ++ if (arg1) (arg1)->func_log = arg2; ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_log_callback_func_log_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_log_callback *arg1 = (struct avc_log_callback *) 0 ; ++ void (*result)(char const *,...) = 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:avc_log_callback_func_log_get",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_log_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_log_callback_func_log_get" "', argument " "1"" of type '" "struct avc_log_callback *""'"); ++ } ++ arg1 = (struct avc_log_callback *)(argp1); ++ result = (void (*)(char const *,...)) ((arg1)->func_log); ++ resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_v_______void); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_log_callback_func_audit_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_log_callback *arg1 = (struct avc_log_callback *) 0 ; ++ void (*arg2)(void *,security_class_t,char *,size_t) = (void (*)(void *,security_class_t,char *,size_t)) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:avc_log_callback_func_audit_set",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_log_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_log_callback_func_audit_set" "', argument " "1"" of type '" "struct avc_log_callback *""'"); ++ } ++ arg1 = (struct avc_log_callback *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_unsigned_short_p_char_size_t__void); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "avc_log_callback_func_audit_set" "', argument " "2"" of type '" "void (*)(void *,security_class_t,char *,size_t)""'"); ++ } ++ } ++ if (arg1) (arg1)->func_audit = arg2; ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_log_callback_func_audit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_log_callback *arg1 = (struct avc_log_callback *) 0 ; ++ void (*result)(void *,security_class_t,char *,size_t) = 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:avc_log_callback_func_audit_get",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_log_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_log_callback_func_audit_get" "', argument " "1"" of type '" "struct avc_log_callback *""'"); ++ } ++ arg1 = (struct avc_log_callback *)(argp1); ++ result = (void (*)(void *,security_class_t,char *,size_t)) ((arg1)->func_audit); ++ resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_unsigned_short_p_char_size_t__void); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_new_avc_log_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_log_callback *result = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)":new_avc_log_callback")) SWIG_fail; ++ result = (struct avc_log_callback *)(struct avc_log_callback *) calloc(1, sizeof(struct avc_log_callback)); ++ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_avc_log_callback, SWIG_POINTER_NEW | 0 ); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_delete_avc_log_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_log_callback *arg1 = (struct avc_log_callback *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:delete_avc_log_callback",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_log_callback, SWIG_POINTER_DISOWN | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_avc_log_callback" "', argument " "1"" of type '" "struct avc_log_callback *""'"); ++ } ++ arg1 = (struct avc_log_callback *)(argp1); ++ free((char *) arg1); ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *avc_log_callback_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *obj; ++ if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL; ++ SWIG_TypeNewClientData(SWIGTYPE_p_avc_log_callback, SWIG_NewClientData(obj)); ++ return SWIG_Py_Void(); ++} ++ ++SWIGINTERN PyObject *_wrap_avc_thread_callback_func_create_thread_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_thread_callback *arg1 = (struct avc_thread_callback *) 0 ; ++ void *(*arg2)(void (*)(void)) = (void *(*)(void (*)(void))) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:avc_thread_callback_func_create_thread_set",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_thread_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_thread_callback_func_create_thread_set" "', argument " "1"" of type '" "struct avc_thread_callback *""'"); ++ } ++ arg1 = (struct avc_thread_callback *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_f_void__void__p_void); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "avc_thread_callback_func_create_thread_set" "', argument " "2"" of type '" "void *(*)(void (*)(void))""'"); ++ } ++ } ++ if (arg1) (arg1)->func_create_thread = arg2; ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_thread_callback_func_create_thread_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_thread_callback *arg1 = (struct avc_thread_callback *) 0 ; ++ void *(*result)(void (*)(void)) = 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:avc_thread_callback_func_create_thread_get",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_thread_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_thread_callback_func_create_thread_get" "', argument " "1"" of type '" "struct avc_thread_callback *""'"); ++ } ++ arg1 = (struct avc_thread_callback *)(argp1); ++ result = (void *(*)(void (*)(void))) ((arg1)->func_create_thread); ++ resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_f_void__void__p_void); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_thread_callback_func_stop_thread_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_thread_callback *arg1 = (struct avc_thread_callback *) 0 ; ++ void (*arg2)(void *) = (void (*)(void *)) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:avc_thread_callback_func_stop_thread_set",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_thread_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_thread_callback_func_stop_thread_set" "', argument " "1"" of type '" "struct avc_thread_callback *""'"); ++ } ++ arg1 = (struct avc_thread_callback *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__void); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "avc_thread_callback_func_stop_thread_set" "', argument " "2"" of type '" "void (*)(void *)""'"); ++ } ++ } ++ if (arg1) (arg1)->func_stop_thread = arg2; ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_thread_callback_func_stop_thread_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_thread_callback *arg1 = (struct avc_thread_callback *) 0 ; ++ void (*result)(void *) = 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:avc_thread_callback_func_stop_thread_get",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_thread_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_thread_callback_func_stop_thread_get" "', argument " "1"" of type '" "struct avc_thread_callback *""'"); ++ } ++ arg1 = (struct avc_thread_callback *)(argp1); ++ result = (void (*)(void *)) ((arg1)->func_stop_thread); ++ resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__void); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_new_avc_thread_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_thread_callback *result = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)":new_avc_thread_callback")) SWIG_fail; ++ result = (struct avc_thread_callback *)(struct avc_thread_callback *) calloc(1, sizeof(struct avc_thread_callback)); ++ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_avc_thread_callback, SWIG_POINTER_NEW | 0 ); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_delete_avc_thread_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_thread_callback *arg1 = (struct avc_thread_callback *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:delete_avc_thread_callback",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_thread_callback, SWIG_POINTER_DISOWN | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_avc_thread_callback" "', argument " "1"" of type '" "struct avc_thread_callback *""'"); ++ } ++ arg1 = (struct avc_thread_callback *)(argp1); ++ free((char *) arg1); ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *avc_thread_callback_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *obj; ++ if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL; ++ SWIG_TypeNewClientData(SWIGTYPE_p_avc_thread_callback, SWIG_NewClientData(obj)); ++ return SWIG_Py_Void(); ++} ++ ++SWIGINTERN PyObject *_wrap_avc_lock_callback_func_alloc_lock_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_lock_callback *arg1 = (struct avc_lock_callback *) 0 ; ++ void *(*arg2)(void) = (void *(*)(void)) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:avc_lock_callback_func_alloc_lock_set",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_lock_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_lock_callback_func_alloc_lock_set" "', argument " "1"" of type '" "struct avc_lock_callback *""'"); ++ } ++ arg1 = (struct avc_lock_callback *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_void__p_void); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "avc_lock_callback_func_alloc_lock_set" "', argument " "2"" of type '" "void *(*)(void)""'"); ++ } ++ } ++ if (arg1) (arg1)->func_alloc_lock = arg2; ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_lock_callback_func_alloc_lock_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_lock_callback *arg1 = (struct avc_lock_callback *) 0 ; ++ void *(*result)(void) = 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:avc_lock_callback_func_alloc_lock_get",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_lock_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_lock_callback_func_alloc_lock_get" "', argument " "1"" of type '" "struct avc_lock_callback *""'"); ++ } ++ arg1 = (struct avc_lock_callback *)(argp1); ++ result = (void *(*)(void)) ((arg1)->func_alloc_lock); ++ resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_void__p_void); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_lock_callback_func_get_lock_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_lock_callback *arg1 = (struct avc_lock_callback *) 0 ; ++ void (*arg2)(void *) = (void (*)(void *)) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:avc_lock_callback_func_get_lock_set",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_lock_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_lock_callback_func_get_lock_set" "', argument " "1"" of type '" "struct avc_lock_callback *""'"); ++ } ++ arg1 = (struct avc_lock_callback *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__void); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "avc_lock_callback_func_get_lock_set" "', argument " "2"" of type '" "void (*)(void *)""'"); ++ } ++ } ++ if (arg1) (arg1)->func_get_lock = arg2; ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_lock_callback_func_get_lock_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_lock_callback *arg1 = (struct avc_lock_callback *) 0 ; ++ void (*result)(void *) = 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:avc_lock_callback_func_get_lock_get",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_lock_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_lock_callback_func_get_lock_get" "', argument " "1"" of type '" "struct avc_lock_callback *""'"); ++ } ++ arg1 = (struct avc_lock_callback *)(argp1); ++ result = (void (*)(void *)) ((arg1)->func_get_lock); ++ resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__void); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_lock_callback_func_release_lock_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_lock_callback *arg1 = (struct avc_lock_callback *) 0 ; ++ void (*arg2)(void *) = (void (*)(void *)) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:avc_lock_callback_func_release_lock_set",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_lock_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_lock_callback_func_release_lock_set" "', argument " "1"" of type '" "struct avc_lock_callback *""'"); ++ } ++ arg1 = (struct avc_lock_callback *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__void); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "avc_lock_callback_func_release_lock_set" "', argument " "2"" of type '" "void (*)(void *)""'"); ++ } ++ } ++ if (arg1) (arg1)->func_release_lock = arg2; ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_lock_callback_func_release_lock_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_lock_callback *arg1 = (struct avc_lock_callback *) 0 ; ++ void (*result)(void *) = 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:avc_lock_callback_func_release_lock_get",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_lock_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_lock_callback_func_release_lock_get" "', argument " "1"" of type '" "struct avc_lock_callback *""'"); ++ } ++ arg1 = (struct avc_lock_callback *)(argp1); ++ result = (void (*)(void *)) ((arg1)->func_release_lock); ++ resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__void); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_lock_callback_func_free_lock_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_lock_callback *arg1 = (struct avc_lock_callback *) 0 ; ++ void (*arg2)(void *) = (void (*)(void *)) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:avc_lock_callback_func_free_lock_set",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_lock_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_lock_callback_func_free_lock_set" "', argument " "1"" of type '" "struct avc_lock_callback *""'"); ++ } ++ arg1 = (struct avc_lock_callback *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__void); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "avc_lock_callback_func_free_lock_set" "', argument " "2"" of type '" "void (*)(void *)""'"); ++ } ++ } ++ if (arg1) (arg1)->func_free_lock = arg2; ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_lock_callback_func_free_lock_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_lock_callback *arg1 = (struct avc_lock_callback *) 0 ; ++ void (*result)(void *) = 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:avc_lock_callback_func_free_lock_get",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_lock_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_lock_callback_func_free_lock_get" "', argument " "1"" of type '" "struct avc_lock_callback *""'"); ++ } ++ arg1 = (struct avc_lock_callback *)(argp1); ++ result = (void (*)(void *)) ((arg1)->func_free_lock); ++ resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__void); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_new_avc_lock_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_lock_callback *result = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)":new_avc_lock_callback")) SWIG_fail; ++ result = (struct avc_lock_callback *)(struct avc_lock_callback *) calloc(1, sizeof(struct avc_lock_callback)); ++ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_avc_lock_callback, SWIG_POINTER_NEW | 0 ); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_delete_avc_lock_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_lock_callback *arg1 = (struct avc_lock_callback *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:delete_avc_lock_callback",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_lock_callback, SWIG_POINTER_DISOWN | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_avc_lock_callback" "', argument " "1"" of type '" "struct avc_lock_callback *""'"); ++ } ++ arg1 = (struct avc_lock_callback *)(argp1); ++ free((char *) arg1); ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *avc_lock_callback_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *obj; ++ if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL; ++ SWIG_TypeNewClientData(SWIGTYPE_p_avc_lock_callback, SWIG_NewClientData(obj)); ++ return SWIG_Py_Void(); ++} ++ ++SWIGINTERN PyObject *_wrap_avc_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ char *arg1 = (char *) 0 ; ++ struct avc_memory_callback *arg2 = (struct avc_memory_callback *) 0 ; ++ struct avc_log_callback *arg3 = (struct avc_log_callback *) 0 ; ++ struct avc_thread_callback *arg4 = (struct avc_thread_callback *) 0 ; ++ struct avc_lock_callback *arg5 = (struct avc_lock_callback *) 0 ; ++ int result; ++ int res1 ; ++ char *buf1 = 0 ; ++ int alloc1 = 0 ; ++ void *argp2 = 0 ; ++ int res2 = 0 ; ++ void *argp3 = 0 ; ++ int res3 = 0 ; ++ void *argp4 = 0 ; ++ int res4 = 0 ; ++ void *argp5 = 0 ; ++ int res5 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ PyObject * obj3 = 0 ; ++ PyObject * obj4 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OOOOO:avc_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; ++ res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_init" "', argument " "1"" of type '" "char const *""'"); ++ } ++ arg1 = (char *)(buf1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_avc_memory_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "avc_init" "', argument " "2"" of type '" "struct avc_memory_callback const *""'"); ++ } ++ arg2 = (struct avc_memory_callback *)(argp2); ++ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_avc_log_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "avc_init" "', argument " "3"" of type '" "struct avc_log_callback const *""'"); ++ } ++ arg3 = (struct avc_log_callback *)(argp3); ++ res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_avc_thread_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res4)) { ++ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "avc_init" "', argument " "4"" of type '" "struct avc_thread_callback const *""'"); ++ } ++ arg4 = (struct avc_thread_callback *)(argp4); ++ res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_avc_lock_callback, 0 | 0 ); ++ if (!SWIG_IsOK(res5)) { ++ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "avc_init" "', argument " "5"" of type '" "struct avc_lock_callback const *""'"); ++ } ++ arg5 = (struct avc_lock_callback *)(argp5); ++ result = (int)avc_init((char const *)arg1,(struct avc_memory_callback const *)arg2,(struct avc_log_callback const *)arg3,(struct avc_thread_callback const *)arg4,(struct avc_lock_callback const *)arg5); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); ++ return resultobj; ++fail: ++ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct selinux_opt *arg1 = (struct selinux_opt *) 0 ; ++ unsigned int arg2 ; ++ int result; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ unsigned int val2 ; ++ int ecode2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:avc_open",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_selinux_opt, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_open" "', argument " "1"" of type '" "struct selinux_opt *""'"); ++ } ++ arg1 = (struct selinux_opt *)(argp1); ++ ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); ++ if (!SWIG_IsOK(ecode2)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "avc_open" "', argument " "2"" of type '" "unsigned int""'"); ++ } ++ arg2 = (unsigned int)(val2); ++ result = (int)avc_open(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_cleanup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ ++ if (!PyArg_ParseTuple(args,(char *)":avc_cleanup")) SWIG_fail; ++ avc_cleanup(); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ int result; ++ ++ if (!PyArg_ParseTuple(args,(char *)":avc_reset")) SWIG_fail; ++ result = (int)avc_reset(); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ ++ if (!PyArg_ParseTuple(args,(char *)":avc_destroy")) SWIG_fail; ++ avc_destroy(); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_has_perm_noaudit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ security_id_t arg1 = (security_id_t) 0 ; ++ security_id_t arg2 = (security_id_t) 0 ; ++ security_class_t arg3 ; ++ access_vector_t arg4 ; ++ struct avc_entry_ref *arg5 = (struct avc_entry_ref *) 0 ; ++ struct av_decision *arg6 = (struct av_decision *) 0 ; ++ int result; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ void *argp2 = 0 ; ++ int res2 = 0 ; ++ unsigned short val3 ; ++ int ecode3 = 0 ; ++ unsigned int val4 ; ++ int ecode4 = 0 ; ++ void *argp5 = 0 ; ++ int res5 = 0 ; ++ void *argp6 = 0 ; ++ int res6 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ PyObject * obj3 = 0 ; ++ PyObject * obj4 = 0 ; ++ PyObject * obj5 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OOOOOO:avc_has_perm_noaudit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_has_perm_noaudit" "', argument " "1"" of type '" "security_id_t""'"); ++ } ++ arg1 = (security_id_t)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_security_id, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "avc_has_perm_noaudit" "', argument " "2"" of type '" "security_id_t""'"); ++ } ++ arg2 = (security_id_t)(argp2); ++ ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); ++ if (!SWIG_IsOK(ecode3)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "avc_has_perm_noaudit" "', argument " "3"" of type '" "security_class_t""'"); ++ } ++ arg3 = (security_class_t)(val3); ++ ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4); ++ if (!SWIG_IsOK(ecode4)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "avc_has_perm_noaudit" "', argument " "4"" of type '" "access_vector_t""'"); ++ } ++ arg4 = (access_vector_t)(val4); ++ res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_avc_entry_ref, 0 | 0 ); ++ if (!SWIG_IsOK(res5)) { ++ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "avc_has_perm_noaudit" "', argument " "5"" of type '" "struct avc_entry_ref *""'"); ++ } ++ arg5 = (struct avc_entry_ref *)(argp5); ++ res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_av_decision, 0 | 0 ); ++ if (!SWIG_IsOK(res6)) { ++ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "avc_has_perm_noaudit" "', argument " "6"" of type '" "struct av_decision *""'"); ++ } ++ arg6 = (struct av_decision *)(argp6); ++ result = (int)avc_has_perm_noaudit(arg1,arg2,arg3,arg4,arg5,arg6); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_has_perm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ security_id_t arg1 = (security_id_t) 0 ; ++ security_id_t arg2 = (security_id_t) 0 ; ++ security_class_t arg3 ; ++ access_vector_t arg4 ; ++ struct avc_entry_ref *arg5 = (struct avc_entry_ref *) 0 ; ++ void *arg6 = (void *) 0 ; ++ int result; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ void *argp2 = 0 ; ++ int res2 = 0 ; ++ unsigned short val3 ; ++ int ecode3 = 0 ; ++ unsigned int val4 ; ++ int ecode4 = 0 ; ++ void *argp5 = 0 ; ++ int res5 = 0 ; ++ int res6 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ PyObject * obj3 = 0 ; ++ PyObject * obj4 = 0 ; ++ PyObject * obj5 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OOOOOO:avc_has_perm",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_has_perm" "', argument " "1"" of type '" "security_id_t""'"); ++ } ++ arg1 = (security_id_t)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_security_id, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "avc_has_perm" "', argument " "2"" of type '" "security_id_t""'"); ++ } ++ arg2 = (security_id_t)(argp2); ++ ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); ++ if (!SWIG_IsOK(ecode3)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "avc_has_perm" "', argument " "3"" of type '" "security_class_t""'"); ++ } ++ arg3 = (security_class_t)(val3); ++ ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4); ++ if (!SWIG_IsOK(ecode4)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "avc_has_perm" "', argument " "4"" of type '" "access_vector_t""'"); ++ } ++ arg4 = (access_vector_t)(val4); ++ res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_avc_entry_ref, 0 | 0 ); ++ if (!SWIG_IsOK(res5)) { ++ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "avc_has_perm" "', argument " "5"" of type '" "struct avc_entry_ref *""'"); ++ } ++ arg5 = (struct avc_entry_ref *)(argp5); ++ res6 = SWIG_ConvertPtr(obj5,SWIG_as_voidptrptr(&arg6), 0, 0); ++ if (!SWIG_IsOK(res6)) { ++ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "avc_has_perm" "', argument " "6"" of type '" "void *""'"); ++ } ++ result = (int)avc_has_perm(arg1,arg2,arg3,arg4,arg5,arg6); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_audit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ security_id_t arg1 = (security_id_t) 0 ; ++ security_id_t arg2 = (security_id_t) 0 ; ++ security_class_t arg3 ; ++ access_vector_t arg4 ; ++ struct av_decision *arg5 = (struct av_decision *) 0 ; ++ int arg6 ; ++ void *arg7 = (void *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ void *argp2 = 0 ; ++ int res2 = 0 ; ++ unsigned short val3 ; ++ int ecode3 = 0 ; ++ unsigned int val4 ; ++ int ecode4 = 0 ; ++ void *argp5 = 0 ; ++ int res5 = 0 ; ++ int val6 ; ++ int ecode6 = 0 ; ++ int res7 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ PyObject * obj3 = 0 ; ++ PyObject * obj4 = 0 ; ++ PyObject * obj5 = 0 ; ++ PyObject * obj6 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:avc_audit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_audit" "', argument " "1"" of type '" "security_id_t""'"); ++ } ++ arg1 = (security_id_t)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_security_id, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "avc_audit" "', argument " "2"" of type '" "security_id_t""'"); ++ } ++ arg2 = (security_id_t)(argp2); ++ ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); ++ if (!SWIG_IsOK(ecode3)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "avc_audit" "', argument " "3"" of type '" "security_class_t""'"); ++ } ++ arg3 = (security_class_t)(val3); ++ ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4); ++ if (!SWIG_IsOK(ecode4)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "avc_audit" "', argument " "4"" of type '" "access_vector_t""'"); ++ } ++ arg4 = (access_vector_t)(val4); ++ res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_av_decision, 0 | 0 ); ++ if (!SWIG_IsOK(res5)) { ++ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "avc_audit" "', argument " "5"" of type '" "struct av_decision *""'"); ++ } ++ arg5 = (struct av_decision *)(argp5); ++ ecode6 = SWIG_AsVal_int(obj5, &val6); ++ if (!SWIG_IsOK(ecode6)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "avc_audit" "', argument " "6"" of type '" "int""'"); ++ } ++ arg6 = (int)(val6); ++ res7 = SWIG_ConvertPtr(obj6,SWIG_as_voidptrptr(&arg7), 0, 0); ++ if (!SWIG_IsOK(res7)) { ++ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "avc_audit" "', argument " "7"" of type '" "void *""'"); ++ } ++ avc_audit(arg1,arg2,arg3,arg4,arg5,arg6,arg7); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_compute_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ security_id_t arg1 = (security_id_t) 0 ; ++ security_id_t arg2 = (security_id_t) 0 ; ++ security_class_t arg3 ; ++ security_id_t *arg4 = (security_id_t *) 0 ; ++ int result; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ void *argp2 = 0 ; ++ int res2 = 0 ; ++ unsigned short val3 ; ++ int ecode3 = 0 ; ++ void *argp4 = 0 ; ++ int res4 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ PyObject * obj3 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OOOO:avc_compute_create",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_compute_create" "', argument " "1"" of type '" "security_id_t""'"); ++ } ++ arg1 = (security_id_t)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_security_id, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "avc_compute_create" "', argument " "2"" of type '" "security_id_t""'"); ++ } ++ arg2 = (security_id_t)(argp2); ++ ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); ++ if (!SWIG_IsOK(ecode3)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "avc_compute_create" "', argument " "3"" of type '" "security_class_t""'"); ++ } ++ arg3 = (security_class_t)(val3); ++ res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_security_id, 0 | 0 ); ++ if (!SWIG_IsOK(res4)) { ++ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "avc_compute_create" "', argument " "4"" of type '" "security_id_t *""'"); ++ } ++ arg4 = (security_id_t *)(argp4); ++ result = (int)avc_compute_create(arg1,arg2,arg3,arg4); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_compute_member(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ security_id_t arg1 = (security_id_t) 0 ; ++ security_id_t arg2 = (security_id_t) 0 ; ++ security_class_t arg3 ; ++ security_id_t *arg4 = (security_id_t *) 0 ; ++ int result; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ void *argp2 = 0 ; ++ int res2 = 0 ; ++ unsigned short val3 ; ++ int ecode3 = 0 ; ++ void *argp4 = 0 ; ++ int res4 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ PyObject * obj3 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OOOO:avc_compute_member",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_compute_member" "', argument " "1"" of type '" "security_id_t""'"); ++ } ++ arg1 = (security_id_t)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_security_id, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "avc_compute_member" "', argument " "2"" of type '" "security_id_t""'"); ++ } ++ arg2 = (security_id_t)(argp2); ++ ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); ++ if (!SWIG_IsOK(ecode3)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "avc_compute_member" "', argument " "3"" of type '" "security_class_t""'"); ++ } ++ arg3 = (security_class_t)(val3); ++ res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_security_id, 0 | 0 ); ++ if (!SWIG_IsOK(res4)) { ++ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "avc_compute_member" "', argument " "4"" of type '" "security_id_t *""'"); ++ } ++ arg4 = (security_id_t *)(argp4); ++ result = (int)avc_compute_member(arg1,arg2,arg3,arg4); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_cache_stats_entry_lookups_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ; ++ unsigned int arg2 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ unsigned int val2 ; ++ int ecode2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:avc_cache_stats_entry_lookups_set",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_entry_lookups_set" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); ++ } ++ arg1 = (struct avc_cache_stats *)(argp1); ++ ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); ++ if (!SWIG_IsOK(ecode2)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "avc_cache_stats_entry_lookups_set" "', argument " "2"" of type '" "unsigned int""'"); ++ } ++ arg2 = (unsigned int)(val2); ++ if (arg1) (arg1)->entry_lookups = arg2; ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_cache_stats_entry_lookups_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ; ++ unsigned int result; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:avc_cache_stats_entry_lookups_get",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_entry_lookups_get" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); ++ } ++ arg1 = (struct avc_cache_stats *)(argp1); ++ result = (unsigned int) ((arg1)->entry_lookups); ++ resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_cache_stats_entry_hits_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ; ++ unsigned int arg2 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ unsigned int val2 ; ++ int ecode2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:avc_cache_stats_entry_hits_set",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_entry_hits_set" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); ++ } ++ arg1 = (struct avc_cache_stats *)(argp1); ++ ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); ++ if (!SWIG_IsOK(ecode2)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "avc_cache_stats_entry_hits_set" "', argument " "2"" of type '" "unsigned int""'"); ++ } ++ arg2 = (unsigned int)(val2); ++ if (arg1) (arg1)->entry_hits = arg2; ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_cache_stats_entry_hits_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ; ++ unsigned int result; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:avc_cache_stats_entry_hits_get",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_entry_hits_get" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); ++ } ++ arg1 = (struct avc_cache_stats *)(argp1); ++ result = (unsigned int) ((arg1)->entry_hits); ++ resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_cache_stats_entry_misses_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ; ++ unsigned int arg2 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ unsigned int val2 ; ++ int ecode2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:avc_cache_stats_entry_misses_set",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_entry_misses_set" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); ++ } ++ arg1 = (struct avc_cache_stats *)(argp1); ++ ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); ++ if (!SWIG_IsOK(ecode2)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "avc_cache_stats_entry_misses_set" "', argument " "2"" of type '" "unsigned int""'"); ++ } ++ arg2 = (unsigned int)(val2); ++ if (arg1) (arg1)->entry_misses = arg2; ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_cache_stats_entry_misses_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ; ++ unsigned int result; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:avc_cache_stats_entry_misses_get",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_entry_misses_get" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); ++ } ++ arg1 = (struct avc_cache_stats *)(argp1); ++ result = (unsigned int) ((arg1)->entry_misses); ++ resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_cache_stats_entry_discards_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ; ++ unsigned int arg2 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ unsigned int val2 ; ++ int ecode2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:avc_cache_stats_entry_discards_set",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_entry_discards_set" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); ++ } ++ arg1 = (struct avc_cache_stats *)(argp1); ++ ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); ++ if (!SWIG_IsOK(ecode2)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "avc_cache_stats_entry_discards_set" "', argument " "2"" of type '" "unsigned int""'"); ++ } ++ arg2 = (unsigned int)(val2); ++ if (arg1) (arg1)->entry_discards = arg2; ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_cache_stats_entry_discards_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ; ++ unsigned int result; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:avc_cache_stats_entry_discards_get",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_entry_discards_get" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); ++ } ++ arg1 = (struct avc_cache_stats *)(argp1); ++ result = (unsigned int) ((arg1)->entry_discards); ++ resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_cache_stats_cav_lookups_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ; ++ unsigned int arg2 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ unsigned int val2 ; ++ int ecode2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:avc_cache_stats_cav_lookups_set",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_cav_lookups_set" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); ++ } ++ arg1 = (struct avc_cache_stats *)(argp1); ++ ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); ++ if (!SWIG_IsOK(ecode2)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "avc_cache_stats_cav_lookups_set" "', argument " "2"" of type '" "unsigned int""'"); ++ } ++ arg2 = (unsigned int)(val2); ++ if (arg1) (arg1)->cav_lookups = arg2; ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_cache_stats_cav_lookups_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ; ++ unsigned int result; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:avc_cache_stats_cav_lookups_get",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_cav_lookups_get" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); ++ } ++ arg1 = (struct avc_cache_stats *)(argp1); ++ result = (unsigned int) ((arg1)->cav_lookups); ++ resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_cache_stats_cav_hits_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ; ++ unsigned int arg2 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ unsigned int val2 ; ++ int ecode2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:avc_cache_stats_cav_hits_set",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_cav_hits_set" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); ++ } ++ arg1 = (struct avc_cache_stats *)(argp1); ++ ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); ++ if (!SWIG_IsOK(ecode2)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "avc_cache_stats_cav_hits_set" "', argument " "2"" of type '" "unsigned int""'"); ++ } ++ arg2 = (unsigned int)(val2); ++ if (arg1) (arg1)->cav_hits = arg2; ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_cache_stats_cav_hits_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ; ++ unsigned int result; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:avc_cache_stats_cav_hits_get",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_cav_hits_get" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); ++ } ++ arg1 = (struct avc_cache_stats *)(argp1); ++ result = (unsigned int) ((arg1)->cav_hits); ++ resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_cache_stats_cav_probes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ; ++ unsigned int arg2 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ unsigned int val2 ; ++ int ecode2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:avc_cache_stats_cav_probes_set",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_cav_probes_set" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); ++ } ++ arg1 = (struct avc_cache_stats *)(argp1); ++ ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); ++ if (!SWIG_IsOK(ecode2)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "avc_cache_stats_cav_probes_set" "', argument " "2"" of type '" "unsigned int""'"); ++ } ++ arg2 = (unsigned int)(val2); ++ if (arg1) (arg1)->cav_probes = arg2; ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_cache_stats_cav_probes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ; ++ unsigned int result; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:avc_cache_stats_cav_probes_get",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_cav_probes_get" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); ++ } ++ arg1 = (struct avc_cache_stats *)(argp1); ++ result = (unsigned int) ((arg1)->cav_probes); ++ resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_cache_stats_cav_misses_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ; ++ unsigned int arg2 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ unsigned int val2 ; ++ int ecode2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:avc_cache_stats_cav_misses_set",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_cav_misses_set" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); ++ } ++ arg1 = (struct avc_cache_stats *)(argp1); ++ ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); ++ if (!SWIG_IsOK(ecode2)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "avc_cache_stats_cav_misses_set" "', argument " "2"" of type '" "unsigned int""'"); ++ } ++ arg2 = (unsigned int)(val2); ++ if (arg1) (arg1)->cav_misses = arg2; ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_cache_stats_cav_misses_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ; ++ unsigned int result; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:avc_cache_stats_cav_misses_get",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_cav_misses_get" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); ++ } ++ arg1 = (struct avc_cache_stats *)(argp1); ++ result = (unsigned int) ((arg1)->cav_misses); ++ resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_new_avc_cache_stats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_cache_stats *result = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)":new_avc_cache_stats")) SWIG_fail; ++ result = (struct avc_cache_stats *)(struct avc_cache_stats *) calloc(1, sizeof(struct avc_cache_stats)); ++ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_avc_cache_stats, SWIG_POINTER_NEW | 0 ); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_delete_avc_cache_stats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:delete_avc_cache_stats",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, SWIG_POINTER_DISOWN | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_avc_cache_stats" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); ++ } ++ arg1 = (struct avc_cache_stats *)(argp1); ++ free((char *) arg1); ++ ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *avc_cache_stats_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *obj; ++ if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL; ++ SWIG_TypeNewClientData(SWIGTYPE_p_avc_cache_stats, SWIG_NewClientData(obj)); ++ return SWIG_Py_Void(); ++} ++ ++SWIGINTERN PyObject *_wrap_avc_av_stats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ ++ if (!PyArg_ParseTuple(args,(char *)":avc_av_stats")) SWIG_fail; ++ avc_av_stats(); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ ++SWIGINTERN PyObject *_wrap_avc_sid_stats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ ++ if (!PyArg_ParseTuple(args,(char *)":avc_sid_stats")) SWIG_fail; ++ avc_sid_stats(); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; ++} ++ ++ + SWIGINTERN PyObject *_wrap_selinux_default_type_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *result = 0 ; +@@ -8128,6 +10217,88 @@ + { (char *)"selinux_file_context_cmp", _wrap_selinux_file_context_cmp, METH_VARARGS, NULL}, + { (char *)"selinux_file_context_verify", _wrap_selinux_file_context_verify, METH_VARARGS, NULL}, + { (char *)"selinux_lsetfilecon_default", _wrap_selinux_lsetfilecon_default, METH_VARARGS, NULL}, ++ { (char *)"security_id_ctx_set", _wrap_security_id_ctx_set, METH_VARARGS, NULL}, ++ { (char *)"security_id_ctx_get", _wrap_security_id_ctx_get, METH_VARARGS, NULL}, ++ { (char *)"security_id_refcnt_set", _wrap_security_id_refcnt_set, METH_VARARGS, NULL}, ++ { (char *)"security_id_refcnt_get", _wrap_security_id_refcnt_get, METH_VARARGS, NULL}, ++ { (char *)"new_security_id", _wrap_new_security_id, METH_VARARGS, NULL}, ++ { (char *)"delete_security_id", _wrap_delete_security_id, METH_VARARGS, NULL}, ++ { (char *)"security_id_swigregister", security_id_swigregister, METH_VARARGS, NULL}, ++ { (char *)"avc_sid_to_context", _wrap_avc_sid_to_context, METH_VARARGS, NULL}, ++ { (char *)"avc_sid_to_context_raw", _wrap_avc_sid_to_context_raw, METH_VARARGS, NULL}, ++ { (char *)"avc_context_to_sid", _wrap_avc_context_to_sid, METH_VARARGS, NULL}, ++ { (char *)"avc_context_to_sid_raw", _wrap_avc_context_to_sid_raw, METH_VARARGS, NULL}, ++ { (char *)"sidget", _wrap_sidget, METH_VARARGS, NULL}, ++ { (char *)"sidput", _wrap_sidput, METH_VARARGS, NULL}, ++ { (char *)"avc_get_initial_sid", _wrap_avc_get_initial_sid, METH_VARARGS, NULL}, ++ { (char *)"avc_entry_ref_ae_set", _wrap_avc_entry_ref_ae_set, METH_VARARGS, NULL}, ++ { (char *)"avc_entry_ref_ae_get", _wrap_avc_entry_ref_ae_get, METH_VARARGS, NULL}, ++ { (char *)"new_avc_entry_ref", _wrap_new_avc_entry_ref, METH_VARARGS, NULL}, ++ { (char *)"delete_avc_entry_ref", _wrap_delete_avc_entry_ref, METH_VARARGS, NULL}, ++ { (char *)"avc_entry_ref_swigregister", avc_entry_ref_swigregister, METH_VARARGS, NULL}, ++ { (char *)"avc_memory_callback_func_malloc_set", _wrap_avc_memory_callback_func_malloc_set, METH_VARARGS, NULL}, ++ { (char *)"avc_memory_callback_func_malloc_get", _wrap_avc_memory_callback_func_malloc_get, METH_VARARGS, NULL}, ++ { (char *)"avc_memory_callback_func_free_set", _wrap_avc_memory_callback_func_free_set, METH_VARARGS, NULL}, ++ { (char *)"avc_memory_callback_func_free_get", _wrap_avc_memory_callback_func_free_get, METH_VARARGS, NULL}, ++ { (char *)"new_avc_memory_callback", _wrap_new_avc_memory_callback, METH_VARARGS, NULL}, ++ { (char *)"delete_avc_memory_callback", _wrap_delete_avc_memory_callback, METH_VARARGS, NULL}, ++ { (char *)"avc_memory_callback_swigregister", avc_memory_callback_swigregister, METH_VARARGS, NULL}, ++ { (char *)"avc_log_callback_func_log_set", _wrap_avc_log_callback_func_log_set, METH_VARARGS, NULL}, ++ { (char *)"avc_log_callback_func_log_get", _wrap_avc_log_callback_func_log_get, METH_VARARGS, NULL}, ++ { (char *)"avc_log_callback_func_audit_set", _wrap_avc_log_callback_func_audit_set, METH_VARARGS, NULL}, ++ { (char *)"avc_log_callback_func_audit_get", _wrap_avc_log_callback_func_audit_get, METH_VARARGS, NULL}, ++ { (char *)"new_avc_log_callback", _wrap_new_avc_log_callback, METH_VARARGS, NULL}, ++ { (char *)"delete_avc_log_callback", _wrap_delete_avc_log_callback, METH_VARARGS, NULL}, ++ { (char *)"avc_log_callback_swigregister", avc_log_callback_swigregister, METH_VARARGS, NULL}, ++ { (char *)"avc_thread_callback_func_create_thread_set", _wrap_avc_thread_callback_func_create_thread_set, METH_VARARGS, NULL}, ++ { (char *)"avc_thread_callback_func_create_thread_get", _wrap_avc_thread_callback_func_create_thread_get, METH_VARARGS, NULL}, ++ { (char *)"avc_thread_callback_func_stop_thread_set", _wrap_avc_thread_callback_func_stop_thread_set, METH_VARARGS, NULL}, ++ { (char *)"avc_thread_callback_func_stop_thread_get", _wrap_avc_thread_callback_func_stop_thread_get, METH_VARARGS, NULL}, ++ { (char *)"new_avc_thread_callback", _wrap_new_avc_thread_callback, METH_VARARGS, NULL}, ++ { (char *)"delete_avc_thread_callback", _wrap_delete_avc_thread_callback, METH_VARARGS, NULL}, ++ { (char *)"avc_thread_callback_swigregister", avc_thread_callback_swigregister, METH_VARARGS, NULL}, ++ { (char *)"avc_lock_callback_func_alloc_lock_set", _wrap_avc_lock_callback_func_alloc_lock_set, METH_VARARGS, NULL}, ++ { (char *)"avc_lock_callback_func_alloc_lock_get", _wrap_avc_lock_callback_func_alloc_lock_get, METH_VARARGS, NULL}, ++ { (char *)"avc_lock_callback_func_get_lock_set", _wrap_avc_lock_callback_func_get_lock_set, METH_VARARGS, NULL}, ++ { (char *)"avc_lock_callback_func_get_lock_get", _wrap_avc_lock_callback_func_get_lock_get, METH_VARARGS, NULL}, ++ { (char *)"avc_lock_callback_func_release_lock_set", _wrap_avc_lock_callback_func_release_lock_set, METH_VARARGS, NULL}, ++ { (char *)"avc_lock_callback_func_release_lock_get", _wrap_avc_lock_callback_func_release_lock_get, METH_VARARGS, NULL}, ++ { (char *)"avc_lock_callback_func_free_lock_set", _wrap_avc_lock_callback_func_free_lock_set, METH_VARARGS, NULL}, ++ { (char *)"avc_lock_callback_func_free_lock_get", _wrap_avc_lock_callback_func_free_lock_get, METH_VARARGS, NULL}, ++ { (char *)"new_avc_lock_callback", _wrap_new_avc_lock_callback, METH_VARARGS, NULL}, ++ { (char *)"delete_avc_lock_callback", _wrap_delete_avc_lock_callback, METH_VARARGS, NULL}, ++ { (char *)"avc_lock_callback_swigregister", avc_lock_callback_swigregister, METH_VARARGS, NULL}, ++ { (char *)"avc_init", _wrap_avc_init, METH_VARARGS, NULL}, ++ { (char *)"avc_open", _wrap_avc_open, METH_VARARGS, NULL}, ++ { (char *)"avc_cleanup", _wrap_avc_cleanup, METH_VARARGS, NULL}, ++ { (char *)"avc_reset", _wrap_avc_reset, METH_VARARGS, NULL}, ++ { (char *)"avc_destroy", _wrap_avc_destroy, METH_VARARGS, NULL}, ++ { (char *)"avc_has_perm_noaudit", _wrap_avc_has_perm_noaudit, METH_VARARGS, NULL}, ++ { (char *)"avc_has_perm", _wrap_avc_has_perm, METH_VARARGS, NULL}, ++ { (char *)"avc_audit", _wrap_avc_audit, METH_VARARGS, NULL}, ++ { (char *)"avc_compute_create", _wrap_avc_compute_create, METH_VARARGS, NULL}, ++ { (char *)"avc_compute_member", _wrap_avc_compute_member, METH_VARARGS, NULL}, ++ { (char *)"avc_cache_stats_entry_lookups_set", _wrap_avc_cache_stats_entry_lookups_set, METH_VARARGS, NULL}, ++ { (char *)"avc_cache_stats_entry_lookups_get", _wrap_avc_cache_stats_entry_lookups_get, METH_VARARGS, NULL}, ++ { (char *)"avc_cache_stats_entry_hits_set", _wrap_avc_cache_stats_entry_hits_set, METH_VARARGS, NULL}, ++ { (char *)"avc_cache_stats_entry_hits_get", _wrap_avc_cache_stats_entry_hits_get, METH_VARARGS, NULL}, ++ { (char *)"avc_cache_stats_entry_misses_set", _wrap_avc_cache_stats_entry_misses_set, METH_VARARGS, NULL}, ++ { (char *)"avc_cache_stats_entry_misses_get", _wrap_avc_cache_stats_entry_misses_get, METH_VARARGS, NULL}, ++ { (char *)"avc_cache_stats_entry_discards_set", _wrap_avc_cache_stats_entry_discards_set, METH_VARARGS, NULL}, ++ { (char *)"avc_cache_stats_entry_discards_get", _wrap_avc_cache_stats_entry_discards_get, METH_VARARGS, NULL}, ++ { (char *)"avc_cache_stats_cav_lookups_set", _wrap_avc_cache_stats_cav_lookups_set, METH_VARARGS, NULL}, ++ { (char *)"avc_cache_stats_cav_lookups_get", _wrap_avc_cache_stats_cav_lookups_get, METH_VARARGS, NULL}, ++ { (char *)"avc_cache_stats_cav_hits_set", _wrap_avc_cache_stats_cav_hits_set, METH_VARARGS, NULL}, ++ { (char *)"avc_cache_stats_cav_hits_get", _wrap_avc_cache_stats_cav_hits_get, METH_VARARGS, NULL}, ++ { (char *)"avc_cache_stats_cav_probes_set", _wrap_avc_cache_stats_cav_probes_set, METH_VARARGS, NULL}, ++ { (char *)"avc_cache_stats_cav_probes_get", _wrap_avc_cache_stats_cav_probes_get, METH_VARARGS, NULL}, ++ { (char *)"avc_cache_stats_cav_misses_set", _wrap_avc_cache_stats_cav_misses_set, METH_VARARGS, NULL}, ++ { (char *)"avc_cache_stats_cav_misses_get", _wrap_avc_cache_stats_cav_misses_get, METH_VARARGS, NULL}, ++ { (char *)"new_avc_cache_stats", _wrap_new_avc_cache_stats, METH_VARARGS, NULL}, ++ { (char *)"delete_avc_cache_stats", _wrap_delete_avc_cache_stats, METH_VARARGS, NULL}, ++ { (char *)"avc_cache_stats_swigregister", avc_cache_stats_swigregister, METH_VARARGS, NULL}, ++ { (char *)"avc_av_stats", _wrap_avc_av_stats, METH_VARARGS, NULL}, ++ { (char *)"avc_sid_stats", _wrap_avc_sid_stats, METH_VARARGS, NULL}, + { (char *)"selinux_default_type_path", _wrap_selinux_default_type_path, METH_VARARGS, NULL}, + { (char *)"get_default_type", _wrap_get_default_type, METH_VARARGS, NULL}, + { (char *)"get_ordered_context_list", _wrap_get_ordered_context_list, METH_VARARGS, NULL}, +@@ -8146,15 +10317,30 @@ + + static swig_type_info _swigt__p_SELboolean = {"_p_SELboolean", "SELboolean *", 0, 0, (void*)0, 0}; + static swig_type_info _swigt__p_av_decision = {"_p_av_decision", "struct av_decision *|av_decision *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_avc_cache_stats = {"_p_avc_cache_stats", "struct avc_cache_stats *|avc_cache_stats *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_avc_entry = {"_p_avc_entry", "struct avc_entry *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_avc_entry_ref = {"_p_avc_entry_ref", "struct avc_entry_ref *|avc_entry_ref *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_avc_lock_callback = {"_p_avc_lock_callback", "struct avc_lock_callback *|avc_lock_callback *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_avc_log_callback = {"_p_avc_log_callback", "struct avc_log_callback *|avc_log_callback *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_avc_memory_callback = {"_p_avc_memory_callback", "struct avc_memory_callback *|avc_memory_callback *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_avc_thread_callback = {"_p_avc_thread_callback", "struct avc_thread_callback *|avc_thread_callback *", 0, 0, (void*)0, 0}; + static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; + static swig_type_info _swigt__p_f_int_p_q_const__char_v_______int = {"_p_f_int_p_q_const__char_v_______int", "int (*)(int,char const *,...)", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_f_p_f_void__void__p_void = {"_p_f_p_f_void__void__p_void", "void *(*)(void (*)(void))", 0, 0, (void*)0, 0}; + static swig_type_info _swigt__p_f_p_p_char__int = {"_p_f_p_p_char__int", "int (*)(char **)|int (*)(security_context_t *)", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_f_p_q_const__char_v_______void = {"_p_f_p_q_const__char_v_______void", "void (*)(char const *,...)", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_f_p_void__void = {"_p_f_p_void__void", "void (*)(void *)", 0, 0, (void*)0, 0}; + static swig_type_info _swigt__p_f_p_void_unsigned_short_p_char_size_t__int = {"_p_f_p_void_unsigned_short_p_char_size_t__int", "int (*)(void *,unsigned short,char *,size_t)|int (*)(void *,security_class_t,char *,size_t)", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_f_p_void_unsigned_short_p_char_size_t__void = {"_p_f_p_void_unsigned_short_p_char_size_t__void", "void (*)(void *,unsigned short,char *,size_t)|void (*)(void *,security_class_t,char *,size_t)", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_f_size_t__p_void = {"_p_f_size_t__p_void", "void *(*)(size_t)", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_f_void__p_void = {"_p_f_void__p_void", "void *(*)(void)", 0, 0, (void*)0, 0}; + static swig_type_info _swigt__p_ino_t = {"_p_ino_t", "ino_t *", 0, 0, (void*)0, 0}; + static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0}; + static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **|security_context_t *", 0, 0, (void*)0, 0}; + static swig_type_info _swigt__p_p_p_char = {"_p_p_p_char", "char ***|security_context_t **", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_p_security_id = {"_p_p_security_id", "struct security_id **|security_id_t *", 0, 0, (void*)0, 0}; + static swig_type_info _swigt__p_security_class_mapping = {"_p_security_class_mapping", "struct security_class_mapping *|security_class_mapping *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_security_id = {"_p_security_id", "security_id_t|struct security_id *|security_id *", 0, 0, (void*)0, 0}; + static swig_type_info _swigt__p_selinux_callback = {"_p_selinux_callback", "union selinux_callback *|selinux_callback *", 0, 0, (void*)0, 0}; + static swig_type_info _swigt__p_selinux_opt = {"_p_selinux_opt", "struct selinux_opt *|selinux_opt *", 0, 0, (void*)0, 0}; + static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|access_vector_t *|mode_t *|pid_t *", 0, 0, (void*)0, 0}; +@@ -8163,15 +10349,30 @@ + static swig_type_info *swig_type_initial[] = { + &_swigt__p_SELboolean, + &_swigt__p_av_decision, ++ &_swigt__p_avc_cache_stats, ++ &_swigt__p_avc_entry, ++ &_swigt__p_avc_entry_ref, ++ &_swigt__p_avc_lock_callback, ++ &_swigt__p_avc_log_callback, ++ &_swigt__p_avc_memory_callback, ++ &_swigt__p_avc_thread_callback, + &_swigt__p_char, + &_swigt__p_f_int_p_q_const__char_v_______int, ++ &_swigt__p_f_p_f_void__void__p_void, + &_swigt__p_f_p_p_char__int, ++ &_swigt__p_f_p_q_const__char_v_______void, ++ &_swigt__p_f_p_void__void, + &_swigt__p_f_p_void_unsigned_short_p_char_size_t__int, ++ &_swigt__p_f_p_void_unsigned_short_p_char_size_t__void, ++ &_swigt__p_f_size_t__p_void, ++ &_swigt__p_f_void__p_void, + &_swigt__p_ino_t, + &_swigt__p_int, + &_swigt__p_p_char, + &_swigt__p_p_p_char, ++ &_swigt__p_p_security_id, + &_swigt__p_security_class_mapping, ++ &_swigt__p_security_id, + &_swigt__p_selinux_callback, + &_swigt__p_selinux_opt, + &_swigt__p_unsigned_int, +@@ -8180,15 +10381,30 @@ + + static swig_cast_info _swigc__p_SELboolean[] = { {&_swigt__p_SELboolean, 0, 0, 0},{0, 0, 0, 0}}; + static swig_cast_info _swigc__p_av_decision[] = { {&_swigt__p_av_decision, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_avc_cache_stats[] = { {&_swigt__p_avc_cache_stats, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_avc_entry[] = { {&_swigt__p_avc_entry, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_avc_entry_ref[] = { {&_swigt__p_avc_entry_ref, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_avc_lock_callback[] = { {&_swigt__p_avc_lock_callback, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_avc_log_callback[] = { {&_swigt__p_avc_log_callback, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_avc_memory_callback[] = { {&_swigt__p_avc_memory_callback, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_avc_thread_callback[] = { {&_swigt__p_avc_thread_callback, 0, 0, 0},{0, 0, 0, 0}}; + static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; + static swig_cast_info _swigc__p_f_int_p_q_const__char_v_______int[] = { {&_swigt__p_f_int_p_q_const__char_v_______int, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_f_p_f_void__void__p_void[] = { {&_swigt__p_f_p_f_void__void__p_void, 0, 0, 0},{0, 0, 0, 0}}; + static swig_cast_info _swigc__p_f_p_p_char__int[] = { {&_swigt__p_f_p_p_char__int, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_f_p_q_const__char_v_______void[] = { {&_swigt__p_f_p_q_const__char_v_______void, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_f_p_void__void[] = { {&_swigt__p_f_p_void__void, 0, 0, 0},{0, 0, 0, 0}}; + static swig_cast_info _swigc__p_f_p_void_unsigned_short_p_char_size_t__int[] = { {&_swigt__p_f_p_void_unsigned_short_p_char_size_t__int, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_f_p_void_unsigned_short_p_char_size_t__void[] = { {&_swigt__p_f_p_void_unsigned_short_p_char_size_t__void, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_f_size_t__p_void[] = { {&_swigt__p_f_size_t__p_void, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_f_void__p_void[] = { {&_swigt__p_f_void__p_void, 0, 0, 0},{0, 0, 0, 0}}; + static swig_cast_info _swigc__p_ino_t[] = { {&_swigt__p_ino_t, 0, 0, 0},{0, 0, 0, 0}}; + static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; + static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}}; + static swig_cast_info _swigc__p_p_p_char[] = { {&_swigt__p_p_p_char, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_p_security_id[] = { {&_swigt__p_p_security_id, 0, 0, 0},{0, 0, 0, 0}}; + static swig_cast_info _swigc__p_security_class_mapping[] = { {&_swigt__p_security_class_mapping, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_security_id[] = { {&_swigt__p_security_id, 0, 0, 0},{0, 0, 0, 0}}; + static swig_cast_info _swigc__p_selinux_callback[] = { {&_swigt__p_selinux_callback, 0, 0, 0},{0, 0, 0, 0}}; + static swig_cast_info _swigc__p_selinux_opt[] = { {&_swigt__p_selinux_opt, 0, 0, 0},{0, 0, 0, 0}}; + static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}}; +@@ -8197,15 +10413,30 @@ + static swig_cast_info *swig_cast_initial[] = { + _swigc__p_SELboolean, + _swigc__p_av_decision, ++ _swigc__p_avc_cache_stats, ++ _swigc__p_avc_entry, ++ _swigc__p_avc_entry_ref, ++ _swigc__p_avc_lock_callback, ++ _swigc__p_avc_log_callback, ++ _swigc__p_avc_memory_callback, ++ _swigc__p_avc_thread_callback, + _swigc__p_char, + _swigc__p_f_int_p_q_const__char_v_______int, ++ _swigc__p_f_p_f_void__void__p_void, + _swigc__p_f_p_p_char__int, ++ _swigc__p_f_p_q_const__char_v_______void, ++ _swigc__p_f_p_void__void, + _swigc__p_f_p_void_unsigned_short_p_char_size_t__int, ++ _swigc__p_f_p_void_unsigned_short_p_char_size_t__void, ++ _swigc__p_f_size_t__p_void, ++ _swigc__p_f_void__p_void, + _swigc__p_ino_t, + _swigc__p_int, + _swigc__p_p_char, + _swigc__p_p_p_char, ++ _swigc__p_p_security_id, + _swigc__p_security_class_mapping, ++ _swigc__p_security_id, + _swigc__p_selinux_callback, + _swigc__p_selinux_opt, + _swigc__p_unsigned_int, +@@ -8740,6 +10971,17 @@ + SWIG_Python_SetConstant(d, "MATCHPATHCON_BASEONLY",SWIG_From_int((int)(1))); + SWIG_Python_SetConstant(d, "MATCHPATHCON_NOTRANS",SWIG_From_int((int)(2))); + SWIG_Python_SetConstant(d, "MATCHPATHCON_VALIDATE",SWIG_From_int((int)(4))); ++ SWIG_Python_SetConstant(d, "AVC_OPT_UNUSED",SWIG_From_int((int)(0))); ++ SWIG_Python_SetConstant(d, "AVC_OPT_SETENFORCE",SWIG_From_int((int)(1))); ++ SWIG_Python_SetConstant(d, "AVC_CALLBACK_GRANT",SWIG_From_int((int)(1))); ++ SWIG_Python_SetConstant(d, "AVC_CALLBACK_TRY_REVOKE",SWIG_From_int((int)(2))); ++ SWIG_Python_SetConstant(d, "AVC_CALLBACK_REVOKE",SWIG_From_int((int)(4))); ++ SWIG_Python_SetConstant(d, "AVC_CALLBACK_RESET",SWIG_From_int((int)(8))); ++ SWIG_Python_SetConstant(d, "AVC_CALLBACK_AUDITALLOW_ENABLE",SWIG_From_int((int)(16))); ++ SWIG_Python_SetConstant(d, "AVC_CALLBACK_AUDITALLOW_DISABLE",SWIG_From_int((int)(32))); ++ SWIG_Python_SetConstant(d, "AVC_CALLBACK_AUDITDENY_ENABLE",SWIG_From_int((int)(64))); ++ SWIG_Python_SetConstant(d, "AVC_CALLBACK_AUDITDENY_DISABLE",SWIG_From_int((int)(128))); ++ SWIG_Python_SetConstant(d, "AVC_CACHE_STATS",SWIG_From_int((int)(1))); + SWIG_Python_SetConstant(d, "SELINUX_DEFAULTUSER",SWIG_FromCharPtr("user_u")); + } + diff --git a/libselinux.spec b/libselinux.spec index 1df0632..1973be8 100644 --- a/libselinux.spec +++ b/libselinux.spec @@ -4,7 +4,7 @@ Summary: SELinux library and simple utilities Name: libselinux Version: 2.0.61 -Release: 1%{?dist} +Release: 3%{?dist} License: Public Domain Group: System Environment/Libraries Source: http://www.nsa.gov/selinux/archives/%{name}-%{version}.tgz @@ -137,6 +137,12 @@ exit 0 %{python_sitearch}/selinux/* %changelog +* Thu Apr 10 2008 Dan Walsh - 2.0.61-3 +- Add avc.h to swig code + +* Wed Apr 9 2008 Dan Walsh - 2.0.61-2 +- Grab the latest policy for the kernel + * Tue Apr 1 2008 Dan Walsh - 2.0.61-1 - Update to Upstream * Man page typo fix from Jim Meyering.