From dcd9773ab2515b51af06d1654ac513f3a340455f Mon Sep 17 00:00:00 2001 From: Daniel J Walsh Date: Thu, 27 Sep 2007 17:55:13 +0000 Subject: [PATCH] - Fix segfault on missing file_context file --- libselinux-rhat.patch | 9073 ++++++++++++++++++++++++++++++++++++++++- libselinux.spec | 5 +- 2 files changed, 9073 insertions(+), 5 deletions(-) diff --git a/libselinux-rhat.patch b/libselinux-rhat.patch index 2506613..6315f41 100644 --- a/libselinux-rhat.patch +++ b/libselinux-rhat.patch @@ -1,6 +1,6 @@ -diff --exclude-from=exclude -N -u -r nsalibselinux/src/matchpathcon.c libselinux-2.0.34/src/matchpathcon.c +diff --exclude-from=exclude -N -u -r nsalibselinux/src/matchpathcon.c libselinux-2.0.35/src/matchpathcon.c --- nsalibselinux/src/matchpathcon.c 2007-09-18 16:27:25.000000000 -0400 -+++ libselinux-2.0.34/src/matchpathcon.c 2007-09-18 16:32:31.000000000 -0400 ++++ libselinux-2.0.35/src/matchpathcon.c 2007-09-27 13:50:55.000000000 -0400 @@ -2,6 +2,7 @@ #include #include @@ -18,9 +18,9074 @@ diff --exclude-from=exclude -N -u -r nsalibselinux/src/matchpathcon.c libselinux va_end(ap); } -diff --exclude-from=exclude -N -u -r nsalibselinux/utils/matchpathcon.c libselinux-2.0.34/utils/matchpathcon.c +@@ -305,8 +306,10 @@ + + void matchpathcon_fini(void) + { +- selabel_close(hnd); +- hnd = NULL; ++ if (hnd) { ++ selabel_close(hnd); ++ hnd = NULL; ++ } + } + + int matchpathcon(const char *name, mode_t mode, security_context_t * con) +diff --exclude-from=exclude -N -u -r nsalibselinux/src/selinux.py libselinux-2.0.35/src/selinux.py +--- nsalibselinux/src/selinux.py 2007-09-13 08:21:12.000000000 -0400 ++++ libselinux-2.0.35/src/selinux.py 1969-12-31 19:00:00.000000000 -0500 +@@ -1,314 +0,0 @@ +-# This file was automatically generated by SWIG (http://www.swig.org). +-# Version 1.3.31 +-# +-# Don't modify this file, modify the SWIG interface instead. +-# This file is compatible with both classic and new-style classes. +- +-import _selinux +-import new +-new_instancemethod = new.instancemethod +-try: +- _swig_property = property +-except NameError: +- pass # Python < 2.2 doesn't have 'property'. +-def _swig_setattr_nondynamic(self,class_type,name,value,static=1): +- if (name == "thisown"): return self.this.own(value) +- if (name == "this"): +- if type(value).__name__ == 'PySwigObject': +- self.__dict__[name] = value +- return +- method = class_type.__swig_setmethods__.get(name,None) +- if method: return method(self,value) +- if (not static) or hasattr(self,name): +- self.__dict__[name] = value +- else: +- raise AttributeError("You cannot add attributes to %s" % self) +- +-def _swig_setattr(self,class_type,name,value): +- return _swig_setattr_nondynamic(self,class_type,name,value,0) +- +-def _swig_getattr(self,class_type,name): +- if (name == "thisown"): return self.this.own() +- method = class_type.__swig_getmethods__.get(name,None) +- if method: return method(self) +- raise AttributeError,name +- +-def _swig_repr(self): +- try: strthis = "proxy of " + self.this.__repr__() +- except: strthis = "" +- return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) +- +-import types +-try: +- _object = types.ObjectType +- _newclass = 1 +-except AttributeError: +- class _object : pass +- _newclass = 0 +-del types +- +- +-is_selinux_enabled = _selinux.is_selinux_enabled +-is_selinux_mls_enabled = _selinux.is_selinux_mls_enabled +-getcon = _selinux.getcon +-getcon_raw = _selinux.getcon_raw +-setcon = _selinux.setcon +-setcon_raw = _selinux.setcon_raw +-getpidcon = _selinux.getpidcon +-getpidcon_raw = _selinux.getpidcon_raw +-getprevcon = _selinux.getprevcon +-getprevcon_raw = _selinux.getprevcon_raw +-getexeccon = _selinux.getexeccon +-getexeccon_raw = _selinux.getexeccon_raw +-setexeccon = _selinux.setexeccon +-setexeccon_raw = _selinux.setexeccon_raw +-getfscreatecon = _selinux.getfscreatecon +-getfscreatecon_raw = _selinux.getfscreatecon_raw +-setfscreatecon = _selinux.setfscreatecon +-setfscreatecon_raw = _selinux.setfscreatecon_raw +-getkeycreatecon = _selinux.getkeycreatecon +-getkeycreatecon_raw = _selinux.getkeycreatecon_raw +-setkeycreatecon = _selinux.setkeycreatecon +-setkeycreatecon_raw = _selinux.setkeycreatecon_raw +-getsockcreatecon = _selinux.getsockcreatecon +-getsockcreatecon_raw = _selinux.getsockcreatecon_raw +-setsockcreatecon = _selinux.setsockcreatecon +-setsockcreatecon_raw = _selinux.setsockcreatecon_raw +-getfilecon = _selinux.getfilecon +-getfilecon_raw = _selinux.getfilecon_raw +-lgetfilecon = _selinux.lgetfilecon +-lgetfilecon_raw = _selinux.lgetfilecon_raw +-fgetfilecon = _selinux.fgetfilecon +-fgetfilecon_raw = _selinux.fgetfilecon_raw +-setfilecon = _selinux.setfilecon +-setfilecon_raw = _selinux.setfilecon_raw +-lsetfilecon = _selinux.lsetfilecon +-lsetfilecon_raw = _selinux.lsetfilecon_raw +-fsetfilecon = _selinux.fsetfilecon +-fsetfilecon_raw = _selinux.fsetfilecon_raw +-getpeercon = _selinux.getpeercon +-getpeercon_raw = _selinux.getpeercon_raw +-class av_decision(_object): +- __swig_setmethods__ = {} +- __setattr__ = lambda self, name, value: _swig_setattr(self, av_decision, name, value) +- __swig_getmethods__ = {} +- __getattr__ = lambda self, name: _swig_getattr(self, av_decision, name) +- __repr__ = _swig_repr +- __swig_setmethods__["allowed"] = _selinux.av_decision_allowed_set +- __swig_getmethods__["allowed"] = _selinux.av_decision_allowed_get +- if _newclass:allowed = _swig_property(_selinux.av_decision_allowed_get, _selinux.av_decision_allowed_set) +- __swig_setmethods__["decided"] = _selinux.av_decision_decided_set +- __swig_getmethods__["decided"] = _selinux.av_decision_decided_get +- if _newclass:decided = _swig_property(_selinux.av_decision_decided_get, _selinux.av_decision_decided_set) +- __swig_setmethods__["auditallow"] = _selinux.av_decision_auditallow_set +- __swig_getmethods__["auditallow"] = _selinux.av_decision_auditallow_get +- if _newclass:auditallow = _swig_property(_selinux.av_decision_auditallow_get, _selinux.av_decision_auditallow_set) +- __swig_setmethods__["auditdeny"] = _selinux.av_decision_auditdeny_set +- __swig_getmethods__["auditdeny"] = _selinux.av_decision_auditdeny_get +- if _newclass:auditdeny = _swig_property(_selinux.av_decision_auditdeny_get, _selinux.av_decision_auditdeny_set) +- __swig_setmethods__["seqno"] = _selinux.av_decision_seqno_set +- __swig_getmethods__["seqno"] = _selinux.av_decision_seqno_get +- if _newclass:seqno = _swig_property(_selinux.av_decision_seqno_get, _selinux.av_decision_seqno_set) +- def __init__(self, *args): +- this = _selinux.new_av_decision(*args) +- try: self.this.append(this) +- except: self.this = this +- __swig_destroy__ = _selinux.delete_av_decision +- __del__ = lambda self : None; +-av_decision_swigregister = _selinux.av_decision_swigregister +-av_decision_swigregister(av_decision) +- +-class selinux_opt(_object): +- __swig_setmethods__ = {} +- __setattr__ = lambda self, name, value: _swig_setattr(self, selinux_opt, name, value) +- __swig_getmethods__ = {} +- __getattr__ = lambda self, name: _swig_getattr(self, selinux_opt, name) +- __repr__ = _swig_repr +- __swig_setmethods__["type"] = _selinux.selinux_opt_type_set +- __swig_getmethods__["type"] = _selinux.selinux_opt_type_get +- if _newclass:type = _swig_property(_selinux.selinux_opt_type_get, _selinux.selinux_opt_type_set) +- __swig_setmethods__["value"] = _selinux.selinux_opt_value_set +- __swig_getmethods__["value"] = _selinux.selinux_opt_value_get +- if _newclass:value = _swig_property(_selinux.selinux_opt_value_get, _selinux.selinux_opt_value_set) +- def __init__(self, *args): +- this = _selinux.new_selinux_opt(*args) +- try: self.this.append(this) +- except: self.this = this +- __swig_destroy__ = _selinux.delete_selinux_opt +- __del__ = lambda self : None; +-selinux_opt_swigregister = _selinux.selinux_opt_swigregister +-selinux_opt_swigregister(selinux_opt) +- +-class selinux_callback(_object): +- __swig_setmethods__ = {} +- __setattr__ = lambda self, name, value: _swig_setattr(self, selinux_callback, name, value) +- __swig_getmethods__ = {} +- __getattr__ = lambda self, name: _swig_getattr(self, selinux_callback, name) +- __repr__ = _swig_repr +- __swig_setmethods__["func_log"] = _selinux.selinux_callback_func_log_set +- __swig_getmethods__["func_log"] = _selinux.selinux_callback_func_log_get +- if _newclass:func_log = _swig_property(_selinux.selinux_callback_func_log_get, _selinux.selinux_callback_func_log_set) +- __swig_setmethods__["func_audit"] = _selinux.selinux_callback_func_audit_set +- __swig_getmethods__["func_audit"] = _selinux.selinux_callback_func_audit_get +- if _newclass:func_audit = _swig_property(_selinux.selinux_callback_func_audit_get, _selinux.selinux_callback_func_audit_set) +- __swig_setmethods__["func_validate"] = _selinux.selinux_callback_func_validate_set +- __swig_getmethods__["func_validate"] = _selinux.selinux_callback_func_validate_get +- if _newclass:func_validate = _swig_property(_selinux.selinux_callback_func_validate_get, _selinux.selinux_callback_func_validate_set) +- def __init__(self, *args): +- this = _selinux.new_selinux_callback(*args) +- try: self.this.append(this) +- except: self.this = this +- __swig_destroy__ = _selinux.delete_selinux_callback +- __del__ = lambda self : None; +-selinux_callback_swigregister = _selinux.selinux_callback_swigregister +-selinux_callback_swigregister(selinux_callback) +- +-SELINUX_CB_LOG = _selinux.SELINUX_CB_LOG +-SELINUX_CB_AUDIT = _selinux.SELINUX_CB_AUDIT +-SELINUX_CB_VALIDATE = _selinux.SELINUX_CB_VALIDATE +-selinux_set_callback = _selinux.selinux_set_callback +-SELINUX_ERROR = _selinux.SELINUX_ERROR +-SELINUX_WARNING = _selinux.SELINUX_WARNING +-SELINUX_INFO = _selinux.SELINUX_INFO +-SELINUX_AVC = _selinux.SELINUX_AVC +-security_compute_av = _selinux.security_compute_av +-security_compute_av_raw = _selinux.security_compute_av_raw +-security_compute_create = _selinux.security_compute_create +-security_compute_create_raw = _selinux.security_compute_create_raw +-security_compute_relabel = _selinux.security_compute_relabel +-security_compute_relabel_raw = _selinux.security_compute_relabel_raw +-security_compute_member = _selinux.security_compute_member +-security_compute_member_raw = _selinux.security_compute_member_raw +-security_compute_user = _selinux.security_compute_user +-security_compute_user_raw = _selinux.security_compute_user_raw +-security_load_policy = _selinux.security_load_policy +-security_get_initial_context = _selinux.security_get_initial_context +-security_get_initial_context_raw = _selinux.security_get_initial_context_raw +-selinux_mkload_policy = _selinux.selinux_mkload_policy +-selinux_init_load_policy = _selinux.selinux_init_load_policy +-class SELboolean(_object): +- __swig_setmethods__ = {} +- __setattr__ = lambda self, name, value: _swig_setattr(self, SELboolean, name, value) +- __swig_getmethods__ = {} +- __getattr__ = lambda self, name: _swig_getattr(self, SELboolean, name) +- __repr__ = _swig_repr +- __swig_setmethods__["name"] = _selinux.SELboolean_name_set +- __swig_getmethods__["name"] = _selinux.SELboolean_name_get +- if _newclass:name = _swig_property(_selinux.SELboolean_name_get, _selinux.SELboolean_name_set) +- __swig_setmethods__["value"] = _selinux.SELboolean_value_set +- __swig_getmethods__["value"] = _selinux.SELboolean_value_get +- if _newclass:value = _swig_property(_selinux.SELboolean_value_get, _selinux.SELboolean_value_set) +- def __init__(self, *args): +- this = _selinux.new_SELboolean(*args) +- try: self.this.append(this) +- except: self.this = this +- __swig_destroy__ = _selinux.delete_SELboolean +- __del__ = lambda self : None; +-SELboolean_swigregister = _selinux.SELboolean_swigregister +-SELboolean_swigregister(SELboolean) +- +-security_set_boolean_list = _selinux.security_set_boolean_list +-security_load_booleans = _selinux.security_load_booleans +-security_check_context = _selinux.security_check_context +-security_check_context_raw = _selinux.security_check_context_raw +-security_canonicalize_context = _selinux.security_canonicalize_context +-security_canonicalize_context_raw = _selinux.security_canonicalize_context_raw +-security_getenforce = _selinux.security_getenforce +-security_setenforce = _selinux.security_setenforce +-security_disable = _selinux.security_disable +-security_policyvers = _selinux.security_policyvers +-security_get_boolean_names = _selinux.security_get_boolean_names +-security_get_boolean_pending = _selinux.security_get_boolean_pending +-security_get_boolean_active = _selinux.security_get_boolean_active +-security_set_boolean = _selinux.security_set_boolean +-security_commit_booleans = _selinux.security_commit_booleans +-class security_class_mapping(_object): +- __swig_setmethods__ = {} +- __setattr__ = lambda self, name, value: _swig_setattr(self, security_class_mapping, name, value) +- __swig_getmethods__ = {} +- __getattr__ = lambda self, name: _swig_getattr(self, security_class_mapping, name) +- __repr__ = _swig_repr +- __swig_setmethods__["name"] = _selinux.security_class_mapping_name_set +- __swig_getmethods__["name"] = _selinux.security_class_mapping_name_get +- if _newclass:name = _swig_property(_selinux.security_class_mapping_name_get, _selinux.security_class_mapping_name_set) +- __swig_setmethods__["perms"] = _selinux.security_class_mapping_perms_set +- __swig_getmethods__["perms"] = _selinux.security_class_mapping_perms_get +- if _newclass:perms = _swig_property(_selinux.security_class_mapping_perms_get, _selinux.security_class_mapping_perms_set) +- def __init__(self, *args): +- this = _selinux.new_security_class_mapping(*args) +- try: self.this.append(this) +- except: self.this = this +- __swig_destroy__ = _selinux.delete_security_class_mapping +- __del__ = lambda self : None; +-security_class_mapping_swigregister = _selinux.security_class_mapping_swigregister +-security_class_mapping_swigregister(security_class_mapping) +- +-selinux_set_mapping = _selinux.selinux_set_mapping +-string_to_security_class = _selinux.string_to_security_class +-security_class_to_string = _selinux.security_class_to_string +-security_av_perm_to_string = _selinux.security_av_perm_to_string +-string_to_av_perm = _selinux.string_to_av_perm +-security_av_string = _selinux.security_av_string +-print_access_vector = _selinux.print_access_vector +-MATCHPATHCON_BASEONLY = _selinux.MATCHPATHCON_BASEONLY +-MATCHPATHCON_NOTRANS = _selinux.MATCHPATHCON_NOTRANS +-MATCHPATHCON_VALIDATE = _selinux.MATCHPATHCON_VALIDATE +-set_matchpathcon_flags = _selinux.set_matchpathcon_flags +-matchpathcon_init = _selinux.matchpathcon_init +-matchpathcon_init_prefix = _selinux.matchpathcon_init_prefix +-matchpathcon_fini = _selinux.matchpathcon_fini +-matchpathcon = _selinux.matchpathcon +-matchpathcon_index = _selinux.matchpathcon_index +-matchpathcon_filespec_add = _selinux.matchpathcon_filespec_add +-matchpathcon_filespec_destroy = _selinux.matchpathcon_filespec_destroy +-matchpathcon_filespec_eval = _selinux.matchpathcon_filespec_eval +-matchpathcon_checkmatches = _selinux.matchpathcon_checkmatches +-matchmediacon = _selinux.matchmediacon +-selinux_getenforcemode = _selinux.selinux_getenforcemode +-selinux_getpolicytype = _selinux.selinux_getpolicytype +-selinux_policy_root = _selinux.selinux_policy_root +-selinux_binary_policy_path = _selinux.selinux_binary_policy_path +-selinux_failsafe_context_path = _selinux.selinux_failsafe_context_path +-selinux_removable_context_path = _selinux.selinux_removable_context_path +-selinux_default_context_path = _selinux.selinux_default_context_path +-selinux_user_contexts_path = _selinux.selinux_user_contexts_path +-selinux_file_context_path = _selinux.selinux_file_context_path +-selinux_file_context_homedir_path = _selinux.selinux_file_context_homedir_path +-selinux_file_context_local_path = _selinux.selinux_file_context_local_path +-selinux_homedir_context_path = _selinux.selinux_homedir_context_path +-selinux_media_context_path = _selinux.selinux_media_context_path +-selinux_x_context_path = _selinux.selinux_x_context_path +-selinux_contexts_path = _selinux.selinux_contexts_path +-selinux_securetty_types_path = _selinux.selinux_securetty_types_path +-selinux_booleans_path = _selinux.selinux_booleans_path +-selinux_customizable_types_path = _selinux.selinux_customizable_types_path +-selinux_users_path = _selinux.selinux_users_path +-selinux_usersconf_path = _selinux.selinux_usersconf_path +-selinux_translations_path = _selinux.selinux_translations_path +-selinux_netfilter_context_path = _selinux.selinux_netfilter_context_path +-selinux_path = _selinux.selinux_path +-selinux_check_passwd_access = _selinux.selinux_check_passwd_access +-checkPasswdAccess = _selinux.checkPasswdAccess +-selinux_check_securetty_context = _selinux.selinux_check_securetty_context +-set_selinuxmnt = _selinux.set_selinuxmnt +-rpm_execcon = _selinux.rpm_execcon +-is_context_customizable = _selinux.is_context_customizable +-selinux_trans_to_raw_context = _selinux.selinux_trans_to_raw_context +-selinux_raw_to_trans_context = _selinux.selinux_raw_to_trans_context +-getseuserbyname = _selinux.getseuserbyname +-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 +-selinux_default_type_path = _selinux.selinux_default_type_path +-get_default_type = _selinux.get_default_type +-SELINUX_DEFAULTUSER = _selinux.SELINUX_DEFAULTUSER +-get_ordered_context_list = _selinux.get_ordered_context_list +-get_ordered_context_list_with_level = _selinux.get_ordered_context_list_with_level +-get_default_context = _selinux.get_default_context +-get_default_context_with_level = _selinux.get_default_context_with_level +-get_default_context_with_role = _selinux.get_default_context_with_role +-get_default_context_with_rolelevel = _selinux.get_default_context_with_rolelevel +-query_user_context = _selinux.query_user_context +-manual_user_enter_context = _selinux.manual_user_enter_context +- +- +diff --exclude-from=exclude -N -u -r nsalibselinux/src/selinuxswig_wrap.c libselinux-2.0.35/src/selinuxswig_wrap.c +--- nsalibselinux/src/selinuxswig_wrap.c 2007-09-13 08:21:12.000000000 -0400 ++++ libselinux-2.0.35/src/selinuxswig_wrap.c 1969-12-31 19:00:00.000000000 -0500 +@@ -1,8730 +0,0 @@ +-/* ---------------------------------------------------------------------------- +- * This file was automatically generated by SWIG (http://www.swig.org). +- * Version 1.3.31 +- * +- * This file is not intended to be easily readable and contains a number of +- * coding conventions designed to improve portability and efficiency. Do not make +- * changes to this file unless you know what you are doing--modify the SWIG +- * interface file instead. +- * ----------------------------------------------------------------------------- */ +- +-#define SWIGPYTHON +-#define SWIG_PYTHON_DIRECTOR_NO_VTABLE +-/* ----------------------------------------------------------------------------- +- * This section contains generic SWIG labels for method/variable +- * declarations/attributes, and other compiler dependent labels. +- * ----------------------------------------------------------------------------- */ +- +-/* template workaround for compilers that cannot correctly implement the C++ standard */ +-#ifndef SWIGTEMPLATEDISAMBIGUATOR +-# if defined(__SUNPRO_CC) +-# if (__SUNPRO_CC <= 0x560) +-# define SWIGTEMPLATEDISAMBIGUATOR template +-# else +-# define SWIGTEMPLATEDISAMBIGUATOR +-# endif +-# else +-# define SWIGTEMPLATEDISAMBIGUATOR +-# endif +-#endif +- +-/* inline attribute */ +-#ifndef SWIGINLINE +-# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +-# define SWIGINLINE inline +-# else +-# define SWIGINLINE +-# endif +-#endif +- +-/* attribute recognised by some compilers to avoid 'unused' warnings */ +-#ifndef SWIGUNUSED +-# if defined(__GNUC__) +-# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +-# define SWIGUNUSED __attribute__ ((__unused__)) +-# else +-# define SWIGUNUSED +-# endif +-# elif defined(__ICC) +-# define SWIGUNUSED __attribute__ ((__unused__)) +-# else +-# define SWIGUNUSED +-# endif +-#endif +- +-#ifndef SWIGUNUSEDPARM +-# ifdef __cplusplus +-# define SWIGUNUSEDPARM(p) +-# else +-# define SWIGUNUSEDPARM(p) p SWIGUNUSED +-# endif +-#endif +- +-/* internal SWIG method */ +-#ifndef SWIGINTERN +-# define SWIGINTERN static SWIGUNUSED +-#endif +- +-/* internal inline SWIG method */ +-#ifndef SWIGINTERNINLINE +-# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +-#endif +- +-/* exporting methods */ +-#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +-# ifndef GCC_HASCLASSVISIBILITY +-# define GCC_HASCLASSVISIBILITY +-# endif +-#endif +- +-#ifndef SWIGEXPORT +-# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +-# if defined(STATIC_LINKED) +-# define SWIGEXPORT +-# else +-# define SWIGEXPORT __declspec(dllexport) +-# endif +-# else +-# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) +-# define SWIGEXPORT __attribute__ ((visibility("default"))) +-# else +-# define SWIGEXPORT +-# endif +-# endif +-#endif +- +-/* calling conventions for Windows */ +-#ifndef SWIGSTDCALL +-# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +-# define SWIGSTDCALL __stdcall +-# else +-# define SWIGSTDCALL +-# endif +-#endif +- +-/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ +-#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) +-# define _CRT_SECURE_NO_DEPRECATE +-#endif +- +- +-/* Python.h has to appear first */ +-#include +- +-/* ----------------------------------------------------------------------------- +- * swigrun.swg +- * +- * This file contains generic CAPI SWIG runtime support for pointer +- * type checking. +- * ----------------------------------------------------------------------------- */ +- +-/* This should only be incremented when either the layout of swig_type_info changes, +- or for whatever reason, the runtime changes incompatibly */ +-#define SWIG_RUNTIME_VERSION "3" +- +-/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ +-#ifdef SWIG_TYPE_TABLE +-# define SWIG_QUOTE_STRING(x) #x +-# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) +-# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) +-#else +-# define SWIG_TYPE_TABLE_NAME +-#endif +- +-/* +- You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for +- creating a static or dynamic library from the swig runtime code. +- In 99.9% of the cases, swig just needs to declare them as 'static'. +- +- But only do this if is strictly necessary, ie, if you have problems +- with your compiler or so. +-*/ +- +-#ifndef SWIGRUNTIME +-# define SWIGRUNTIME SWIGINTERN +-#endif +- +-#ifndef SWIGRUNTIMEINLINE +-# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE +-#endif +- +-/* Generic buffer size */ +-#ifndef SWIG_BUFFER_SIZE +-# define SWIG_BUFFER_SIZE 1024 +-#endif +- +-/* Flags for pointer conversions */ +-#define SWIG_POINTER_DISOWN 0x1 +- +-/* Flags for new pointer objects */ +-#define SWIG_POINTER_OWN 0x1 +- +- +-/* +- Flags/methods for returning states. +- +- The swig conversion methods, as ConvertPtr, return and integer +- that tells if the conversion was successful or not. And if not, +- an error code can be returned (see swigerrors.swg for the codes). +- +- Use the following macros/flags to set or process the returning +- states. +- +- In old swig versions, you usually write code as: +- +- if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { +- // success code +- } else { +- //fail code +- } +- +- Now you can be more explicit as: +- +- int res = SWIG_ConvertPtr(obj,vptr,ty.flags); +- if (SWIG_IsOK(res)) { +- // success code +- } else { +- // fail code +- } +- +- that seems to be the same, but now you can also do +- +- Type *ptr; +- int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); +- if (SWIG_IsOK(res)) { +- // success code +- if (SWIG_IsNewObj(res) { +- ... +- delete *ptr; +- } else { +- ... +- } +- } else { +- // fail code +- } +- +- I.e., now SWIG_ConvertPtr can return new objects and you can +- identify the case and take care of the deallocation. Of course that +- requires also to SWIG_ConvertPtr to return new result values, as +- +- int SWIG_ConvertPtr(obj, ptr,...) { +- if () { +- if () { +- *ptr = ; +- return SWIG_NEWOBJ; +- } else { +- *ptr = ; +- return SWIG_OLDOBJ; +- } +- } else { +- return SWIG_BADOBJ; +- } +- } +- +- Of course, returning the plain '0(success)/-1(fail)' still works, but you can be +- more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the +- swig errors code. +- +- Finally, if the SWIG_CASTRANK_MODE is enabled, the result code +- allows to return the 'cast rank', for example, if you have this +- +- int food(double) +- int fooi(int); +- +- and you call +- +- food(1) // cast rank '1' (1 -> 1.0) +- fooi(1) // cast rank '0' +- +- just use the SWIG_AddCast()/SWIG_CheckState() +- +- +- */ +-#define SWIG_OK (0) +-#define SWIG_ERROR (-1) +-#define SWIG_IsOK(r) (r >= 0) +-#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) +- +-/* The CastRankLimit says how many bits are used for the cast rank */ +-#define SWIG_CASTRANKLIMIT (1 << 8) +-/* The NewMask denotes the object was created (using new/malloc) */ +-#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) +-/* The TmpMask is for in/out typemaps that use temporal objects */ +-#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) +-/* Simple returning values */ +-#define SWIG_BADOBJ (SWIG_ERROR) +-#define SWIG_OLDOBJ (SWIG_OK) +-#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) +-#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) +-/* Check, add and del mask methods */ +-#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) +-#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) +-#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) +-#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) +-#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) +-#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) +- +- +-/* Cast-Rank Mode */ +-#if defined(SWIG_CASTRANK_MODE) +-# ifndef SWIG_TypeRank +-# define SWIG_TypeRank unsigned long +-# endif +-# ifndef SWIG_MAXCASTRANK /* Default cast allowed */ +-# define SWIG_MAXCASTRANK (2) +-# endif +-# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) +-# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) +-SWIGINTERNINLINE int SWIG_AddCast(int r) { +- return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; +-} +-SWIGINTERNINLINE int SWIG_CheckState(int r) { +- return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; +-} +-#else /* no cast-rank mode */ +-# define SWIG_AddCast +-# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) +-#endif +- +- +- +- +-#include +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-typedef void *(*swig_converter_func)(void *); +-typedef struct swig_type_info *(*swig_dycast_func)(void **); +- +-/* Structure to store inforomation on one type */ +-typedef struct swig_type_info { +- const char *name; /* mangled name of this type */ +- const char *str; /* human readable name of this type */ +- swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ +- struct swig_cast_info *cast; /* linked list of types that can cast into this type */ +- void *clientdata; /* language specific type data */ +- int owndata; /* flag if the structure owns the clientdata */ +-} swig_type_info; +- +-/* Structure to store a type and conversion function used for casting */ +-typedef struct swig_cast_info { +- swig_type_info *type; /* pointer to type that is equivalent to this type */ +- swig_converter_func converter; /* function to cast the void pointers */ +- struct swig_cast_info *next; /* pointer to next cast in linked list */ +- struct swig_cast_info *prev; /* pointer to the previous cast */ +-} swig_cast_info; +- +-/* Structure used to store module information +- * Each module generates one structure like this, and the runtime collects +- * all of these structures and stores them in a circularly linked list.*/ +-typedef struct swig_module_info { +- swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ +- size_t size; /* Number of types in this module */ +- struct swig_module_info *next; /* Pointer to next element in circularly linked list */ +- swig_type_info **type_initial; /* Array of initially generated type structures */ +- swig_cast_info **cast_initial; /* Array of initially generated casting structures */ +- void *clientdata; /* Language specific module data */ +-} swig_module_info; +- +-/* +- Compare two type names skipping the space characters, therefore +- "char*" == "char *" and "Class" == "Class", etc. +- +- Return 0 when the two name types are equivalent, as in +- strncmp, but skipping ' '. +-*/ +-SWIGRUNTIME int +-SWIG_TypeNameComp(const char *f1, const char *l1, +- const char *f2, const char *l2) { +- for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { +- while ((*f1 == ' ') && (f1 != l1)) ++f1; +- while ((*f2 == ' ') && (f2 != l2)) ++f2; +- if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; +- } +- return (l1 - f1) - (l2 - f2); +-} +- +-/* +- Check type equivalence in a name list like ||... +- Return 0 if not equal, 1 if equal +-*/ +-SWIGRUNTIME int +-SWIG_TypeEquiv(const char *nb, const char *tb) { +- int equiv = 0; +- const char* te = tb + strlen(tb); +- const char* ne = nb; +- while (!equiv && *ne) { +- for (nb = ne; *ne; ++ne) { +- if (*ne == '|') break; +- } +- equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; +- if (*ne) ++ne; +- } +- return equiv; +-} +- +-/* +- Check type equivalence in a name list like ||... +- Return 0 if equal, -1 if nb < tb, 1 if nb > tb +-*/ +-SWIGRUNTIME int +-SWIG_TypeCompare(const char *nb, const char *tb) { +- int equiv = 0; +- const char* te = tb + strlen(tb); +- const char* ne = nb; +- while (!equiv && *ne) { +- for (nb = ne; *ne; ++ne) { +- if (*ne == '|') break; +- } +- equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; +- if (*ne) ++ne; +- } +- return equiv; +-} +- +- +-/* think of this as a c++ template<> or a scheme macro */ +-#define SWIG_TypeCheck_Template(comparison, ty) \ +- if (ty) { \ +- swig_cast_info *iter = ty->cast; \ +- while (iter) { \ +- if (comparison) { \ +- if (iter == ty->cast) return iter; \ +- /* Move iter to the top of the linked list */ \ +- iter->prev->next = iter->next; \ +- if (iter->next) \ +- iter->next->prev = iter->prev; \ +- iter->next = ty->cast; \ +- iter->prev = 0; \ +- if (ty->cast) ty->cast->prev = iter; \ +- ty->cast = iter; \ +- return iter; \ +- } \ +- iter = iter->next; \ +- } \ +- } \ +- return 0 +- +-/* +- Check the typename +-*/ +-SWIGRUNTIME swig_cast_info * +-SWIG_TypeCheck(const char *c, swig_type_info *ty) { +- SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty); +-} +- +-/* Same as previous function, except strcmp is replaced with a pointer comparison */ +-SWIGRUNTIME swig_cast_info * +-SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) { +- SWIG_TypeCheck_Template(iter->type == from, into); +-} +- +-/* +- Cast a pointer up an inheritance hierarchy +-*/ +-SWIGRUNTIMEINLINE void * +-SWIG_TypeCast(swig_cast_info *ty, void *ptr) { +- return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr); +-} +- +-/* +- Dynamic pointer casting. Down an inheritance hierarchy +-*/ +-SWIGRUNTIME swig_type_info * +-SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { +- swig_type_info *lastty = ty; +- if (!ty || !ty->dcast) return ty; +- while (ty && (ty->dcast)) { +- ty = (*ty->dcast)(ptr); +- if (ty) lastty = ty; +- } +- return lastty; +-} +- +-/* +- Return the name associated with this type +-*/ +-SWIGRUNTIMEINLINE const char * +-SWIG_TypeName(const swig_type_info *ty) { +- return ty->name; +-} +- +-/* +- Return the pretty name associated with this type, +- that is an unmangled type name in a form presentable to the user. +-*/ +-SWIGRUNTIME const char * +-SWIG_TypePrettyName(const swig_type_info *type) { +- /* The "str" field contains the equivalent pretty names of the +- type, separated by vertical-bar characters. We choose +- to print the last name, as it is often (?) the most +- specific. */ +- if (!type) return NULL; +- if (type->str != NULL) { +- const char *last_name = type->str; +- const char *s; +- for (s = type->str; *s; s++) +- if (*s == '|') last_name = s+1; +- return last_name; +- } +- else +- return type->name; +-} +- +-/* +- Set the clientdata field for a type +-*/ +-SWIGRUNTIME void +-SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { +- swig_cast_info *cast = ti->cast; +- /* if (ti->clientdata == clientdata) return; */ +- ti->clientdata = clientdata; +- +- while (cast) { +- if (!cast->converter) { +- swig_type_info *tc = cast->type; +- if (!tc->clientdata) { +- SWIG_TypeClientData(tc, clientdata); +- } +- } +- cast = cast->next; +- } +-} +-SWIGRUNTIME void +-SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { +- SWIG_TypeClientData(ti, clientdata); +- ti->owndata = 1; +-} +- +-/* +- Search for a swig_type_info structure only by mangled name +- Search is a O(log #types) +- +- We start searching at module start, and finish searching when start == end. +- Note: if start == end at the beginning of the function, we go all the way around +- the circular list. +-*/ +-SWIGRUNTIME swig_type_info * +-SWIG_MangledTypeQueryModule(swig_module_info *start, +- swig_module_info *end, +- const char *name) { +- swig_module_info *iter = start; +- do { +- if (iter->size) { +- register size_t l = 0; +- register size_t r = iter->size - 1; +- do { +- /* since l+r >= 0, we can (>> 1) instead (/ 2) */ +- register size_t i = (l + r) >> 1; +- const char *iname = iter->types[i]->name; +- if (iname) { +- register int compare = strcmp(name, iname); +- if (compare == 0) { +- return iter->types[i]; +- } else if (compare < 0) { +- if (i) { +- r = i - 1; +- } else { +- break; +- } +- } else if (compare > 0) { +- l = i + 1; +- } +- } else { +- break; /* should never happen */ +- } +- } while (l <= r); +- } +- iter = iter->next; +- } while (iter != end); +- return 0; +-} +- +-/* +- Search for a swig_type_info structure for either a mangled name or a human readable name. +- It first searches the mangled names of the types, which is a O(log #types) +- If a type is not found it then searches the human readable names, which is O(#types). +- +- We start searching at module start, and finish searching when start == end. +- Note: if start == end at the beginning of the function, we go all the way around +- the circular list. +-*/ +-SWIGRUNTIME swig_type_info * +-SWIG_TypeQueryModule(swig_module_info *start, +- swig_module_info *end, +- const char *name) { +- /* STEP 1: Search the name field using binary search */ +- swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); +- if (ret) { +- return ret; +- } else { +- /* STEP 2: If the type hasn't been found, do a complete search +- of the str field (the human readable name) */ +- swig_module_info *iter = start; +- do { +- register size_t i = 0; +- for (; i < iter->size; ++i) { +- if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) +- return iter->types[i]; +- } +- iter = iter->next; +- } while (iter != end); +- } +- +- /* neither found a match */ +- return 0; +-} +- +-/* +- Pack binary data into a string +-*/ +-SWIGRUNTIME char * +-SWIG_PackData(char *c, void *ptr, size_t sz) { +- static const char hex[17] = "0123456789abcdef"; +- register const unsigned char *u = (unsigned char *) ptr; +- register const unsigned char *eu = u + sz; +- for (; u != eu; ++u) { +- register unsigned char uu = *u; +- *(c++) = hex[(uu & 0xf0) >> 4]; +- *(c++) = hex[uu & 0xf]; +- } +- return c; +-} +- +-/* +- Unpack binary data from a string +-*/ +-SWIGRUNTIME const char * +-SWIG_UnpackData(const char *c, void *ptr, size_t sz) { +- register unsigned char *u = (unsigned char *) ptr; +- register const unsigned char *eu = u + sz; +- for (; u != eu; ++u) { +- register char d = *(c++); +- register unsigned char uu; +- if ((d >= '0') && (d <= '9')) +- uu = ((d - '0') << 4); +- else if ((d >= 'a') && (d <= 'f')) +- uu = ((d - ('a'-10)) << 4); +- else +- return (char *) 0; +- d = *(c++); +- if ((d >= '0') && (d <= '9')) +- uu |= (d - '0'); +- else if ((d >= 'a') && (d <= 'f')) +- uu |= (d - ('a'-10)); +- else +- return (char *) 0; +- *u = uu; +- } +- return c; +-} +- +-/* +- Pack 'void *' into a string buffer. +-*/ +-SWIGRUNTIME char * +-SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { +- char *r = buff; +- if ((2*sizeof(void *) + 2) > bsz) return 0; +- *(r++) = '_'; +- r = SWIG_PackData(r,&ptr,sizeof(void *)); +- if (strlen(name) + 1 > (bsz - (r - buff))) return 0; +- strcpy(r,name); +- return buff; +-} +- +-SWIGRUNTIME const char * +-SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { +- if (*c != '_') { +- if (strcmp(c,"NULL") == 0) { +- *ptr = (void *) 0; +- return name; +- } else { +- return 0; +- } +- } +- return SWIG_UnpackData(++c,ptr,sizeof(void *)); +-} +- +-SWIGRUNTIME char * +-SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { +- char *r = buff; +- size_t lname = (name ? strlen(name) : 0); +- if ((2*sz + 2 + lname) > bsz) return 0; +- *(r++) = '_'; +- r = SWIG_PackData(r,ptr,sz); +- if (lname) { +- strncpy(r,name,lname+1); +- } else { +- *r = 0; +- } +- return buff; +-} +- +-SWIGRUNTIME const char * +-SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { +- if (*c != '_') { +- if (strcmp(c,"NULL") == 0) { +- memset(ptr,0,sz); +- return name; +- } else { +- return 0; +- } +- } +- return SWIG_UnpackData(++c,ptr,sz); +-} +- +-#ifdef __cplusplus +-} +-#endif +- +-/* Errors in SWIG */ +-#define SWIG_UnknownError -1 +-#define SWIG_IOError -2 +-#define SWIG_RuntimeError -3 +-#define SWIG_IndexError -4 +-#define SWIG_TypeError -5 +-#define SWIG_DivisionByZero -6 +-#define SWIG_OverflowError -7 +-#define SWIG_SyntaxError -8 +-#define SWIG_ValueError -9 +-#define SWIG_SystemError -10 +-#define SWIG_AttributeError -11 +-#define SWIG_MemoryError -12 +-#define SWIG_NullReferenceError -13 +- +- +- +- +-/* Add PyOS_snprintf for old Pythons */ +-#if PY_VERSION_HEX < 0x02020000 +-# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM) +-# define PyOS_snprintf _snprintf +-# else +-# define PyOS_snprintf snprintf +-# endif +-#endif +- +-/* A crude PyString_FromFormat implementation for old Pythons */ +-#if PY_VERSION_HEX < 0x02020000 +- +-#ifndef SWIG_PYBUFFER_SIZE +-# define SWIG_PYBUFFER_SIZE 1024 +-#endif +- +-static PyObject * +-PyString_FromFormat(const char *fmt, ...) { +- va_list ap; +- char buf[SWIG_PYBUFFER_SIZE * 2]; +- int res; +- va_start(ap, fmt); +- res = vsnprintf(buf, sizeof(buf), fmt, ap); +- va_end(ap); +- return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf); +-} +-#endif +- +-/* Add PyObject_Del for old Pythons */ +-#if PY_VERSION_HEX < 0x01060000 +-# define PyObject_Del(op) PyMem_DEL((op)) +-#endif +-#ifndef PyObject_DEL +-# define PyObject_DEL PyObject_Del +-#endif +- +-/* A crude PyExc_StopIteration exception for old Pythons */ +-#if PY_VERSION_HEX < 0x02020000 +-# ifndef PyExc_StopIteration +-# define PyExc_StopIteration PyExc_RuntimeError +-# endif +-# ifndef PyObject_GenericGetAttr +-# define PyObject_GenericGetAttr 0 +-# endif +-#endif +-/* Py_NotImplemented is defined in 2.1 and up. */ +-#if PY_VERSION_HEX < 0x02010000 +-# ifndef Py_NotImplemented +-# define Py_NotImplemented PyExc_RuntimeError +-# endif +-#endif +- +- +-/* A crude PyString_AsStringAndSize implementation for old Pythons */ +-#if PY_VERSION_HEX < 0x02010000 +-# ifndef PyString_AsStringAndSize +-# define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;} +-# endif +-#endif +- +-/* PySequence_Size for old Pythons */ +-#if PY_VERSION_HEX < 0x02000000 +-# ifndef PySequence_Size +-# define PySequence_Size PySequence_Length +-# endif +-#endif +- +- +-/* PyBool_FromLong for old Pythons */ +-#if PY_VERSION_HEX < 0x02030000 +-static +-PyObject *PyBool_FromLong(long ok) +-{ +- PyObject *result = ok ? Py_True : Py_False; +- Py_INCREF(result); +- return result; +-} +-#endif +- +-/* Py_ssize_t for old Pythons */ +-/* This code is as recommended by: */ +-/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */ +-#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN) +-typedef int Py_ssize_t; +-# define PY_SSIZE_T_MAX INT_MAX +-# define PY_SSIZE_T_MIN INT_MIN +-#endif +- +-/* ----------------------------------------------------------------------------- +- * error manipulation +- * ----------------------------------------------------------------------------- */ +- +-SWIGRUNTIME PyObject* +-SWIG_Python_ErrorType(int code) { +- PyObject* type = 0; +- switch(code) { +- case SWIG_MemoryError: +- type = PyExc_MemoryError; +- break; +- case SWIG_IOError: +- type = PyExc_IOError; +- break; +- case SWIG_RuntimeError: +- type = PyExc_RuntimeError; +- break; +- case SWIG_IndexError: +- type = PyExc_IndexError; +- break; +- case SWIG_TypeError: +- type = PyExc_TypeError; +- break; +- case SWIG_DivisionByZero: +- type = PyExc_ZeroDivisionError; +- break; +- case SWIG_OverflowError: +- type = PyExc_OverflowError; +- break; +- case SWIG_SyntaxError: +- type = PyExc_SyntaxError; +- break; +- case SWIG_ValueError: +- type = PyExc_ValueError; +- break; +- case SWIG_SystemError: +- type = PyExc_SystemError; +- break; +- case SWIG_AttributeError: +- type = PyExc_AttributeError; +- break; +- default: +- type = PyExc_RuntimeError; +- } +- return type; +-} +- +- +-SWIGRUNTIME void +-SWIG_Python_AddErrorMsg(const char* mesg) +-{ +- PyObject *type = 0; +- PyObject *value = 0; +- PyObject *traceback = 0; +- +- if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback); +- if (value) { +- PyObject *old_str = PyObject_Str(value); +- PyErr_Clear(); +- Py_XINCREF(type); +- PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg); +- Py_DECREF(old_str); +- Py_DECREF(value); +- } else { +- PyErr_Format(PyExc_RuntimeError, mesg); +- } +-} +- +- +- +-#if defined(SWIG_PYTHON_NO_THREADS) +-# if defined(SWIG_PYTHON_THREADS) +-# undef SWIG_PYTHON_THREADS +-# endif +-#endif +-#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */ +-# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL) +-# if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */ +-# define SWIG_PYTHON_USE_GIL +-# endif +-# endif +-# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */ +-# ifndef SWIG_PYTHON_INITIALIZE_THREADS +-# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads() +-# endif +-# ifdef __cplusplus /* C++ code */ +- class SWIG_Python_Thread_Block { +- bool status; +- PyGILState_STATE state; +- public: +- void end() { if (status) { PyGILState_Release(state); status = false;} } +- SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {} +- ~SWIG_Python_Thread_Block() { end(); } +- }; +- class SWIG_Python_Thread_Allow { +- bool status; +- PyThreadState *save; +- public: +- void end() { if (status) { PyEval_RestoreThread(save); status = false; }} +- SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {} +- ~SWIG_Python_Thread_Allow() { end(); } +- }; +-# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block +-# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end() +-# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow +-# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end() +-# else /* C code */ +-# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure() +-# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block) +-# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread() +-# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow) +-# endif +-# else /* Old thread way, not implemented, user must provide it */ +-# if !defined(SWIG_PYTHON_INITIALIZE_THREADS) +-# define SWIG_PYTHON_INITIALIZE_THREADS +-# endif +-# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK) +-# define SWIG_PYTHON_THREAD_BEGIN_BLOCK +-# endif +-# if !defined(SWIG_PYTHON_THREAD_END_BLOCK) +-# define SWIG_PYTHON_THREAD_END_BLOCK +-# endif +-# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW) +-# define SWIG_PYTHON_THREAD_BEGIN_ALLOW +-# endif +-# if !defined(SWIG_PYTHON_THREAD_END_ALLOW) +-# define SWIG_PYTHON_THREAD_END_ALLOW +-# endif +-# endif +-#else /* No thread support */ +-# define SWIG_PYTHON_INITIALIZE_THREADS +-# define SWIG_PYTHON_THREAD_BEGIN_BLOCK +-# define SWIG_PYTHON_THREAD_END_BLOCK +-# define SWIG_PYTHON_THREAD_BEGIN_ALLOW +-# define SWIG_PYTHON_THREAD_END_ALLOW +-#endif +- +-/* ----------------------------------------------------------------------------- +- * Python API portion that goes into the runtime +- * ----------------------------------------------------------------------------- */ +- +-#ifdef __cplusplus +-extern "C" { +-#if 0 +-} /* cc-mode */ +-#endif +-#endif +- +-/* ----------------------------------------------------------------------------- +- * Constant declarations +- * ----------------------------------------------------------------------------- */ +- +-/* Constant Types */ +-#define SWIG_PY_POINTER 4 +-#define SWIG_PY_BINARY 5 +- +-/* Constant information structure */ +-typedef struct swig_const_info { +- int type; +- char *name; +- long lvalue; +- double dvalue; +- void *pvalue; +- swig_type_info **ptype; +-} swig_const_info; +- +-#ifdef __cplusplus +-#if 0 +-{ /* cc-mode */ +-#endif +-} +-#endif +- +- +-/* ----------------------------------------------------------------------------- +- * See the LICENSE file for information on copyright, usage and redistribution +- * of SWIG, and the README file for authors - http://www.swig.org/release.html. +- * +- * pyrun.swg +- * +- * This file contains the runtime support for Python modules +- * and includes code for managing global variables and pointer +- * type checking. +- * +- * ----------------------------------------------------------------------------- */ +- +-/* Common SWIG API */ +- +-/* for raw pointers */ +-#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) +-#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags) +-#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own) +-#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags) +-#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty) +-#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src) +-#define swig_owntype int +- +-/* for raw packed data */ +-#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +-#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) +- +-/* for class or struct pointers */ +-#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags) +-#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags) +- +-/* for C or C++ function pointers */ +-#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type) +-#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0) +- +-/* for C++ member pointers, ie, member methods */ +-#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +-#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) +- +- +-/* Runtime API */ +- +-#define SWIG_GetModule(clientdata) SWIG_Python_GetModule() +-#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer) +-#define SWIG_NewClientData(obj) PySwigClientData_New(obj) +- +-#define SWIG_SetErrorObj SWIG_Python_SetErrorObj +-#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg +-#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code) +-#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) +-#define SWIG_fail goto fail +- +- +-/* Runtime API implementation */ +- +-/* Error manipulation */ +- +-SWIGINTERN void +-SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) { +- SWIG_PYTHON_THREAD_BEGIN_BLOCK; +- PyErr_SetObject(errtype, obj); +- Py_DECREF(obj); +- SWIG_PYTHON_THREAD_END_BLOCK; +-} +- +-SWIGINTERN void +-SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) { +- SWIG_PYTHON_THREAD_BEGIN_BLOCK; +- PyErr_SetString(errtype, (char *) msg); +- SWIG_PYTHON_THREAD_END_BLOCK; +-} +- +-#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj) +- +-/* Set a constant value */ +- +-SWIGINTERN void +-SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) { +- PyDict_SetItemString(d, (char*) name, obj); +- Py_DECREF(obj); +-} +- +-/* Append a value to the result obj */ +- +-SWIGINTERN PyObject* +-SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) { +-#if !defined(SWIG_PYTHON_OUTPUT_TUPLE) +- if (!result) { +- result = obj; +- } else if (result == Py_None) { +- Py_DECREF(result); +- result = obj; +- } else { +- if (!PyList_Check(result)) { +- PyObject *o2 = result; +- result = PyList_New(1); +- PyList_SetItem(result, 0, o2); +- } +- PyList_Append(result,obj); +- Py_DECREF(obj); +- } +- return result; +-#else +- PyObject* o2; +- PyObject* o3; +- if (!result) { +- result = obj; +- } else if (result == Py_None) { +- Py_DECREF(result); +- result = obj; +- } else { +- if (!PyTuple_Check(result)) { +- o2 = result; +- result = PyTuple_New(1); +- PyTuple_SET_ITEM(result, 0, o2); +- } +- o3 = PyTuple_New(1); +- PyTuple_SET_ITEM(o3, 0, obj); +- o2 = result; +- result = PySequence_Concat(o2, o3); +- Py_DECREF(o2); +- Py_DECREF(o3); +- } +- return result; +-#endif +-} +- +-/* Unpack the argument tuple */ +- +-SWIGINTERN int +-SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs) +-{ +- if (!args) { +- if (!min && !max) { +- return 1; +- } else { +- PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", +- name, (min == max ? "" : "at least "), min); +- return 0; +- } +- } +- if (!PyTuple_Check(args)) { +- PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple"); +- return 0; +- } else { +- register int l = PyTuple_GET_SIZE(args); +- if (l < min) { +- PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", +- name, (min == max ? "" : "at least "), min, l); +- return 0; +- } else if (l > max) { +- PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", +- name, (min == max ? "" : "at most "), max, l); +- return 0; +- } else { +- register int i; +- for (i = 0; i < l; ++i) { +- objs[i] = PyTuple_GET_ITEM(args, i); +- } +- for (; l < max; ++l) { +- objs[l] = 0; +- } +- return i + 1; +- } +- } +-} +- +-/* A functor is a function object with one single object argument */ +-#if PY_VERSION_HEX >= 0x02020000 +-#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL); +-#else +-#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj); +-#endif +- +-/* +- Helper for static pointer initialization for both C and C++ code, for example +- static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...); +-*/ +-#ifdef __cplusplus +-#define SWIG_STATIC_POINTER(var) var +-#else +-#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var +-#endif +- +-/* ----------------------------------------------------------------------------- +- * Pointer declarations +- * ----------------------------------------------------------------------------- */ +- +-/* Flags for new pointer objects */ +-#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1) +-#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN) +- +-#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1) +- +-#ifdef __cplusplus +-extern "C" { +-#if 0 +-} /* cc-mode */ +-#endif +-#endif +- +-/* How to access Py_None */ +-#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +-# ifndef SWIG_PYTHON_NO_BUILD_NONE +-# ifndef SWIG_PYTHON_BUILD_NONE +-# define SWIG_PYTHON_BUILD_NONE +-# endif +-# endif +-#endif +- +-#ifdef SWIG_PYTHON_BUILD_NONE +-# ifdef Py_None +-# undef Py_None +-# define Py_None SWIG_Py_None() +-# endif +-SWIGRUNTIMEINLINE PyObject * +-_SWIG_Py_None(void) +-{ +- PyObject *none = Py_BuildValue((char*)""); +- Py_DECREF(none); +- return none; +-} +-SWIGRUNTIME PyObject * +-SWIG_Py_None(void) +-{ +- static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None(); +- return none; +-} +-#endif +- +-/* The python void return value */ +- +-SWIGRUNTIMEINLINE PyObject * +-SWIG_Py_Void(void) +-{ +- PyObject *none = Py_None; +- Py_INCREF(none); +- return none; +-} +- +-/* PySwigClientData */ +- +-typedef struct { +- PyObject *klass; +- PyObject *newraw; +- PyObject *newargs; +- PyObject *destroy; +- int delargs; +- int implicitconv; +-} PySwigClientData; +- +-SWIGRUNTIMEINLINE int +-SWIG_Python_CheckImplicit(swig_type_info *ty) +-{ +- PySwigClientData *data = (PySwigClientData *)ty->clientdata; +- return data ? data->implicitconv : 0; +-} +- +-SWIGRUNTIMEINLINE PyObject * +-SWIG_Python_ExceptionType(swig_type_info *desc) { +- PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0; +- PyObject *klass = data ? data->klass : 0; +- return (klass ? klass : PyExc_RuntimeError); +-} +- +- +-SWIGRUNTIME PySwigClientData * +-PySwigClientData_New(PyObject* obj) +-{ +- if (!obj) { +- return 0; +- } else { +- PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData)); +- /* the klass element */ +- data->klass = obj; +- Py_INCREF(data->klass); +- /* the newraw method and newargs arguments used to create a new raw instance */ +- if (PyClass_Check(obj)) { +- data->newraw = 0; +- data->newargs = obj; +- Py_INCREF(obj); +- } else { +-#if (PY_VERSION_HEX < 0x02020000) +- data->newraw = 0; +-#else +- data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__"); +-#endif +- if (data->newraw) { +- Py_INCREF(data->newraw); +- data->newargs = PyTuple_New(1); +- PyTuple_SetItem(data->newargs, 0, obj); +- } else { +- data->newargs = obj; +- } +- Py_INCREF(data->newargs); +- } +- /* the destroy method, aka as the C++ delete method */ +- data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__"); +- if (PyErr_Occurred()) { +- PyErr_Clear(); +- data->destroy = 0; +- } +- if (data->destroy) { +- int flags; +- Py_INCREF(data->destroy); +- flags = PyCFunction_GET_FLAGS(data->destroy); +-#ifdef METH_O +- data->delargs = !(flags & (METH_O)); +-#else +- data->delargs = 0; +-#endif +- } else { +- data->delargs = 0; +- } +- data->implicitconv = 0; +- return data; +- } +-} +- +-SWIGRUNTIME void +-PySwigClientData_Del(PySwigClientData* data) +-{ +- Py_XDECREF(data->newraw); +- Py_XDECREF(data->newargs); +- Py_XDECREF(data->destroy); +-} +- +-/* =============== PySwigObject =====================*/ +- +-typedef struct { +- PyObject_HEAD +- void *ptr; +- swig_type_info *ty; +- int own; +- PyObject *next; +-} PySwigObject; +- +-SWIGRUNTIME PyObject * +-PySwigObject_long(PySwigObject *v) +-{ +- return PyLong_FromVoidPtr(v->ptr); +-} +- +-SWIGRUNTIME PyObject * +-PySwigObject_format(const char* fmt, PySwigObject *v) +-{ +- PyObject *res = NULL; +- PyObject *args = PyTuple_New(1); +- if (args) { +- if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) { +- PyObject *ofmt = PyString_FromString(fmt); +- if (ofmt) { +- res = PyString_Format(ofmt,args); +- Py_DECREF(ofmt); +- } +- Py_DECREF(args); +- } +- } +- return res; +-} +- +-SWIGRUNTIME PyObject * +-PySwigObject_oct(PySwigObject *v) +-{ +- return PySwigObject_format("%o",v); +-} +- +-SWIGRUNTIME PyObject * +-PySwigObject_hex(PySwigObject *v) +-{ +- return PySwigObject_format("%x",v); +-} +- +-SWIGRUNTIME PyObject * +-#ifdef METH_NOARGS +-PySwigObject_repr(PySwigObject *v) +-#else +-PySwigObject_repr(PySwigObject *v, PyObject *args) +-#endif +-{ +- const char *name = SWIG_TypePrettyName(v->ty); +- PyObject *hex = PySwigObject_hex(v); +- PyObject *repr = PyString_FromFormat("", name, PyString_AsString(hex)); +- Py_DECREF(hex); +- if (v->next) { +-#ifdef METH_NOARGS +- PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next); +-#else +- PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args); +-#endif +- PyString_ConcatAndDel(&repr,nrep); +- } +- return repr; +-} +- +-SWIGRUNTIME int +-PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) +-{ +-#ifdef METH_NOARGS +- PyObject *repr = PySwigObject_repr(v); +-#else +- PyObject *repr = PySwigObject_repr(v, NULL); +-#endif +- if (repr) { +- fputs(PyString_AsString(repr), fp); +- Py_DECREF(repr); +- return 0; +- } else { +- return 1; +- } +-} +- +-SWIGRUNTIME PyObject * +-PySwigObject_str(PySwigObject *v) +-{ +- char result[SWIG_BUFFER_SIZE]; +- return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ? +- PyString_FromString(result) : 0; +-} +- +-SWIGRUNTIME int +-PySwigObject_compare(PySwigObject *v, PySwigObject *w) +-{ +- void *i = v->ptr; +- void *j = w->ptr; +- return (i < j) ? -1 : ((i > j) ? 1 : 0); +-} +- +-SWIGRUNTIME PyTypeObject* _PySwigObject_type(void); +- +-SWIGRUNTIME PyTypeObject* +-PySwigObject_type(void) { +- static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type(); +- return type; +-} +- +-SWIGRUNTIMEINLINE int +-PySwigObject_Check(PyObject *op) { +- return ((op)->ob_type == PySwigObject_type()) +- || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0); +-} +- +-SWIGRUNTIME PyObject * +-PySwigObject_New(void *ptr, swig_type_info *ty, int own); +- +-SWIGRUNTIME void +-PySwigObject_dealloc(PyObject *v) +-{ +- PySwigObject *sobj = (PySwigObject *) v; +- PyObject *next = sobj->next; +- if (sobj->own) { +- swig_type_info *ty = sobj->ty; +- PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0; +- PyObject *destroy = data ? data->destroy : 0; +- if (destroy) { +- /* destroy is always a VARARGS method */ +- PyObject *res; +- if (data->delargs) { +- /* we need to create a temporal object to carry the destroy operation */ +- PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0); +- res = SWIG_Python_CallFunctor(destroy, tmp); +- Py_DECREF(tmp); +- } else { +- PyCFunction meth = PyCFunction_GET_FUNCTION(destroy); +- PyObject *mself = PyCFunction_GET_SELF(destroy); +- res = ((*meth)(mself, v)); +- } +- Py_XDECREF(res); +- } else { +- const char *name = SWIG_TypePrettyName(ty); +-#if !defined(SWIG_PYTHON_SILENT_MEMLEAK) +- printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name); +-#endif +- } +- } +- Py_XDECREF(next); +- PyObject_DEL(v); +-} +- +-SWIGRUNTIME PyObject* +-PySwigObject_append(PyObject* v, PyObject* next) +-{ +- PySwigObject *sobj = (PySwigObject *) v; +-#ifndef METH_O +- PyObject *tmp = 0; +- if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL; +- next = tmp; +-#endif +- if (!PySwigObject_Check(next)) { +- return NULL; +- } +- sobj->next = next; +- Py_INCREF(next); +- return SWIG_Py_Void(); +-} +- +-SWIGRUNTIME PyObject* +-#ifdef METH_NOARGS +-PySwigObject_next(PyObject* v) +-#else +-PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +-#endif +-{ +- PySwigObject *sobj = (PySwigObject *) v; +- if (sobj->next) { +- Py_INCREF(sobj->next); +- return sobj->next; +- } else { +- return SWIG_Py_Void(); +- } +-} +- +-SWIGINTERN PyObject* +-#ifdef METH_NOARGS +-PySwigObject_disown(PyObject *v) +-#else +-PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +-#endif +-{ +- PySwigObject *sobj = (PySwigObject *)v; +- sobj->own = 0; +- return SWIG_Py_Void(); +-} +- +-SWIGINTERN PyObject* +-#ifdef METH_NOARGS +-PySwigObject_acquire(PyObject *v) +-#else +-PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +-#endif +-{ +- PySwigObject *sobj = (PySwigObject *)v; +- sobj->own = SWIG_POINTER_OWN; +- return SWIG_Py_Void(); +-} +- +-SWIGINTERN PyObject* +-PySwigObject_own(PyObject *v, PyObject *args) +-{ +- PyObject *val = 0; +-#if (PY_VERSION_HEX < 0x02020000) +- if (!PyArg_ParseTuple(args,(char *)"|O:own",&val)) +-#else +- if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) +-#endif +- { +- return NULL; +- } +- else +- { +- PySwigObject *sobj = (PySwigObject *)v; +- PyObject *obj = PyBool_FromLong(sobj->own); +- if (val) { +-#ifdef METH_NOARGS +- if (PyObject_IsTrue(val)) { +- PySwigObject_acquire(v); +- } else { +- PySwigObject_disown(v); +- } +-#else +- if (PyObject_IsTrue(val)) { +- PySwigObject_acquire(v,args); +- } else { +- PySwigObject_disown(v,args); +- } +-#endif +- } +- return obj; +- } +-} +- +-#ifdef METH_O +-static PyMethodDef +-swigobject_methods[] = { +- {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"}, +- {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"}, +- {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, +- {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"}, +- {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"}, +- {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"}, +- {0, 0, 0, 0} +-}; +-#else +-static PyMethodDef +-swigobject_methods[] = { +- {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"}, +- {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"}, +- {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, +- {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"}, +- {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"}, +- {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"}, +- {0, 0, 0, 0} +-}; +-#endif +- +-#if PY_VERSION_HEX < 0x02020000 +-SWIGINTERN PyObject * +-PySwigObject_getattr(PySwigObject *sobj,char *name) +-{ +- return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name); +-} +-#endif +- +-SWIGRUNTIME PyTypeObject* +-_PySwigObject_type(void) { +- static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; +- +- static PyNumberMethods PySwigObject_as_number = { +- (binaryfunc)0, /*nb_add*/ +- (binaryfunc)0, /*nb_subtract*/ +- (binaryfunc)0, /*nb_multiply*/ +- (binaryfunc)0, /*nb_divide*/ +- (binaryfunc)0, /*nb_remainder*/ +- (binaryfunc)0, /*nb_divmod*/ +- (ternaryfunc)0,/*nb_power*/ +- (unaryfunc)0, /*nb_negative*/ +- (unaryfunc)0, /*nb_positive*/ +- (unaryfunc)0, /*nb_absolute*/ +- (inquiry)0, /*nb_nonzero*/ +- 0, /*nb_invert*/ +- 0, /*nb_lshift*/ +- 0, /*nb_rshift*/ +- 0, /*nb_and*/ +- 0, /*nb_xor*/ +- 0, /*nb_or*/ +- (coercion)0, /*nb_coerce*/ +- (unaryfunc)PySwigObject_long, /*nb_int*/ +- (unaryfunc)PySwigObject_long, /*nb_long*/ +- (unaryfunc)0, /*nb_float*/ +- (unaryfunc)PySwigObject_oct, /*nb_oct*/ +- (unaryfunc)PySwigObject_hex, /*nb_hex*/ +-#if PY_VERSION_HEX >= 0x02020000 +- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ +-#elif PY_VERSION_HEX >= 0x02000000 +- 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */ +-#endif +- }; +- +- static PyTypeObject pyswigobject_type; +- static int type_init = 0; +- if (!type_init) { +- const PyTypeObject tmp +- = { +- PyObject_HEAD_INIT(NULL) +- 0, /* ob_size */ +- (char *)"PySwigObject", /* tp_name */ +- sizeof(PySwigObject), /* tp_basicsize */ +- 0, /* tp_itemsize */ +- (destructor)PySwigObject_dealloc, /* tp_dealloc */ +- (printfunc)PySwigObject_print, /* tp_print */ +-#if PY_VERSION_HEX < 0x02020000 +- (getattrfunc)PySwigObject_getattr, /* tp_getattr */ +-#else +- (getattrfunc)0, /* tp_getattr */ +-#endif +- (setattrfunc)0, /* tp_setattr */ +- (cmpfunc)PySwigObject_compare, /* tp_compare */ +- (reprfunc)PySwigObject_repr, /* tp_repr */ +- &PySwigObject_as_number, /* tp_as_number */ +- 0, /* tp_as_sequence */ +- 0, /* tp_as_mapping */ +- (hashfunc)0, /* tp_hash */ +- (ternaryfunc)0, /* tp_call */ +- (reprfunc)PySwigObject_str, /* tp_str */ +- PyObject_GenericGetAttr, /* tp_getattro */ +- 0, /* tp_setattro */ +- 0, /* tp_as_buffer */ +- Py_TPFLAGS_DEFAULT, /* tp_flags */ +- swigobject_doc, /* tp_doc */ +- 0, /* tp_traverse */ +- 0, /* tp_clear */ +- 0, /* tp_richcompare */ +- 0, /* tp_weaklistoffset */ +-#if PY_VERSION_HEX >= 0x02020000 +- 0, /* tp_iter */ +- 0, /* tp_iternext */ +- swigobject_methods, /* tp_methods */ +- 0, /* tp_members */ +- 0, /* tp_getset */ +- 0, /* tp_base */ +- 0, /* tp_dict */ +- 0, /* tp_descr_get */ +- 0, /* tp_descr_set */ +- 0, /* tp_dictoffset */ +- 0, /* tp_init */ +- 0, /* tp_alloc */ +- 0, /* tp_new */ +- 0, /* tp_free */ +- 0, /* tp_is_gc */ +- 0, /* tp_bases */ +- 0, /* tp_mro */ +- 0, /* tp_cache */ +- 0, /* tp_subclasses */ +- 0, /* tp_weaklist */ +-#endif +-#if PY_VERSION_HEX >= 0x02030000 +- 0, /* tp_del */ +-#endif +-#ifdef COUNT_ALLOCS +- 0,0,0,0 /* tp_alloc -> tp_next */ +-#endif +- }; +- pyswigobject_type = tmp; +- pyswigobject_type.ob_type = &PyType_Type; +- type_init = 1; +- } +- return &pyswigobject_type; +-} +- +-SWIGRUNTIME PyObject * +-PySwigObject_New(void *ptr, swig_type_info *ty, int own) +-{ +- PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type()); +- if (sobj) { +- sobj->ptr = ptr; +- sobj->ty = ty; +- sobj->own = own; +- sobj->next = 0; +- } +- return (PyObject *)sobj; +-} +- +-/* ----------------------------------------------------------------------------- +- * Implements a simple Swig Packed type, and use it instead of string +- * ----------------------------------------------------------------------------- */ +- +-typedef struct { +- PyObject_HEAD +- void *pack; +- swig_type_info *ty; +- size_t size; +-} PySwigPacked; +- +-SWIGRUNTIME int +-PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags)) +-{ +- char result[SWIG_BUFFER_SIZE]; +- fputs("pack, v->size, 0, sizeof(result))) { +- fputs("at ", fp); +- fputs(result, fp); +- } +- fputs(v->ty->name,fp); +- fputs(">", fp); +- return 0; +-} +- +-SWIGRUNTIME PyObject * +-PySwigPacked_repr(PySwigPacked *v) +-{ +- char result[SWIG_BUFFER_SIZE]; +- if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { +- return PyString_FromFormat("", result, v->ty->name); +- } else { +- return PyString_FromFormat("", v->ty->name); +- } +-} +- +-SWIGRUNTIME PyObject * +-PySwigPacked_str(PySwigPacked *v) +-{ +- char result[SWIG_BUFFER_SIZE]; +- if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){ +- return PyString_FromFormat("%s%s", result, v->ty->name); +- } else { +- return PyString_FromString(v->ty->name); +- } +-} +- +-SWIGRUNTIME int +-PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w) +-{ +- size_t i = v->size; +- size_t j = w->size; +- int s = (i < j) ? -1 : ((i > j) ? 1 : 0); +- return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size); +-} +- +-SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void); +- +-SWIGRUNTIME PyTypeObject* +-PySwigPacked_type(void) { +- static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type(); +- return type; +-} +- +-SWIGRUNTIMEINLINE int +-PySwigPacked_Check(PyObject *op) { +- return ((op)->ob_type == _PySwigPacked_type()) +- || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0); +-} +- +-SWIGRUNTIME void +-PySwigPacked_dealloc(PyObject *v) +-{ +- if (PySwigPacked_Check(v)) { +- PySwigPacked *sobj = (PySwigPacked *) v; +- free(sobj->pack); +- } +- PyObject_DEL(v); +-} +- +-SWIGRUNTIME PyTypeObject* +-_PySwigPacked_type(void) { +- static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; +- static PyTypeObject pyswigpacked_type; +- static int type_init = 0; +- if (!type_init) { +- const PyTypeObject tmp +- = { +- PyObject_HEAD_INIT(NULL) +- 0, /* ob_size */ +- (char *)"PySwigPacked", /* tp_name */ +- sizeof(PySwigPacked), /* tp_basicsize */ +- 0, /* tp_itemsize */ +- (destructor)PySwigPacked_dealloc, /* tp_dealloc */ +- (printfunc)PySwigPacked_print, /* tp_print */ +- (getattrfunc)0, /* tp_getattr */ +- (setattrfunc)0, /* tp_setattr */ +- (cmpfunc)PySwigPacked_compare, /* tp_compare */ +- (reprfunc)PySwigPacked_repr, /* tp_repr */ +- 0, /* tp_as_number */ +- 0, /* tp_as_sequence */ +- 0, /* tp_as_mapping */ +- (hashfunc)0, /* tp_hash */ +- (ternaryfunc)0, /* tp_call */ +- (reprfunc)PySwigPacked_str, /* tp_str */ +- PyObject_GenericGetAttr, /* tp_getattro */ +- 0, /* tp_setattro */ +- 0, /* tp_as_buffer */ +- Py_TPFLAGS_DEFAULT, /* tp_flags */ +- swigpacked_doc, /* tp_doc */ +- 0, /* tp_traverse */ +- 0, /* tp_clear */ +- 0, /* tp_richcompare */ +- 0, /* tp_weaklistoffset */ +-#if PY_VERSION_HEX >= 0x02020000 +- 0, /* tp_iter */ +- 0, /* tp_iternext */ +- 0, /* tp_methods */ +- 0, /* tp_members */ +- 0, /* tp_getset */ +- 0, /* tp_base */ +- 0, /* tp_dict */ +- 0, /* tp_descr_get */ +- 0, /* tp_descr_set */ +- 0, /* tp_dictoffset */ +- 0, /* tp_init */ +- 0, /* tp_alloc */ +- 0, /* tp_new */ +- 0, /* tp_free */ +- 0, /* tp_is_gc */ +- 0, /* tp_bases */ +- 0, /* tp_mro */ +- 0, /* tp_cache */ +- 0, /* tp_subclasses */ +- 0, /* tp_weaklist */ +-#endif +-#if PY_VERSION_HEX >= 0x02030000 +- 0, /* tp_del */ +-#endif +-#ifdef COUNT_ALLOCS +- 0,0,0,0 /* tp_alloc -> tp_next */ +-#endif +- }; +- pyswigpacked_type = tmp; +- pyswigpacked_type.ob_type = &PyType_Type; +- type_init = 1; +- } +- return &pyswigpacked_type; +-} +- +-SWIGRUNTIME PyObject * +-PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty) +-{ +- PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type()); +- if (sobj) { +- void *pack = malloc(size); +- if (pack) { +- memcpy(pack, ptr, size); +- sobj->pack = pack; +- sobj->ty = ty; +- sobj->size = size; +- } else { +- PyObject_DEL((PyObject *) sobj); +- sobj = 0; +- } +- } +- return (PyObject *) sobj; +-} +- +-SWIGRUNTIME swig_type_info * +-PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size) +-{ +- if (PySwigPacked_Check(obj)) { +- PySwigPacked *sobj = (PySwigPacked *)obj; +- if (sobj->size != size) return 0; +- memcpy(ptr, sobj->pack, size); +- return sobj->ty; +- } else { +- return 0; +- } +-} +- +-/* ----------------------------------------------------------------------------- +- * pointers/data manipulation +- * ----------------------------------------------------------------------------- */ +- +-SWIGRUNTIMEINLINE PyObject * +-_SWIG_This(void) +-{ +- return PyString_FromString("this"); +-} +- +-SWIGRUNTIME PyObject * +-SWIG_This(void) +-{ +- static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This(); +- return swig_this; +-} +- +-/* #define SWIG_PYTHON_SLOW_GETSET_THIS */ +- +-SWIGRUNTIME PySwigObject * +-SWIG_Python_GetSwigThis(PyObject *pyobj) +-{ +- if (PySwigObject_Check(pyobj)) { +- return (PySwigObject *) pyobj; +- } else { +- PyObject *obj = 0; +-#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000)) +- if (PyInstance_Check(pyobj)) { +- obj = _PyInstance_Lookup(pyobj, SWIG_This()); +- } else { +- PyObject **dictptr = _PyObject_GetDictPtr(pyobj); +- if (dictptr != NULL) { +- PyObject *dict = *dictptr; +- obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0; +- } else { +-#ifdef PyWeakref_CheckProxy +- if (PyWeakref_CheckProxy(pyobj)) { +- PyObject *wobj = PyWeakref_GET_OBJECT(pyobj); +- return wobj ? SWIG_Python_GetSwigThis(wobj) : 0; +- } +-#endif +- obj = PyObject_GetAttr(pyobj,SWIG_This()); +- if (obj) { +- Py_DECREF(obj); +- } else { +- if (PyErr_Occurred()) PyErr_Clear(); +- return 0; +- } +- } +- } +-#else +- obj = PyObject_GetAttr(pyobj,SWIG_This()); +- if (obj) { +- Py_DECREF(obj); +- } else { +- if (PyErr_Occurred()) PyErr_Clear(); +- return 0; +- } +-#endif +- if (obj && !PySwigObject_Check(obj)) { +- /* a PyObject is called 'this', try to get the 'real this' +- PySwigObject from it */ +- return SWIG_Python_GetSwigThis(obj); +- } +- return (PySwigObject *)obj; +- } +-} +- +-/* Acquire a pointer value */ +- +-SWIGRUNTIME int +-SWIG_Python_AcquirePtr(PyObject *obj, int own) { +- if (own) { +- PySwigObject *sobj = SWIG_Python_GetSwigThis(obj); +- if (sobj) { +- int oldown = sobj->own; +- sobj->own = own; +- return oldown; +- } +- } +- return 0; +-} +- +-/* Convert a pointer value */ +- +-SWIGRUNTIME int +-SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) { +- if (!obj) return SWIG_ERROR; +- if (obj == Py_None) { +- if (ptr) *ptr = 0; +- return SWIG_OK; +- } else { +- PySwigObject *sobj = SWIG_Python_GetSwigThis(obj); +- while (sobj) { +- void *vptr = sobj->ptr; +- if (ty) { +- swig_type_info *to = sobj->ty; +- if (to == ty) { +- /* no type cast needed */ +- if (ptr) *ptr = vptr; +- break; +- } else { +- swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); +- if (!tc) { +- sobj = (PySwigObject *)sobj->next; +- } else { +- if (ptr) *ptr = SWIG_TypeCast(tc,vptr); +- break; +- } +- } +- } else { +- if (ptr) *ptr = vptr; +- break; +- } +- } +- if (sobj) { +- if (own) *own = sobj->own; +- if (flags & SWIG_POINTER_DISOWN) { +- sobj->own = 0; +- } +- return SWIG_OK; +- } else { +- int res = SWIG_ERROR; +- if (flags & SWIG_POINTER_IMPLICIT_CONV) { +- PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0; +- if (data && !data->implicitconv) { +- PyObject *klass = data->klass; +- if (klass) { +- PyObject *impconv; +- data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/ +- impconv = SWIG_Python_CallFunctor(klass, obj); +- data->implicitconv = 0; +- if (PyErr_Occurred()) { +- PyErr_Clear(); +- impconv = 0; +- } +- if (impconv) { +- PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv); +- if (iobj) { +- void *vptr; +- res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0); +- if (SWIG_IsOK(res)) { +- if (ptr) { +- *ptr = vptr; +- /* transfer the ownership to 'ptr' */ +- iobj->own = 0; +- res = SWIG_AddCast(res); +- res = SWIG_AddNewMask(res); +- } else { +- res = SWIG_AddCast(res); +- } +- } +- } +- Py_DECREF(impconv); +- } +- } +- } +- } +- return res; +- } +- } +-} +- +-/* Convert a function ptr value */ +- +-SWIGRUNTIME int +-SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) { +- if (!PyCFunction_Check(obj)) { +- return SWIG_ConvertPtr(obj, ptr, ty, 0); +- } else { +- void *vptr = 0; +- +- /* here we get the method pointer for callbacks */ +- const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); +- const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0; +- if (desc) { +- desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; +- if (!desc) return SWIG_ERROR; +- } +- if (ty) { +- swig_cast_info *tc = SWIG_TypeCheck(desc,ty); +- if (!tc) return SWIG_ERROR; +- *ptr = SWIG_TypeCast(tc,vptr); +- } else { +- *ptr = vptr; +- } +- return SWIG_OK; +- } +-} +- +-/* Convert a packed value value */ +- +-SWIGRUNTIME int +-SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) { +- swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz); +- if (!to) return SWIG_ERROR; +- if (ty) { +- if (to != ty) { +- /* check type cast? */ +- swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); +- if (!tc) return SWIG_ERROR; +- } +- } +- return SWIG_OK; +-} +- +-/* ----------------------------------------------------------------------------- +- * Create a new pointer object +- * ----------------------------------------------------------------------------- */ +- +-/* +- Create a new instance object, whitout calling __init__, and set the +- 'this' attribute. +-*/ +- +-SWIGRUNTIME PyObject* +-SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this) +-{ +-#if (PY_VERSION_HEX >= 0x02020000) +- PyObject *inst = 0; +- PyObject *newraw = data->newraw; +- if (newraw) { +- inst = PyObject_Call(newraw, data->newargs, NULL); +- if (inst) { +-#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) +- PyObject **dictptr = _PyObject_GetDictPtr(inst); +- if (dictptr != NULL) { +- PyObject *dict = *dictptr; +- if (dict == NULL) { +- dict = PyDict_New(); +- *dictptr = dict; +- PyDict_SetItem(dict, SWIG_This(), swig_this); +- } +- } +-#else +- PyObject *key = SWIG_This(); +- PyObject_SetAttr(inst, key, swig_this); +-#endif +- } +- } else { +- PyObject *dict = PyDict_New(); +- PyDict_SetItem(dict, SWIG_This(), swig_this); +- inst = PyInstance_NewRaw(data->newargs, dict); +- Py_DECREF(dict); +- } +- return inst; +-#else +-#if (PY_VERSION_HEX >= 0x02010000) +- PyObject *inst; +- PyObject *dict = PyDict_New(); +- PyDict_SetItem(dict, SWIG_This(), swig_this); +- inst = PyInstance_NewRaw(data->newargs, dict); +- Py_DECREF(dict); +- return (PyObject *) inst; +-#else +- PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type); +- if (inst == NULL) { +- return NULL; +- } +- inst->in_class = (PyClassObject *)data->newargs; +- Py_INCREF(inst->in_class); +- inst->in_dict = PyDict_New(); +- if (inst->in_dict == NULL) { +- Py_DECREF(inst); +- return NULL; +- } +-#ifdef Py_TPFLAGS_HAVE_WEAKREFS +- inst->in_weakreflist = NULL; +-#endif +-#ifdef Py_TPFLAGS_GC +- PyObject_GC_Init(inst); +-#endif +- PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this); +- return (PyObject *) inst; +-#endif +-#endif +-} +- +-SWIGRUNTIME void +-SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this) +-{ +- PyObject *dict; +-#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS) +- PyObject **dictptr = _PyObject_GetDictPtr(inst); +- if (dictptr != NULL) { +- dict = *dictptr; +- if (dict == NULL) { +- dict = PyDict_New(); +- *dictptr = dict; +- } +- PyDict_SetItem(dict, SWIG_This(), swig_this); +- return; +- } +-#endif +- dict = PyObject_GetAttrString(inst, (char*)"__dict__"); +- PyDict_SetItem(dict, SWIG_This(), swig_this); +- Py_DECREF(dict); +-} +- +- +-SWIGINTERN PyObject * +-SWIG_Python_InitShadowInstance(PyObject *args) { +- PyObject *obj[2]; +- if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) { +- return NULL; +- } else { +- PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]); +- if (sthis) { +- PySwigObject_append((PyObject*) sthis, obj[1]); +- } else { +- SWIG_Python_SetSwigThis(obj[0], obj[1]); +- } +- return SWIG_Py_Void(); +- } +-} +- +-/* Create a new pointer object */ +- +-SWIGRUNTIME PyObject * +-SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) { +- if (!ptr) { +- return SWIG_Py_Void(); +- } else { +- int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0; +- PyObject *robj = PySwigObject_New(ptr, type, own); +- PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0; +- if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) { +- PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj); +- if (inst) { +- Py_DECREF(robj); +- robj = inst; +- } +- } +- return robj; +- } +-} +- +-/* Create a new packed object */ +- +-SWIGRUNTIMEINLINE PyObject * +-SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { +- return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void(); +-} +- +-/* -----------------------------------------------------------------------------* +- * Get type list +- * -----------------------------------------------------------------------------*/ +- +-#ifdef SWIG_LINK_RUNTIME +-void *SWIG_ReturnGlobalTypeList(void *); +-#endif +- +-SWIGRUNTIME swig_module_info * +-SWIG_Python_GetModule(void) { +- static void *type_pointer = (void *)0; +- /* first check if module already created */ +- if (!type_pointer) { +-#ifdef SWIG_LINK_RUNTIME +- type_pointer = SWIG_ReturnGlobalTypeList((void *)0); +-#else +- type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, +- (char*)"type_pointer" SWIG_TYPE_TABLE_NAME); +- if (PyErr_Occurred()) { +- PyErr_Clear(); +- type_pointer = (void *)0; +- } +-#endif +- } +- return (swig_module_info *) type_pointer; +-} +- +-#if PY_MAJOR_VERSION < 2 +-/* PyModule_AddObject function was introduced in Python 2.0. The following function +- is copied out of Python/modsupport.c in python version 2.3.4 */ +-SWIGINTERN int +-PyModule_AddObject(PyObject *m, char *name, PyObject *o) +-{ +- PyObject *dict; +- if (!PyModule_Check(m)) { +- PyErr_SetString(PyExc_TypeError, +- "PyModule_AddObject() needs module as first arg"); +- return SWIG_ERROR; +- } +- if (!o) { +- PyErr_SetString(PyExc_TypeError, +- "PyModule_AddObject() needs non-NULL value"); +- return SWIG_ERROR; +- } +- +- dict = PyModule_GetDict(m); +- if (dict == NULL) { +- /* Internal error -- modules must have a dict! */ +- PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__", +- PyModule_GetName(m)); +- return SWIG_ERROR; +- } +- if (PyDict_SetItemString(dict, name, o)) +- return SWIG_ERROR; +- Py_DECREF(o); +- return SWIG_OK; +-} +-#endif +- +-SWIGRUNTIME void +-SWIG_Python_DestroyModule(void *vptr) +-{ +- swig_module_info *swig_module = (swig_module_info *) vptr; +- swig_type_info **types = swig_module->types; +- size_t i; +- for (i =0; i < swig_module->size; ++i) { +- swig_type_info *ty = types[i]; +- if (ty->owndata) { +- PySwigClientData *data = (PySwigClientData *) ty->clientdata; +- if (data) PySwigClientData_Del(data); +- } +- } +- Py_DECREF(SWIG_This()); +-} +- +-SWIGRUNTIME void +-SWIG_Python_SetModule(swig_module_info *swig_module) { +- static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */ +- +- PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, +- swig_empty_runtime_method_table); +- PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule); +- if (pointer && module) { +- PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer); +- } else { +- Py_XDECREF(pointer); +- } +-} +- +-/* The python cached type query */ +-SWIGRUNTIME PyObject * +-SWIG_Python_TypeCache(void) { +- static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New(); +- return cache; +-} +- +-SWIGRUNTIME swig_type_info * +-SWIG_Python_TypeQuery(const char *type) +-{ +- PyObject *cache = SWIG_Python_TypeCache(); +- PyObject *key = PyString_FromString(type); +- PyObject *obj = PyDict_GetItem(cache, key); +- swig_type_info *descriptor; +- if (obj) { +- descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj); +- } else { +- swig_module_info *swig_module = SWIG_Python_GetModule(); +- descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); +- if (descriptor) { +- obj = PyCObject_FromVoidPtr(descriptor, NULL); +- PyDict_SetItem(cache, key, obj); +- Py_DECREF(obj); +- } +- } +- Py_DECREF(key); +- return descriptor; +-} +- +-/* +- For backward compatibility only +-*/ +-#define SWIG_POINTER_EXCEPTION 0 +-#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg) +-#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) +- +-SWIGRUNTIME int +-SWIG_Python_AddErrMesg(const char* mesg, int infront) +-{ +- if (PyErr_Occurred()) { +- PyObject *type = 0; +- PyObject *value = 0; +- PyObject *traceback = 0; +- PyErr_Fetch(&type, &value, &traceback); +- if (value) { +- PyObject *old_str = PyObject_Str(value); +- Py_XINCREF(type); +- PyErr_Clear(); +- if (infront) { +- PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str)); +- } else { +- PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg); +- } +- Py_DECREF(old_str); +- } +- return 1; +- } else { +- return 0; +- } +-} +- +-SWIGRUNTIME int +-SWIG_Python_ArgFail(int argnum) +-{ +- if (PyErr_Occurred()) { +- /* add information about failing argument */ +- char mesg[256]; +- PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum); +- return SWIG_Python_AddErrMesg(mesg, 1); +- } else { +- return 0; +- } +-} +- +-SWIGRUNTIMEINLINE const char * +-PySwigObject_GetDesc(PyObject *self) +-{ +- PySwigObject *v = (PySwigObject *)self; +- swig_type_info *ty = v ? v->ty : 0; +- return ty ? ty->str : (char*)""; +-} +- +-SWIGRUNTIME void +-SWIG_Python_TypeError(const char *type, PyObject *obj) +-{ +- if (type) { +-#if defined(SWIG_COBJECT_TYPES) +- if (obj && PySwigObject_Check(obj)) { +- const char *otype = (const char *) PySwigObject_GetDesc(obj); +- if (otype) { +- PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received", +- type, otype); +- return; +- } +- } else +-#endif +- { +- const char *otype = (obj ? obj->ob_type->tp_name : 0); +- if (otype) { +- PyObject *str = PyObject_Str(obj); +- const char *cstr = str ? PyString_AsString(str) : 0; +- if (cstr) { +- PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", +- type, otype, cstr); +- } else { +- PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", +- type, otype); +- } +- Py_XDECREF(str); +- return; +- } +- } +- PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); +- } else { +- PyErr_Format(PyExc_TypeError, "unexpected type is received"); +- } +-} +- +- +-/* Convert a pointer value, signal an exception on a type mismatch */ +-SWIGRUNTIME void * +-SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) { +- void *result; +- if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { +- PyErr_Clear(); +- if (flags & SWIG_POINTER_EXCEPTION) { +- SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); +- SWIG_Python_ArgFail(argnum); +- } +- } +- return result; +-} +- +- +-#ifdef __cplusplus +-#if 0 +-{ /* cc-mode */ +-#endif +-} +-#endif +- +- +- +-#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) +- +-#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else +- +- +- +-/* -------- TYPES TABLE (BEGIN) -------- */ +- +-#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_pid_t swig_types[10] +-#define SWIGTYPE_p_security_class_mapping swig_types[11] +-#define SWIGTYPE_p_selinux_callback swig_types[12] +-#define SWIGTYPE_p_selinux_opt swig_types[13] +-#define SWIGTYPE_p_unsigned_int swig_types[14] +-#define SWIGTYPE_p_unsigned_short swig_types[15] +-static swig_type_info *swig_types[17]; +-static swig_module_info swig_module = {swig_types, 16, 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) +- +-/* -------- TYPES TABLE (END) -------- */ +- +-#if (PY_VERSION_HEX <= 0x02000000) +-# if !defined(SWIG_PYTHON_CLASSIC) +-# error "This python version requires swig to be run with the '-classic' option" +-# endif +-#endif +- +-/*----------------------------------------------- +- @(target):= _selinux.so +- ------------------------------------------------*/ +-#define SWIG_init init_selinux +- +-#define SWIG_name "_selinux" +- +-#define SWIGVERSION 0x010331 +-#define SWIG_VERSION SWIGVERSION +- +- +-#define SWIG_as_voidptr(a) (void *)((const void *)(a)) +-#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a)) +- +- +- #include "selinux/selinux.h" +- +- +- #include "selinux/selinux.h" +- +- +- #define SWIG_From_long PyInt_FromLong +- +- +-SWIGINTERNINLINE PyObject * +-SWIG_From_int (int value) +-{ +- return SWIG_From_long (value); +-} +- +- +-SWIGINTERN swig_type_info* +-SWIG_pchar_descriptor(void) +-{ +- static int init = 0; +- static swig_type_info* info = 0; +- if (!init) { +- info = SWIG_TypeQuery("_p_char"); +- init = 1; +- } +- return info; +-} +- +- +-SWIGINTERN int +-SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) +-{ +- if (PyString_Check(obj)) { +- char *cstr; Py_ssize_t len; +- PyString_AsStringAndSize(obj, &cstr, &len); +- if (cptr) { +- if (alloc) { +- /* +- In python the user should not be able to modify the inner +- string representation. To warranty that, if you define +- SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string +- buffer is always returned. +- +- The default behavior is just to return the pointer value, +- so, be careful. +- */ +-#if defined(SWIG_PYTHON_SAFE_CSTRINGS) +- if (*alloc != SWIG_OLDOBJ) +-#else +- if (*alloc == SWIG_NEWOBJ) +-#endif +- { +- *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1)); +- *alloc = SWIG_NEWOBJ; +- } +- else { +- *cptr = cstr; +- *alloc = SWIG_OLDOBJ; +- } +- } else { +- *cptr = PyString_AsString(obj); +- } +- } +- if (psize) *psize = len + 1; +- return SWIG_OK; +- } else { +- swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); +- if (pchar_descriptor) { +- void* vptr = 0; +- if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) { +- if (cptr) *cptr = (char *) vptr; +- if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0; +- if (alloc) *alloc = SWIG_OLDOBJ; +- return SWIG_OK; +- } +- } +- } +- return SWIG_TypeError; +-} +- +- +- +- +- +-#include +-#ifndef LLONG_MIN +-# define LLONG_MIN LONG_LONG_MIN +-#endif +-#ifndef LLONG_MAX +-# define LLONG_MAX LONG_LONG_MAX +-#endif +-#ifndef ULLONG_MAX +-# define ULLONG_MAX ULONG_LONG_MAX +-#endif +- +- +-SWIGINTERN int +-SWIG_AsVal_double (PyObject *obj, double *val) +-{ +- int res = SWIG_TypeError; +- if (PyFloat_Check(obj)) { +- if (val) *val = PyFloat_AsDouble(obj); +- return SWIG_OK; +- } else if (PyInt_Check(obj)) { +- if (val) *val = PyInt_AsLong(obj); +- return SWIG_OK; +- } else if (PyLong_Check(obj)) { +- double v = PyLong_AsDouble(obj); +- if (!PyErr_Occurred()) { +- if (val) *val = v; +- return SWIG_OK; +- } else { +- PyErr_Clear(); +- } +- } +-#ifdef SWIG_PYTHON_CAST_MODE +- { +- int dispatch = 0; +- double d = PyFloat_AsDouble(obj); +- if (!PyErr_Occurred()) { +- if (val) *val = d; +- return SWIG_AddCast(SWIG_OK); +- } else { +- PyErr_Clear(); +- } +- if (!dispatch) { +- long v = PyLong_AsLong(obj); +- if (!PyErr_Occurred()) { +- if (val) *val = v; +- return SWIG_AddCast(SWIG_AddCast(SWIG_OK)); +- } else { +- PyErr_Clear(); +- } +- } +- } +-#endif +- return res; +-} +- +- +-#include +- +- +-#include +- +- +-SWIGINTERNINLINE int +-SWIG_CanCastAsInteger(double *d, double min, double max) { +- double x = *d; +- if ((min <= x && x <= max)) { +- double fx = floor(x); +- double cx = ceil(x); +- double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ +- if ((errno == EDOM) || (errno == ERANGE)) { +- errno = 0; +- } else { +- double summ, reps, diff; +- if (rd < x) { +- diff = x - rd; +- } else if (rd > x) { +- diff = rd - x; +- } else { +- return 1; +- } +- summ = rd + x; +- reps = diff/summ; +- if (reps < 8*DBL_EPSILON) { +- *d = rd; +- return 1; +- } +- } +- } +- return 0; +-} +- +- +-SWIGINTERN int +-SWIG_AsVal_long (PyObject *obj, long* val) +-{ +- if (PyInt_Check(obj)) { +- if (val) *val = PyInt_AsLong(obj); +- return SWIG_OK; +- } else if (PyLong_Check(obj)) { +- long v = PyLong_AsLong(obj); +- if (!PyErr_Occurred()) { +- if (val) *val = v; +- return SWIG_OK; +- } else { +- PyErr_Clear(); +- } +- } +-#ifdef SWIG_PYTHON_CAST_MODE +- { +- int dispatch = 0; +- long v = PyInt_AsLong(obj); +- if (!PyErr_Occurred()) { +- if (val) *val = v; +- return SWIG_AddCast(SWIG_OK); +- } else { +- PyErr_Clear(); +- } +- if (!dispatch) { +- double d; +- int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); +- if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { +- if (val) *val = (long)(d); +- return res; +- } +- } +- } +-#endif +- return SWIG_TypeError; +-} +- +- +-SWIGINTERN int +-SWIG_AsVal_int (PyObject * obj, int *val) +-{ +- long v; +- int res = SWIG_AsVal_long (obj, &v); +- if (SWIG_IsOK(res)) { +- if ((v < INT_MIN || v > INT_MAX)) { +- return SWIG_OverflowError; +- } else { +- if (val) *val = (int)(v); +- } +- } +- return res; +-} +- +- +-SWIGINTERN int +-SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) +-{ +- if (PyInt_Check(obj)) { +- long v = PyInt_AsLong(obj); +- if (v >= 0) { +- if (val) *val = v; +- return SWIG_OK; +- } else { +- return SWIG_OverflowError; +- } +- } else if (PyLong_Check(obj)) { +- unsigned long v = PyLong_AsUnsignedLong(obj); +- if (!PyErr_Occurred()) { +- if (val) *val = v; +- return SWIG_OK; +- } else { +- PyErr_Clear(); +- } +- } +-#ifdef SWIG_PYTHON_CAST_MODE +- { +- int dispatch = 0; +- unsigned long v = PyLong_AsUnsignedLong(obj); +- if (!PyErr_Occurred()) { +- if (val) *val = v; +- return SWIG_AddCast(SWIG_OK); +- } else { +- PyErr_Clear(); +- } +- if (!dispatch) { +- double d; +- int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); +- if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) { +- if (val) *val = (unsigned long)(d); +- return res; +- } +- } +- } +-#endif +- return SWIG_TypeError; +-} +- +- +-SWIGINTERN int +-SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val) +-{ +- unsigned long v; +- int res = SWIG_AsVal_unsigned_SS_long (obj, &v); +- if (SWIG_IsOK(res)) { +- if ((v > UINT_MAX)) { +- return SWIG_OverflowError; +- } else { +- if (val) *val = (unsigned int)(v); +- } +- } +- return res; +-} +- +- +-SWIGINTERNINLINE PyObject* +-SWIG_From_unsigned_SS_long (unsigned long value) +-{ +- return (value > LONG_MAX) ? +- PyLong_FromUnsignedLong(value) : PyInt_FromLong((long)(value)); +-} +- +- +-SWIGINTERNINLINE PyObject * +-SWIG_From_unsigned_SS_int (unsigned int value) +-{ +- return SWIG_From_unsigned_SS_long (value); +-} +- +- +-SWIGINTERNINLINE PyObject * +-SWIG_FromCharPtrAndSize(const char* carray, size_t size) +-{ +- if (carray) { +- if (size > INT_MAX) { +- swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); +- return pchar_descriptor ? +- SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void(); +- } else { +- return PyString_FromStringAndSize(carray, (int)(size)); +- } +- } else { +- return SWIG_Py_Void(); +- } +-} +- +- +-SWIGINTERNINLINE PyObject * +-SWIG_FromCharPtr(const char *cptr) +-{ +- return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0)); +-} +- +- +-SWIGINTERN int +-SWIG_AsVal_unsigned_SS_short (PyObject * obj, unsigned short *val) +-{ +- unsigned long v; +- int res = SWIG_AsVal_unsigned_SS_long (obj, &v); +- if (SWIG_IsOK(res)) { +- if ((v > USHRT_MAX)) { +- return SWIG_OverflowError; +- } else { +- if (val) *val = (unsigned short)(v); +- } +- } +- return res; +-} +- +- +-SWIGINTERNINLINE int +-SWIG_AsVal_size_t (PyObject * obj, size_t *val) +-{ +- unsigned long v; +- int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0); +- if (SWIG_IsOK(res) && val) *val = (size_t)(v); +- return res; +-} +- +- +-SWIGINTERNINLINE PyObject * +-SWIG_From_unsigned_SS_short (unsigned short value) +-{ +- return SWIG_From_unsigned_SS_long (value); +-} +- +-#ifdef __cplusplus +-extern "C" { +-#endif +-SWIGINTERN PyObject *_wrap_is_selinux_enabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- int result; +- +- if (!PyArg_ParseTuple(args,(char *)":is_selinux_enabled")) SWIG_fail; +- result = (int)is_selinux_enabled(); +- resultobj = SWIG_From_int((int)(result)); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_is_selinux_mls_enabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- int result; +- +- if (!PyArg_ParseTuple(args,(char *)":is_selinux_mls_enabled")) SWIG_fail; +- result = (int)is_selinux_mls_enabled(); +- resultobj = SWIG_From_int((int)(result)); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_getcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t *arg1 = (security_context_t *) 0 ; +- int result; +- security_context_t temp1 = 0 ; +- +- arg1 = &temp1; +- if (!PyArg_ParseTuple(args,(char *)":getcon")) SWIG_fail; +- result = (int)getcon(arg1); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg1) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1)); +- freecon(*arg1); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_getcon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t *arg1 = (security_context_t *) 0 ; +- int result; +- security_context_t temp1 = 0 ; +- +- arg1 = &temp1; +- if (!PyArg_ParseTuple(args,(char *)":getcon_raw")) SWIG_fail; +- result = (int)getcon_raw(arg1); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg1) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1)); +- freecon(*arg1); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_setcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:setcon",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setcon" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- result = (int)setcon(arg1); +- 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_setcon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:setcon_raw",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setcon_raw" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- result = (int)setcon_raw(arg1); +- 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_getpidcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- pid_t arg1 ; +- security_context_t *arg2 = (security_context_t *) 0 ; +- int result; +- void *argp1 ; +- int res1 = 0 ; +- security_context_t temp2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; +- if (!PyArg_ParseTuple(args,(char *)"O:getpidcon",&obj0)) SWIG_fail; +- { +- res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_pid_t, 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getpidcon" "', argument " "1"" of type '" "pid_t""'"); +- } +- if (!argp1) { +- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getpidcon" "', argument " "1"" of type '" "pid_t""'"); +- } else { +- arg1 = *((pid_t *)(argp1)); +- } +- } +- result = (int)getpidcon(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_getpidcon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- pid_t arg1 ; +- security_context_t *arg2 = (security_context_t *) 0 ; +- int result; +- void *argp1 ; +- int res1 = 0 ; +- security_context_t temp2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; +- if (!PyArg_ParseTuple(args,(char *)"O:getpidcon_raw",&obj0)) SWIG_fail; +- { +- res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_pid_t, 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getpidcon_raw" "', argument " "1"" of type '" "pid_t""'"); +- } +- if (!argp1) { +- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getpidcon_raw" "', argument " "1"" of type '" "pid_t""'"); +- } else { +- arg1 = *((pid_t *)(argp1)); +- } +- } +- result = (int)getpidcon_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_getprevcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t *arg1 = (security_context_t *) 0 ; +- int result; +- security_context_t temp1 = 0 ; +- +- arg1 = &temp1; +- if (!PyArg_ParseTuple(args,(char *)":getprevcon")) SWIG_fail; +- result = (int)getprevcon(arg1); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg1) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1)); +- freecon(*arg1); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_getprevcon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t *arg1 = (security_context_t *) 0 ; +- int result; +- security_context_t temp1 = 0 ; +- +- arg1 = &temp1; +- if (!PyArg_ParseTuple(args,(char *)":getprevcon_raw")) SWIG_fail; +- result = (int)getprevcon_raw(arg1); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg1) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1)); +- freecon(*arg1); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_getexeccon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t *arg1 = (security_context_t *) 0 ; +- int result; +- security_context_t temp1 = 0 ; +- +- arg1 = &temp1; +- if (!PyArg_ParseTuple(args,(char *)":getexeccon")) SWIG_fail; +- result = (int)getexeccon(arg1); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg1) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1)); +- freecon(*arg1); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_getexeccon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t *arg1 = (security_context_t *) 0 ; +- int result; +- security_context_t temp1 = 0 ; +- +- arg1 = &temp1; +- if (!PyArg_ParseTuple(args,(char *)":getexeccon_raw")) SWIG_fail; +- result = (int)getexeccon_raw(arg1); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg1) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1)); +- freecon(*arg1); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_setexeccon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:setexeccon",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setexeccon" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- result = (int)setexeccon(arg1); +- 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_setexeccon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:setexeccon_raw",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setexeccon_raw" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- result = (int)setexeccon_raw(arg1); +- 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_getfscreatecon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t *arg1 = (security_context_t *) 0 ; +- int result; +- security_context_t temp1 = 0 ; +- +- arg1 = &temp1; +- if (!PyArg_ParseTuple(args,(char *)":getfscreatecon")) SWIG_fail; +- result = (int)getfscreatecon(arg1); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg1) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1)); +- freecon(*arg1); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_getfscreatecon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t *arg1 = (security_context_t *) 0 ; +- int result; +- security_context_t temp1 = 0 ; +- +- arg1 = &temp1; +- if (!PyArg_ParseTuple(args,(char *)":getfscreatecon_raw")) SWIG_fail; +- result = (int)getfscreatecon_raw(arg1); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg1) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1)); +- freecon(*arg1); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_setfscreatecon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:setfscreatecon",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setfscreatecon" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- result = (int)setfscreatecon(arg1); +- 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_setfscreatecon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:setfscreatecon_raw",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setfscreatecon_raw" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- result = (int)setfscreatecon_raw(arg1); +- 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_getkeycreatecon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t *arg1 = (security_context_t *) 0 ; +- int result; +- security_context_t temp1 = 0 ; +- +- arg1 = &temp1; +- if (!PyArg_ParseTuple(args,(char *)":getkeycreatecon")) SWIG_fail; +- result = (int)getkeycreatecon(arg1); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg1) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1)); +- freecon(*arg1); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_getkeycreatecon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t *arg1 = (security_context_t *) 0 ; +- int result; +- security_context_t temp1 = 0 ; +- +- arg1 = &temp1; +- if (!PyArg_ParseTuple(args,(char *)":getkeycreatecon_raw")) SWIG_fail; +- result = (int)getkeycreatecon_raw(arg1); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg1) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1)); +- freecon(*arg1); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_setkeycreatecon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:setkeycreatecon",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setkeycreatecon" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- result = (int)setkeycreatecon(arg1); +- 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_setkeycreatecon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:setkeycreatecon_raw",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setkeycreatecon_raw" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- result = (int)setkeycreatecon_raw(arg1); +- 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_getsockcreatecon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t *arg1 = (security_context_t *) 0 ; +- int result; +- security_context_t temp1 = 0 ; +- +- arg1 = &temp1; +- if (!PyArg_ParseTuple(args,(char *)":getsockcreatecon")) SWIG_fail; +- result = (int)getsockcreatecon(arg1); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg1) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1)); +- freecon(*arg1); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_getsockcreatecon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t *arg1 = (security_context_t *) 0 ; +- int result; +- security_context_t temp1 = 0 ; +- +- arg1 = &temp1; +- if (!PyArg_ParseTuple(args,(char *)":getsockcreatecon_raw")) SWIG_fail; +- result = (int)getsockcreatecon_raw(arg1); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg1) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1)); +- freecon(*arg1); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_setsockcreatecon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:setsockcreatecon",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setsockcreatecon" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- result = (int)setsockcreatecon(arg1); +- 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_setsockcreatecon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:setsockcreatecon_raw",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setsockcreatecon_raw" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- result = (int)setsockcreatecon_raw(arg1); +- 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_getfilecon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- security_context_t *arg2 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- security_context_t temp2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; +- if (!PyArg_ParseTuple(args,(char *)"O:getfilecon",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getfilecon" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- result = (int)getfilecon((char const *)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); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_getfilecon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- security_context_t *arg2 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- security_context_t temp2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; +- if (!PyArg_ParseTuple(args,(char *)"O:getfilecon_raw",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getfilecon_raw" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- result = (int)getfilecon_raw((char const *)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); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_lgetfilecon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- security_context_t *arg2 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- security_context_t temp2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; +- if (!PyArg_ParseTuple(args,(char *)"O:lgetfilecon",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lgetfilecon" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- result = (int)lgetfilecon((char const *)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); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_lgetfilecon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- security_context_t *arg2 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- security_context_t temp2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; +- if (!PyArg_ParseTuple(args,(char *)"O:lgetfilecon_raw",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lgetfilecon_raw" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- result = (int)lgetfilecon_raw((char const *)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); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_fgetfilecon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- int arg1 ; +- security_context_t *arg2 = (security_context_t *) 0 ; +- int result; +- int val1 ; +- int ecode1 = 0 ; +- security_context_t temp2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; +- if (!PyArg_ParseTuple(args,(char *)"O:fgetfilecon",&obj0)) SWIG_fail; +- ecode1 = SWIG_AsVal_int(obj0, &val1); +- if (!SWIG_IsOK(ecode1)) { +- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fgetfilecon" "', argument " "1"" of type '" "int""'"); +- } +- arg1 = (int)(val1); +- result = (int)fgetfilecon(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_fgetfilecon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- int arg1 ; +- security_context_t *arg2 = (security_context_t *) 0 ; +- int result; +- int val1 ; +- int ecode1 = 0 ; +- security_context_t temp2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; +- if (!PyArg_ParseTuple(args,(char *)"O:fgetfilecon_raw",&obj0)) SWIG_fail; +- ecode1 = SWIG_AsVal_int(obj0, &val1); +- if (!SWIG_IsOK(ecode1)) { +- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fgetfilecon_raw" "', argument " "1"" of type '" "int""'"); +- } +- arg1 = (int)(val1); +- result = (int)fgetfilecon_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_setfilecon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- security_context_t arg2 = (security_context_t) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"OO:setfilecon",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setfilecon" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "setfilecon" "', argument " "2"" of type '" "security_context_t""'"); +- } +- arg2 = (security_context_t)(buf2); +- result = (int)setfilecon((char const *)arg1,arg2); +- resultobj = SWIG_From_int((int)(result)); +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_setfilecon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- security_context_t arg2 = (security_context_t) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"OO:setfilecon_raw",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setfilecon_raw" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "setfilecon_raw" "', argument " "2"" of type '" "security_context_t""'"); +- } +- arg2 = (security_context_t)(buf2); +- result = (int)setfilecon_raw((char const *)arg1,arg2); +- resultobj = SWIG_From_int((int)(result)); +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_lsetfilecon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- security_context_t arg2 = (security_context_t) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"OO:lsetfilecon",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lsetfilecon" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lsetfilecon" "', argument " "2"" of type '" "security_context_t""'"); +- } +- arg2 = (security_context_t)(buf2); +- result = (int)lsetfilecon((char const *)arg1,arg2); +- resultobj = SWIG_From_int((int)(result)); +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_lsetfilecon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- security_context_t arg2 = (security_context_t) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"OO:lsetfilecon_raw",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lsetfilecon_raw" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lsetfilecon_raw" "', argument " "2"" of type '" "security_context_t""'"); +- } +- arg2 = (security_context_t)(buf2); +- result = (int)lsetfilecon_raw((char const *)arg1,arg2); +- resultobj = SWIG_From_int((int)(result)); +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_fsetfilecon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- int arg1 ; +- security_context_t arg2 = (security_context_t) 0 ; +- int result; +- int val1 ; +- int ecode1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"OO:fsetfilecon",&obj0,&obj1)) SWIG_fail; +- ecode1 = SWIG_AsVal_int(obj0, &val1); +- if (!SWIG_IsOK(ecode1)) { +- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fsetfilecon" "', argument " "1"" of type '" "int""'"); +- } +- arg1 = (int)(val1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fsetfilecon" "', argument " "2"" of type '" "security_context_t""'"); +- } +- arg2 = (security_context_t)(buf2); +- result = (int)fsetfilecon(arg1,arg2); +- resultobj = SWIG_From_int((int)(result)); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return resultobj; +-fail: +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_fsetfilecon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- int arg1 ; +- security_context_t arg2 = (security_context_t) 0 ; +- int result; +- int val1 ; +- int ecode1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"OO:fsetfilecon_raw",&obj0,&obj1)) SWIG_fail; +- ecode1 = SWIG_AsVal_int(obj0, &val1); +- if (!SWIG_IsOK(ecode1)) { +- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fsetfilecon_raw" "', argument " "1"" of type '" "int""'"); +- } +- arg1 = (int)(val1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fsetfilecon_raw" "', argument " "2"" of type '" "security_context_t""'"); +- } +- arg2 = (security_context_t)(buf2); +- result = (int)fsetfilecon_raw(arg1,arg2); +- resultobj = SWIG_From_int((int)(result)); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return resultobj; +-fail: +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_getpeercon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- int arg1 ; +- security_context_t *arg2 = (security_context_t *) 0 ; +- int result; +- int val1 ; +- int ecode1 = 0 ; +- security_context_t temp2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; +- if (!PyArg_ParseTuple(args,(char *)"O:getpeercon",&obj0)) SWIG_fail; +- ecode1 = SWIG_AsVal_int(obj0, &val1); +- if (!SWIG_IsOK(ecode1)) { +- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "getpeercon" "', argument " "1"" of type '" "int""'"); +- } +- arg1 = (int)(val1); +- result = (int)getpeercon(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_getpeercon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- int arg1 ; +- security_context_t *arg2 = (security_context_t *) 0 ; +- int result; +- int val1 ; +- int ecode1 = 0 ; +- security_context_t temp2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; +- if (!PyArg_ParseTuple(args,(char *)"O:getpeercon_raw",&obj0)) SWIG_fail; +- ecode1 = SWIG_AsVal_int(obj0, &val1); +- if (!SWIG_IsOK(ecode1)) { +- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "getpeercon_raw" "', argument " "1"" of type '" "int""'"); +- } +- arg1 = (int)(val1); +- result = (int)getpeercon_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_av_decision_allowed_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct av_decision *arg1 = (struct av_decision *) 0 ; +- access_vector_t 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:av_decision_allowed_set",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_av_decision, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "av_decision_allowed_set" "', argument " "1"" of type '" "struct av_decision *""'"); +- } +- arg1 = (struct av_decision *)(argp1); +- ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); +- if (!SWIG_IsOK(ecode2)) { +- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "av_decision_allowed_set" "', argument " "2"" of type '" "access_vector_t""'"); +- } +- arg2 = (access_vector_t)(val2); +- if (arg1) (arg1)->allowed = arg2; +- +- resultobj = SWIG_Py_Void(); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_av_decision_allowed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct av_decision *arg1 = (struct av_decision *) 0 ; +- access_vector_t result; +- void *argp1 = 0 ; +- int res1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:av_decision_allowed_get",&obj0)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_av_decision, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "av_decision_allowed_get" "', argument " "1"" of type '" "struct av_decision *""'"); +- } +- arg1 = (struct av_decision *)(argp1); +- result = (access_vector_t) ((arg1)->allowed); +- resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_av_decision_decided_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct av_decision *arg1 = (struct av_decision *) 0 ; +- access_vector_t 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:av_decision_decided_set",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_av_decision, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "av_decision_decided_set" "', argument " "1"" of type '" "struct av_decision *""'"); +- } +- arg1 = (struct av_decision *)(argp1); +- ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); +- if (!SWIG_IsOK(ecode2)) { +- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "av_decision_decided_set" "', argument " "2"" of type '" "access_vector_t""'"); +- } +- arg2 = (access_vector_t)(val2); +- if (arg1) (arg1)->decided = arg2; +- +- resultobj = SWIG_Py_Void(); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_av_decision_decided_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct av_decision *arg1 = (struct av_decision *) 0 ; +- access_vector_t result; +- void *argp1 = 0 ; +- int res1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:av_decision_decided_get",&obj0)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_av_decision, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "av_decision_decided_get" "', argument " "1"" of type '" "struct av_decision *""'"); +- } +- arg1 = (struct av_decision *)(argp1); +- result = (access_vector_t) ((arg1)->decided); +- resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_av_decision_auditallow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct av_decision *arg1 = (struct av_decision *) 0 ; +- access_vector_t 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:av_decision_auditallow_set",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_av_decision, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "av_decision_auditallow_set" "', argument " "1"" of type '" "struct av_decision *""'"); +- } +- arg1 = (struct av_decision *)(argp1); +- ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); +- if (!SWIG_IsOK(ecode2)) { +- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "av_decision_auditallow_set" "', argument " "2"" of type '" "access_vector_t""'"); +- } +- arg2 = (access_vector_t)(val2); +- if (arg1) (arg1)->auditallow = arg2; +- +- resultobj = SWIG_Py_Void(); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_av_decision_auditallow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct av_decision *arg1 = (struct av_decision *) 0 ; +- access_vector_t result; +- void *argp1 = 0 ; +- int res1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:av_decision_auditallow_get",&obj0)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_av_decision, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "av_decision_auditallow_get" "', argument " "1"" of type '" "struct av_decision *""'"); +- } +- arg1 = (struct av_decision *)(argp1); +- result = (access_vector_t) ((arg1)->auditallow); +- resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_av_decision_auditdeny_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct av_decision *arg1 = (struct av_decision *) 0 ; +- access_vector_t 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:av_decision_auditdeny_set",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_av_decision, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "av_decision_auditdeny_set" "', argument " "1"" of type '" "struct av_decision *""'"); +- } +- arg1 = (struct av_decision *)(argp1); +- ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); +- if (!SWIG_IsOK(ecode2)) { +- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "av_decision_auditdeny_set" "', argument " "2"" of type '" "access_vector_t""'"); +- } +- arg2 = (access_vector_t)(val2); +- if (arg1) (arg1)->auditdeny = arg2; +- +- resultobj = SWIG_Py_Void(); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_av_decision_auditdeny_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct av_decision *arg1 = (struct av_decision *) 0 ; +- access_vector_t result; +- void *argp1 = 0 ; +- int res1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:av_decision_auditdeny_get",&obj0)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_av_decision, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "av_decision_auditdeny_get" "', argument " "1"" of type '" "struct av_decision *""'"); +- } +- arg1 = (struct av_decision *)(argp1); +- result = (access_vector_t) ((arg1)->auditdeny); +- resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_av_decision_seqno_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct av_decision *arg1 = (struct av_decision *) 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:av_decision_seqno_set",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_av_decision, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "av_decision_seqno_set" "', argument " "1"" of type '" "struct av_decision *""'"); +- } +- arg1 = (struct av_decision *)(argp1); +- ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); +- if (!SWIG_IsOK(ecode2)) { +- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "av_decision_seqno_set" "', argument " "2"" of type '" "unsigned int""'"); +- } +- arg2 = (unsigned int)(val2); +- if (arg1) (arg1)->seqno = arg2; +- +- resultobj = SWIG_Py_Void(); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_av_decision_seqno_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct av_decision *arg1 = (struct av_decision *) 0 ; +- unsigned int result; +- void *argp1 = 0 ; +- int res1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:av_decision_seqno_get",&obj0)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_av_decision, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "av_decision_seqno_get" "', argument " "1"" of type '" "struct av_decision *""'"); +- } +- arg1 = (struct av_decision *)(argp1); +- result = (unsigned int) ((arg1)->seqno); +- resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_new_av_decision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct av_decision *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":new_av_decision")) SWIG_fail; +- result = (struct av_decision *)(struct av_decision *) calloc(1, sizeof(struct av_decision)); +- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_av_decision, SWIG_POINTER_NEW | 0 ); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_delete_av_decision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct av_decision *arg1 = (struct av_decision *) 0 ; +- void *argp1 = 0 ; +- int res1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:delete_av_decision",&obj0)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_av_decision, SWIG_POINTER_DISOWN | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_av_decision" "', argument " "1"" of type '" "struct av_decision *""'"); +- } +- arg1 = (struct av_decision *)(argp1); +- free((char *) arg1); +- +- resultobj = SWIG_Py_Void(); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *av_decision_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *obj; +- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL; +- SWIG_TypeNewClientData(SWIGTYPE_p_av_decision, SWIG_NewClientData(obj)); +- return SWIG_Py_Void(); +-} +- +-SWIGINTERN PyObject *_wrap_selinux_opt_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct selinux_opt *arg1 = (struct selinux_opt *) 0 ; +- int arg2 ; +- void *argp1 = 0 ; +- int res1 = 0 ; +- int val2 ; +- int ecode2 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"OO:selinux_opt_type_set",&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 '" "selinux_opt_type_set" "', argument " "1"" of type '" "struct selinux_opt *""'"); +- } +- arg1 = (struct selinux_opt *)(argp1); +- ecode2 = SWIG_AsVal_int(obj1, &val2); +- if (!SWIG_IsOK(ecode2)) { +- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "selinux_opt_type_set" "', argument " "2"" of type '" "int""'"); +- } +- arg2 = (int)(val2); +- if (arg1) (arg1)->type = arg2; +- +- resultobj = SWIG_Py_Void(); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_opt_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct selinux_opt *arg1 = (struct selinux_opt *) 0 ; +- int result; +- void *argp1 = 0 ; +- int res1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:selinux_opt_type_get",&obj0)) 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 '" "selinux_opt_type_get" "', argument " "1"" of type '" "struct selinux_opt *""'"); +- } +- arg1 = (struct selinux_opt *)(argp1); +- result = (int) ((arg1)->type); +- resultobj = SWIG_From_int((int)(result)); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_opt_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct selinux_opt *arg1 = (struct selinux_opt *) 0 ; +- char *arg2 = (char *) 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:selinux_opt_value_set",&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 '" "selinux_opt_value_set" "', argument " "1"" of type '" "struct selinux_opt *""'"); +- } +- arg1 = (struct selinux_opt *)(argp1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "selinux_opt_value_set" "', argument " "2"" of type '" "char const *""'"); +- } +- arg2 = (char *)(buf2); +- if (arg2) { +- size_t size = strlen((const char *)((const char *)(arg2))) + 1; +- arg1->value = (char const *)(char *)memcpy((char *)malloc((size)*sizeof(char)), arg2, sizeof(char)*(size)); +- } else { +- arg1->value = 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_selinux_opt_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct selinux_opt *arg1 = (struct selinux_opt *) 0 ; +- char *result = 0 ; +- void *argp1 = 0 ; +- int res1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:selinux_opt_value_get",&obj0)) 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 '" "selinux_opt_value_get" "', argument " "1"" of type '" "struct selinux_opt *""'"); +- } +- arg1 = (struct selinux_opt *)(argp1); +- result = (char *) ((arg1)->value); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_new_selinux_opt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct selinux_opt *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":new_selinux_opt")) SWIG_fail; +- result = (struct selinux_opt *)(struct selinux_opt *) calloc(1, sizeof(struct selinux_opt)); +- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_selinux_opt, SWIG_POINTER_NEW | 0 ); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_delete_selinux_opt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct selinux_opt *arg1 = (struct selinux_opt *) 0 ; +- void *argp1 = 0 ; +- int res1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:delete_selinux_opt",&obj0)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_selinux_opt, SWIG_POINTER_DISOWN | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_selinux_opt" "', argument " "1"" of type '" "struct selinux_opt *""'"); +- } +- arg1 = (struct selinux_opt *)(argp1); +- free((char *) arg1); +- +- resultobj = SWIG_Py_Void(); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *selinux_opt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *obj; +- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL; +- SWIG_TypeNewClientData(SWIGTYPE_p_selinux_opt, SWIG_NewClientData(obj)); +- return SWIG_Py_Void(); +-} +- +-SWIGINTERN PyObject *_wrap_selinux_callback_func_log_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- union selinux_callback *arg1 = (union selinux_callback *) 0 ; +- int (*arg2)(int,char const *,...) = (int (*)(int,char const *,...)) 0 ; +- void *argp1 = 0 ; +- int res1 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"OO:selinux_callback_func_log_set",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_selinux_callback, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_callback_func_log_set" "', argument " "1"" of type '" "union selinux_callback *""'"); +- } +- arg1 = (union selinux_callback *)(argp1); +- { +- int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_int_p_q_const__char_v_______int); +- if (!SWIG_IsOK(res)) { +- SWIG_exception_fail(SWIG_ArgError(res), "in method '" "selinux_callback_func_log_set" "', argument " "2"" of type '" "int (*)(int,char const *,...)""'"); +- } +- } +- if (arg1) (arg1)->func_log = arg2; +- +- resultobj = SWIG_Py_Void(); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_callback_func_log_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- union selinux_callback *arg1 = (union selinux_callback *) 0 ; +- int (*result)(int,char const *,...) = 0 ; +- void *argp1 = 0 ; +- int res1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:selinux_callback_func_log_get",&obj0)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_selinux_callback, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_callback_func_log_get" "', argument " "1"" of type '" "union selinux_callback *""'"); +- } +- arg1 = (union selinux_callback *)(argp1); +- result = (int (*)(int,char const *,...)) ((arg1)->func_log); +- resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_int_p_q_const__char_v_______int); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_callback_func_audit_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- union selinux_callback *arg1 = (union selinux_callback *) 0 ; +- int (*arg2)(void *,security_class_t,char *,size_t) = (int (*)(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:selinux_callback_func_audit_set",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_selinux_callback, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_callback_func_audit_set" "', argument " "1"" of type '" "union selinux_callback *""'"); +- } +- arg1 = (union selinux_callback *)(argp1); +- { +- int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_unsigned_short_p_char_size_t__int); +- if (!SWIG_IsOK(res)) { +- SWIG_exception_fail(SWIG_ArgError(res), "in method '" "selinux_callback_func_audit_set" "', argument " "2"" of type '" "int (*)(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_selinux_callback_func_audit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- union selinux_callback *arg1 = (union selinux_callback *) 0 ; +- int (*result)(void *,security_class_t,char *,size_t) = 0 ; +- void *argp1 = 0 ; +- int res1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:selinux_callback_func_audit_get",&obj0)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_selinux_callback, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_callback_func_audit_get" "', argument " "1"" of type '" "union selinux_callback *""'"); +- } +- arg1 = (union selinux_callback *)(argp1); +- result = (int (*)(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__int); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_callback_func_validate_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- union selinux_callback *arg1 = (union selinux_callback *) 0 ; +- int (*arg2)(security_context_t *) = (int (*)(security_context_t *)) 0 ; +- void *argp1 = 0 ; +- int res1 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"OO:selinux_callback_func_validate_set",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_selinux_callback, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_callback_func_validate_set" "', argument " "1"" of type '" "union selinux_callback *""'"); +- } +- arg1 = (union selinux_callback *)(argp1); +- { +- int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_p_char__int); +- if (!SWIG_IsOK(res)) { +- SWIG_exception_fail(SWIG_ArgError(res), "in method '" "selinux_callback_func_validate_set" "', argument " "2"" of type '" "int (*)(security_context_t *)""'"); +- } +- } +- if (arg1) (arg1)->func_validate = arg2; +- +- resultobj = SWIG_Py_Void(); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_callback_func_validate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- union selinux_callback *arg1 = (union selinux_callback *) 0 ; +- int (*result)(security_context_t *) = 0 ; +- void *argp1 = 0 ; +- int res1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:selinux_callback_func_validate_get",&obj0)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_selinux_callback, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_callback_func_validate_get" "', argument " "1"" of type '" "union selinux_callback *""'"); +- } +- arg1 = (union selinux_callback *)(argp1); +- result = (int (*)(security_context_t *)) ((arg1)->func_validate); +- resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_p_char__int); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_new_selinux_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- union selinux_callback *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":new_selinux_callback")) SWIG_fail; +- result = (union selinux_callback *)(union selinux_callback *) calloc(1, sizeof(union selinux_callback)); +- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_selinux_callback, SWIG_POINTER_NEW | 0 ); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_delete_selinux_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- union selinux_callback *arg1 = (union selinux_callback *) 0 ; +- void *argp1 = 0 ; +- int res1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:delete_selinux_callback",&obj0)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_selinux_callback, SWIG_POINTER_DISOWN | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_selinux_callback" "', argument " "1"" of type '" "union selinux_callback *""'"); +- } +- arg1 = (union selinux_callback *)(argp1); +- free((char *) arg1); +- +- resultobj = SWIG_Py_Void(); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *selinux_callback_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *obj; +- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL; +- SWIG_TypeNewClientData(SWIGTYPE_p_selinux_callback, SWIG_NewClientData(obj)); +- return SWIG_Py_Void(); +-} +- +-SWIGINTERN PyObject *_wrap_selinux_set_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- int arg1 ; +- union selinux_callback arg2 ; +- int val1 ; +- int ecode1 = 0 ; +- void *argp2 ; +- int res2 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"OO:selinux_set_callback",&obj0,&obj1)) SWIG_fail; +- ecode1 = SWIG_AsVal_int(obj0, &val1); +- if (!SWIG_IsOK(ecode1)) { +- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "selinux_set_callback" "', argument " "1"" of type '" "int""'"); +- } +- arg1 = (int)(val1); +- { +- res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_selinux_callback, 0 ); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "selinux_set_callback" "', argument " "2"" of type '" "union selinux_callback""'"); +- } +- if (!argp2) { +- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "selinux_set_callback" "', argument " "2"" of type '" "union selinux_callback""'"); +- } else { +- arg2 = *((union selinux_callback *)(argp2)); +- } +- } +- selinux_set_callback(arg1,arg2); +- resultobj = SWIG_Py_Void(); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_compute_av(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- security_context_t arg2 = (security_context_t) 0 ; +- security_class_t arg3 ; +- access_vector_t arg4 ; +- struct av_decision *arg5 = (struct av_decision *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- unsigned short val3 ; +- int ecode3 = 0 ; +- unsigned int val4 ; +- int ecode4 = 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:security_compute_av",&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 '" "security_compute_av" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_av" "', argument " "2"" of type '" "security_context_t""'"); +- } +- arg2 = (security_context_t)(buf2); +- ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); +- if (!SWIG_IsOK(ecode3)) { +- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_av" "', 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 '" "security_compute_av" "', 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 '" "security_compute_av" "', argument " "5"" of type '" "struct av_decision *""'"); +- } +- arg5 = (struct av_decision *)(argp5); +- result = (int)security_compute_av(arg1,arg2,arg3,arg4,arg5); +- resultobj = SWIG_From_int((int)(result)); +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_compute_av_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- security_context_t arg2 = (security_context_t) 0 ; +- security_class_t arg3 ; +- access_vector_t arg4 ; +- struct av_decision *arg5 = (struct av_decision *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- unsigned short val3 ; +- int ecode3 = 0 ; +- unsigned int val4 ; +- int ecode4 = 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:security_compute_av_raw",&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 '" "security_compute_av_raw" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_av_raw" "', argument " "2"" of type '" "security_context_t""'"); +- } +- arg2 = (security_context_t)(buf2); +- ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); +- if (!SWIG_IsOK(ecode3)) { +- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_av_raw" "', 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 '" "security_compute_av_raw" "', 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 '" "security_compute_av_raw" "', argument " "5"" of type '" "struct av_decision *""'"); +- } +- arg5 = (struct av_decision *)(argp5); +- result = (int)security_compute_av_raw(arg1,arg2,arg3,arg4,arg5); +- resultobj = SWIG_From_int((int)(result)); +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_compute_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- security_context_t arg2 = (security_context_t) 0 ; +- security_class_t arg3 ; +- security_context_t *arg4 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- unsigned short val3 ; +- int ecode3 = 0 ; +- security_context_t temp4 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- arg4 = &temp4; +- if (!PyArg_ParseTuple(args,(char *)"OOO:security_compute_create",&obj0,&obj1,&obj2)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_create" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_create" "', argument " "2"" of type '" "security_context_t""'"); +- } +- arg2 = (security_context_t)(buf2); +- ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); +- if (!SWIG_IsOK(ecode3)) { +- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_create" "', argument " "3"" of type '" "security_class_t""'"); +- } +- arg3 = (security_class_t)(val3); +- result = (int)security_compute_create(arg1,arg2,arg3,arg4); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg4) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg4)); +- freecon(*arg4); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_compute_create_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- security_context_t arg2 = (security_context_t) 0 ; +- security_class_t arg3 ; +- security_context_t *arg4 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- unsigned short val3 ; +- int ecode3 = 0 ; +- security_context_t temp4 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- arg4 = &temp4; +- if (!PyArg_ParseTuple(args,(char *)"OOO:security_compute_create_raw",&obj0,&obj1,&obj2)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_create_raw" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_create_raw" "', argument " "2"" of type '" "security_context_t""'"); +- } +- arg2 = (security_context_t)(buf2); +- ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); +- if (!SWIG_IsOK(ecode3)) { +- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_create_raw" "', argument " "3"" of type '" "security_class_t""'"); +- } +- arg3 = (security_class_t)(val3); +- result = (int)security_compute_create_raw(arg1,arg2,arg3,arg4); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg4) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg4)); +- freecon(*arg4); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_compute_relabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- security_context_t arg2 = (security_context_t) 0 ; +- security_class_t arg3 ; +- security_context_t *arg4 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- unsigned short val3 ; +- int ecode3 = 0 ; +- security_context_t temp4 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- arg4 = &temp4; +- if (!PyArg_ParseTuple(args,(char *)"OOO:security_compute_relabel",&obj0,&obj1,&obj2)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_relabel" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_relabel" "', argument " "2"" of type '" "security_context_t""'"); +- } +- arg2 = (security_context_t)(buf2); +- ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); +- if (!SWIG_IsOK(ecode3)) { +- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_relabel" "', argument " "3"" of type '" "security_class_t""'"); +- } +- arg3 = (security_class_t)(val3); +- result = (int)security_compute_relabel(arg1,arg2,arg3,arg4); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg4) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg4)); +- freecon(*arg4); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_compute_relabel_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- security_context_t arg2 = (security_context_t) 0 ; +- security_class_t arg3 ; +- security_context_t *arg4 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- unsigned short val3 ; +- int ecode3 = 0 ; +- security_context_t temp4 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- arg4 = &temp4; +- if (!PyArg_ParseTuple(args,(char *)"OOO:security_compute_relabel_raw",&obj0,&obj1,&obj2)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_relabel_raw" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_relabel_raw" "', argument " "2"" of type '" "security_context_t""'"); +- } +- arg2 = (security_context_t)(buf2); +- ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); +- if (!SWIG_IsOK(ecode3)) { +- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_relabel_raw" "', argument " "3"" of type '" "security_class_t""'"); +- } +- arg3 = (security_class_t)(val3); +- result = (int)security_compute_relabel_raw(arg1,arg2,arg3,arg4); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg4) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg4)); +- freecon(*arg4); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_compute_member(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- security_context_t arg2 = (security_context_t) 0 ; +- security_class_t arg3 ; +- security_context_t *arg4 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- unsigned short val3 ; +- int ecode3 = 0 ; +- security_context_t temp4 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- arg4 = &temp4; +- if (!PyArg_ParseTuple(args,(char *)"OOO:security_compute_member",&obj0,&obj1,&obj2)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_member" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_member" "', argument " "2"" of type '" "security_context_t""'"); +- } +- arg2 = (security_context_t)(buf2); +- ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); +- if (!SWIG_IsOK(ecode3)) { +- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_member" "', argument " "3"" of type '" "security_class_t""'"); +- } +- arg3 = (security_class_t)(val3); +- result = (int)security_compute_member(arg1,arg2,arg3,arg4); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg4) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg4)); +- freecon(*arg4); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_compute_member_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- security_context_t arg2 = (security_context_t) 0 ; +- security_class_t arg3 ; +- security_context_t *arg4 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- unsigned short val3 ; +- int ecode3 = 0 ; +- security_context_t temp4 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- arg4 = &temp4; +- if (!PyArg_ParseTuple(args,(char *)"OOO:security_compute_member_raw",&obj0,&obj1,&obj2)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_member_raw" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_member_raw" "', argument " "2"" of type '" "security_context_t""'"); +- } +- arg2 = (security_context_t)(buf2); +- ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); +- if (!SWIG_IsOK(ecode3)) { +- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_member_raw" "', argument " "3"" of type '" "security_class_t""'"); +- } +- arg3 = (security_class_t)(val3); +- result = (int)security_compute_member_raw(arg1,arg2,arg3,arg4); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg4) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg4)); +- freecon(*arg4); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_compute_user(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- char *arg2 = (char *) 0 ; +- security_context_t **arg3 = (security_context_t **) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- security_context_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if (!PyArg_ParseTuple(args,(char *)"OO:security_compute_user",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_user" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_user" "', argument " "2"" of type '" "char const *""'"); +- } +- arg2 = (char *)(buf2); +- result = (int)security_compute_user(arg1,(char const *)arg2,arg3); +- resultobj = SWIG_From_int((int)(result)); +- { +- PyObject* plist; +- int i, len = 0; +- +- if (*arg3) { +- while((*arg3)[len]) +- len++; +- plist = PyList_New(len); +- for (i = 0; i < len; i++) { +- PyList_SetItem(plist, i, PyString_FromString((*arg3)[i])); +- } +- } else { +- plist = PyList_New(0); +- } +- +- resultobj = SWIG_Python_AppendOutput(resultobj, plist); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- { +- if (*arg3) freeconary(*arg3); +- } +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- { +- if (*arg3) freeconary(*arg3); +- } +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_compute_user_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- char *arg2 = (char *) 0 ; +- security_context_t **arg3 = (security_context_t **) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- security_context_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if (!PyArg_ParseTuple(args,(char *)"OO:security_compute_user_raw",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_user_raw" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_user_raw" "', argument " "2"" of type '" "char const *""'"); +- } +- arg2 = (char *)(buf2); +- result = (int)security_compute_user_raw(arg1,(char const *)arg2,arg3); +- resultobj = SWIG_From_int((int)(result)); +- { +- PyObject* plist; +- int i, len = 0; +- +- if (*arg3) { +- while((*arg3)[len]) +- len++; +- plist = PyList_New(len); +- for (i = 0; i < len; i++) { +- PyList_SetItem(plist, i, PyString_FromString((*arg3)[i])); +- } +- } else { +- plist = PyList_New(0); +- } +- +- resultobj = SWIG_Python_AppendOutput(resultobj, plist); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- { +- if (*arg3) freeconary(*arg3); +- } +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- { +- if (*arg3) freeconary(*arg3); +- } +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_load_policy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- void *arg1 = (void *) 0 ; +- size_t arg2 ; +- int result; +- int res1 ; +- size_t val2 ; +- int ecode2 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"OO:security_load_policy",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_load_policy" "', argument " "1"" of type '" "void *""'"); +- } +- ecode2 = SWIG_AsVal_size_t(obj1, &val2); +- if (!SWIG_IsOK(ecode2)) { +- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "security_load_policy" "', argument " "2"" of type '" "size_t""'"); +- } +- arg2 = (size_t)(val2); +- result = (int)security_load_policy(arg1,arg2); +- resultobj = SWIG_From_int((int)(result)); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_get_initial_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- security_context_t *arg2 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- security_context_t temp2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; +- if (!PyArg_ParseTuple(args,(char *)"O:security_get_initial_context",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_get_initial_context" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- result = (int)security_get_initial_context((char const *)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); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_get_initial_context_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- security_context_t *arg2 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- security_context_t temp2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; +- if (!PyArg_ParseTuple(args,(char *)"O:security_get_initial_context_raw",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_get_initial_context_raw" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- result = (int)security_get_initial_context_raw((char const *)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); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_mkload_policy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- int arg1 ; +- int result; +- int val1 ; +- int ecode1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:selinux_mkload_policy",&obj0)) SWIG_fail; +- ecode1 = SWIG_AsVal_int(obj0, &val1); +- if (!SWIG_IsOK(ecode1)) { +- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "selinux_mkload_policy" "', argument " "1"" of type '" "int""'"); +- } +- arg1 = (int)(val1); +- result = (int)selinux_mkload_policy(arg1); +- resultobj = SWIG_From_int((int)(result)); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_init_load_policy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- int *arg1 = (int *) 0 ; +- int result; +- int temp1 ; +- int res1 = SWIG_TMPOBJ ; +- +- arg1 = &temp1; +- if (!PyArg_ParseTuple(args,(char *)":selinux_init_load_policy")) SWIG_fail; +- result = (int)selinux_init_load_policy(arg1); +- resultobj = SWIG_From_int((int)(result)); +- if (SWIG_IsTmpObj(res1)) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1))); +- } else { +- int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags)); +- } +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_SELboolean_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- SELboolean *arg1 = (SELboolean *) 0 ; +- char *arg2 = (char *) 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:SELboolean_name_set",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SELboolean, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SELboolean_name_set" "', argument " "1"" of type '" "SELboolean *""'"); +- } +- arg1 = (SELboolean *)(argp1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SELboolean_name_set" "', argument " "2"" of type '" "char *""'"); +- } +- arg2 = (char *)(buf2); +- if (arg1->name) free((char*)arg1->name); +- if (arg2) { +- size_t size = strlen((const char *)(arg2)) + 1; +- arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size)); +- } else { +- arg1->name = 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_SELboolean_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- SELboolean *arg1 = (SELboolean *) 0 ; +- char *result = 0 ; +- void *argp1 = 0 ; +- int res1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:SELboolean_name_get",&obj0)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SELboolean, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SELboolean_name_get" "', argument " "1"" of type '" "SELboolean *""'"); +- } +- arg1 = (SELboolean *)(argp1); +- result = (char *) ((arg1)->name); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_SELboolean_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- SELboolean *arg1 = (SELboolean *) 0 ; +- int arg2 ; +- void *argp1 = 0 ; +- int res1 = 0 ; +- int val2 ; +- int ecode2 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"OO:SELboolean_value_set",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SELboolean, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SELboolean_value_set" "', argument " "1"" of type '" "SELboolean *""'"); +- } +- arg1 = (SELboolean *)(argp1); +- ecode2 = SWIG_AsVal_int(obj1, &val2); +- if (!SWIG_IsOK(ecode2)) { +- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SELboolean_value_set" "', argument " "2"" of type '" "int""'"); +- } +- arg2 = (int)(val2); +- if (arg1) (arg1)->value = arg2; +- +- resultobj = SWIG_Py_Void(); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_SELboolean_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- SELboolean *arg1 = (SELboolean *) 0 ; +- int result; +- void *argp1 = 0 ; +- int res1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:SELboolean_value_get",&obj0)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SELboolean, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SELboolean_value_get" "', argument " "1"" of type '" "SELboolean *""'"); +- } +- arg1 = (SELboolean *)(argp1); +- result = (int) ((arg1)->value); +- resultobj = SWIG_From_int((int)(result)); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_new_SELboolean(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- SELboolean *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":new_SELboolean")) SWIG_fail; +- result = (SELboolean *)(SELboolean *) calloc(1, sizeof(SELboolean)); +- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SELboolean, SWIG_POINTER_NEW | 0 ); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_delete_SELboolean(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- SELboolean *arg1 = (SELboolean *) 0 ; +- void *argp1 = 0 ; +- int res1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:delete_SELboolean",&obj0)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SELboolean, SWIG_POINTER_DISOWN | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SELboolean" "', argument " "1"" of type '" "SELboolean *""'"); +- } +- arg1 = (SELboolean *)(argp1); +- free((char *) arg1); +- +- resultobj = SWIG_Py_Void(); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *SELboolean_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *obj; +- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL; +- SWIG_TypeNewClientData(SWIGTYPE_p_SELboolean, SWIG_NewClientData(obj)); +- return SWIG_Py_Void(); +-} +- +-SWIGINTERN PyObject *_wrap_security_set_boolean_list(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- size_t arg1 ; +- SELboolean *arg2 = (SELboolean *) 0 ; +- int arg3 ; +- int result; +- size_t val1 ; +- int ecode1 = 0 ; +- void *argp2 = 0 ; +- int res2 = 0 ; +- int val3 ; +- int ecode3 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"OOO:security_set_boolean_list",&obj0,&obj1,&obj2)) SWIG_fail; +- ecode1 = SWIG_AsVal_size_t(obj0, &val1); +- if (!SWIG_IsOK(ecode1)) { +- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "security_set_boolean_list" "', argument " "1"" of type '" "size_t""'"); +- } +- arg1 = (size_t)(val1); +- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SELboolean, 0 | 0 ); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_set_boolean_list" "', argument " "2"" of type '" "SELboolean *""'"); +- } +- arg2 = (SELboolean *)(argp2); +- ecode3 = SWIG_AsVal_int(obj2, &val3); +- if (!SWIG_IsOK(ecode3)) { +- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_set_boolean_list" "', argument " "3"" of type '" "int""'"); +- } +- arg3 = (int)(val3); +- result = (int)security_set_boolean_list(arg1,arg2,arg3); +- resultobj = SWIG_From_int((int)(result)); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_load_booleans(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:security_load_booleans",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_load_booleans" "', argument " "1"" of type '" "char *""'"); +- } +- arg1 = (char *)(buf1); +- result = (int)security_load_booleans(arg1); +- 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_security_check_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:security_check_context",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_check_context" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- result = (int)security_check_context(arg1); +- 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_security_check_context_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:security_check_context_raw",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_check_context_raw" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- result = (int)security_check_context_raw(arg1); +- 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_security_canonicalize_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- security_context_t *arg2 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- security_context_t temp2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; +- if (!PyArg_ParseTuple(args,(char *)"O:security_canonicalize_context",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_canonicalize_context" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- result = (int)security_canonicalize_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); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_canonicalize_context_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- security_context_t *arg2 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- security_context_t temp2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; +- if (!PyArg_ParseTuple(args,(char *)"O:security_canonicalize_context_raw",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_canonicalize_context_raw" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- result = (int)security_canonicalize_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); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_getenforce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- int result; +- +- if (!PyArg_ParseTuple(args,(char *)":security_getenforce")) SWIG_fail; +- result = (int)security_getenforce(); +- resultobj = SWIG_From_int((int)(result)); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_setenforce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- int arg1 ; +- int result; +- int val1 ; +- int ecode1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:security_setenforce",&obj0)) SWIG_fail; +- ecode1 = SWIG_AsVal_int(obj0, &val1); +- if (!SWIG_IsOK(ecode1)) { +- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "security_setenforce" "', argument " "1"" of type '" "int""'"); +- } +- arg1 = (int)(val1); +- result = (int)security_setenforce(arg1); +- resultobj = SWIG_From_int((int)(result)); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- int result; +- +- if (!PyArg_ParseTuple(args,(char *)":security_disable")) SWIG_fail; +- result = (int)security_disable(); +- resultobj = SWIG_From_int((int)(result)); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_policyvers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- int result; +- +- if (!PyArg_ParseTuple(args,(char *)":security_policyvers")) SWIG_fail; +- result = (int)security_policyvers(); +- resultobj = SWIG_From_int((int)(result)); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_get_boolean_names(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char ***arg1 = (char ***) 0 ; +- int *arg2 = (int *) 0 ; +- int result; +- char **temp11 ; +- int temp21 ; +- +- { +- arg1 = &temp11; +- arg2 = &temp21; +- } +- if (!PyArg_ParseTuple(args,(char *)":security_get_boolean_names")) SWIG_fail; +- result = (int)security_get_boolean_names(arg1,arg2); +- resultobj = SWIG_From_int((int)(result)); +- { +- PyObject* list = PyList_New(*arg2); +- int i; +- for (i = 0; i < *arg2; i++) { +- PyList_SetItem(list, i, PyString_FromString((*arg1)[i])); +- } +- resultobj = SWIG_Python_AppendOutput(resultobj, list); +- } +- { +- int i; +- if (*arg1) { +- for (i = 0; i < *arg2; i++) { +- free((*arg1)[i]); +- } +- free(*arg1); +- } +- } +- return resultobj; +-fail: +- { +- int i; +- if (*arg1) { +- for (i = 0; i < *arg2; i++) { +- free((*arg1)[i]); +- } +- free(*arg1); +- } +- } +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_get_boolean_pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:security_get_boolean_pending",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_get_boolean_pending" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- result = (int)security_get_boolean_pending((char const *)arg1); +- 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_security_get_boolean_active(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:security_get_boolean_active",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_get_boolean_active" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- result = (int)security_get_boolean_active((char const *)arg1); +- 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_security_set_boolean(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- int arg2 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- int val2 ; +- int ecode2 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"OO:security_set_boolean",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_set_boolean" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- ecode2 = SWIG_AsVal_int(obj1, &val2); +- if (!SWIG_IsOK(ecode2)) { +- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "security_set_boolean" "', argument " "2"" of type '" "int""'"); +- } +- arg2 = (int)(val2); +- result = (int)security_set_boolean((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_security_commit_booleans(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- int result; +- +- if (!PyArg_ParseTuple(args,(char *)":security_commit_booleans")) SWIG_fail; +- result = (int)security_commit_booleans(); +- resultobj = SWIG_From_int((int)(result)); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_class_mapping_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct security_class_mapping *arg1 = (struct security_class_mapping *) 0 ; +- char *arg2 = (char *) 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_class_mapping_name_set",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_class_mapping, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_class_mapping_name_set" "', argument " "1"" of type '" "struct security_class_mapping *""'"); +- } +- arg1 = (struct security_class_mapping *)(argp1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_class_mapping_name_set" "', argument " "2"" of type '" "char const *""'"); +- } +- arg2 = (char *)(buf2); +- if (arg2) { +- size_t size = strlen((const char *)((const char *)(arg2))) + 1; +- arg1->name = (char const *)(char *)memcpy((char *)malloc((size)*sizeof(char)), arg2, sizeof(char)*(size)); +- } else { +- arg1->name = 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_class_mapping_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct security_class_mapping *arg1 = (struct security_class_mapping *) 0 ; +- char *result = 0 ; +- void *argp1 = 0 ; +- int res1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:security_class_mapping_name_get",&obj0)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_class_mapping, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_class_mapping_name_get" "', argument " "1"" of type '" "struct security_class_mapping *""'"); +- } +- arg1 = (struct security_class_mapping *)(argp1); +- result = (char *) ((arg1)->name); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_class_mapping_perms_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct security_class_mapping *arg1 = (struct security_class_mapping *) 0 ; +- char **arg2 ; +- void *argp1 = 0 ; +- int res1 = 0 ; +- void *argp2 = 0 ; +- int res2 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"OO:security_class_mapping_perms_set",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_class_mapping, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_class_mapping_perms_set" "', argument " "1"" of type '" "struct security_class_mapping *""'"); +- } +- arg1 = (struct security_class_mapping *)(argp1); +- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_char, 0 | 0 ); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_class_mapping_perms_set" "', argument " "2"" of type '" "char const *[sizeof(access_vector_t)*8+1]""'"); +- } +- arg2 = (char **)(argp2); +- { +- if (arg2) { +- size_t ii = 0; +- for (; ii < (size_t)sizeof(access_vector_t)*8+1; ++ii) arg1->perms[ii] = arg2[ii]; +- } else { +- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""perms""' of type '""char const *[sizeof(access_vector_t)*8+1]""'"); +- } +- } +- resultobj = SWIG_Py_Void(); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_class_mapping_perms_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct security_class_mapping *arg1 = (struct security_class_mapping *) 0 ; +- char **result = 0 ; +- void *argp1 = 0 ; +- int res1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:security_class_mapping_perms_get",&obj0)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_class_mapping, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_class_mapping_perms_get" "', argument " "1"" of type '" "struct security_class_mapping *""'"); +- } +- arg1 = (struct security_class_mapping *)(argp1); +- result = (char **)(char **) ((arg1)->perms); +- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 | 0 ); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_new_security_class_mapping(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct security_class_mapping *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":new_security_class_mapping")) SWIG_fail; +- result = (struct security_class_mapping *)(struct security_class_mapping *) calloc(1, sizeof(struct security_class_mapping)); +- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_security_class_mapping, SWIG_POINTER_NEW | 0 ); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_delete_security_class_mapping(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct security_class_mapping *arg1 = (struct security_class_mapping *) 0 ; +- void *argp1 = 0 ; +- int res1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:delete_security_class_mapping",&obj0)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_class_mapping, SWIG_POINTER_DISOWN | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_security_class_mapping" "', argument " "1"" of type '" "struct security_class_mapping *""'"); +- } +- arg1 = (struct security_class_mapping *)(argp1); +- free((char *) arg1); +- +- resultobj = SWIG_Py_Void(); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *security_class_mapping_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *obj; +- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL; +- SWIG_TypeNewClientData(SWIGTYPE_p_security_class_mapping, SWIG_NewClientData(obj)); +- return SWIG_Py_Void(); +-} +- +-SWIGINTERN PyObject *_wrap_selinux_set_mapping(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- struct security_class_mapping *arg1 = (struct security_class_mapping *) 0 ; +- int result; +- void *argp1 = 0 ; +- int res1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:selinux_set_mapping",&obj0)) SWIG_fail; +- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_class_mapping, 0 | 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_set_mapping" "', argument " "1"" of type '" "struct security_class_mapping *""'"); +- } +- arg1 = (struct security_class_mapping *)(argp1); +- result = (int)selinux_set_mapping(arg1); +- resultobj = SWIG_From_int((int)(result)); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_string_to_security_class(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- security_class_t result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:string_to_security_class",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_to_security_class" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- result = (security_class_t)string_to_security_class((char const *)arg1); +- resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_class_to_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_class_t arg1 ; +- char *result = 0 ; +- unsigned short val1 ; +- int ecode1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:security_class_to_string",&obj0)) SWIG_fail; +- ecode1 = SWIG_AsVal_unsigned_SS_short(obj0, &val1); +- if (!SWIG_IsOK(ecode1)) { +- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "security_class_to_string" "', argument " "1"" of type '" "security_class_t""'"); +- } +- arg1 = (security_class_t)(val1); +- result = (char *)security_class_to_string(arg1); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_av_perm_to_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_class_t arg1 ; +- access_vector_t arg2 ; +- char *result = 0 ; +- unsigned short val1 ; +- int ecode1 = 0 ; +- unsigned int val2 ; +- int ecode2 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"OO:security_av_perm_to_string",&obj0,&obj1)) SWIG_fail; +- ecode1 = SWIG_AsVal_unsigned_SS_short(obj0, &val1); +- if (!SWIG_IsOK(ecode1)) { +- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "security_av_perm_to_string" "', argument " "1"" of type '" "security_class_t""'"); +- } +- arg1 = (security_class_t)(val1); +- ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); +- if (!SWIG_IsOK(ecode2)) { +- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "security_av_perm_to_string" "', argument " "2"" of type '" "access_vector_t""'"); +- } +- arg2 = (access_vector_t)(val2); +- result = (char *)security_av_perm_to_string(arg1,arg2); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_string_to_av_perm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_class_t arg1 ; +- char *arg2 = (char *) 0 ; +- access_vector_t result; +- unsigned short val1 ; +- int ecode1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"OO:string_to_av_perm",&obj0,&obj1)) SWIG_fail; +- ecode1 = SWIG_AsVal_unsigned_SS_short(obj0, &val1); +- if (!SWIG_IsOK(ecode1)) { +- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "string_to_av_perm" "', argument " "1"" of type '" "security_class_t""'"); +- } +- arg1 = (security_class_t)(val1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_to_av_perm" "', argument " "2"" of type '" "char const *""'"); +- } +- arg2 = (char *)(buf2); +- result = (access_vector_t)string_to_av_perm(arg1,(char const *)arg2); +- resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return resultobj; +-fail: +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_security_av_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_class_t arg1 ; +- access_vector_t arg2 ; +- char **arg3 = (char **) 0 ; +- int result; +- unsigned short val1 ; +- int ecode1 = 0 ; +- unsigned int val2 ; +- int ecode2 = 0 ; +- char *temp3 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- arg3 = &temp3; +- if (!PyArg_ParseTuple(args,(char *)"OO:security_av_string",&obj0,&obj1)) SWIG_fail; +- ecode1 = SWIG_AsVal_unsigned_SS_short(obj0, &val1); +- if (!SWIG_IsOK(ecode1)) { +- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "security_av_string" "', argument " "1"" of type '" "security_class_t""'"); +- } +- arg1 = (security_class_t)(val1); +- ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); +- if (!SWIG_IsOK(ecode2)) { +- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "security_av_string" "', argument " "2"" of type '" "access_vector_t""'"); +- } +- arg2 = (access_vector_t)(val2); +- result = (int)security_av_string(arg1,arg2,arg3); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg3) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg3)); +- free(*arg3); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_print_access_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_class_t arg1 ; +- access_vector_t arg2 ; +- unsigned short val1 ; +- int ecode1 = 0 ; +- unsigned int val2 ; +- int ecode2 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"OO:print_access_vector",&obj0,&obj1)) SWIG_fail; +- ecode1 = SWIG_AsVal_unsigned_SS_short(obj0, &val1); +- if (!SWIG_IsOK(ecode1)) { +- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "print_access_vector" "', argument " "1"" of type '" "security_class_t""'"); +- } +- arg1 = (security_class_t)(val1); +- ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); +- if (!SWIG_IsOK(ecode2)) { +- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "print_access_vector" "', argument " "2"" of type '" "access_vector_t""'"); +- } +- arg2 = (access_vector_t)(val2); +- print_access_vector(arg1,arg2); +- resultobj = SWIG_Py_Void(); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_set_matchpathcon_flags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- unsigned int arg1 ; +- unsigned int val1 ; +- int ecode1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:set_matchpathcon_flags",&obj0)) SWIG_fail; +- ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1); +- if (!SWIG_IsOK(ecode1)) { +- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "set_matchpathcon_flags" "', argument " "1"" of type '" "unsigned int""'"); +- } +- arg1 = (unsigned int)(val1); +- set_matchpathcon_flags(arg1); +- resultobj = SWIG_Py_Void(); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_matchpathcon_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:matchpathcon_init",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "matchpathcon_init" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- result = (int)matchpathcon_init((char const *)arg1); +- 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_matchpathcon_init_prefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- char *arg2 = (char *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"OO:matchpathcon_init_prefix",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "matchpathcon_init_prefix" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "matchpathcon_init_prefix" "', argument " "2"" of type '" "char const *""'"); +- } +- arg2 = (char *)(buf2); +- result = (int)matchpathcon_init_prefix((char const *)arg1,(char const *)arg2); +- resultobj = SWIG_From_int((int)(result)); +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_matchpathcon_fini(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- +- if (!PyArg_ParseTuple(args,(char *)":matchpathcon_fini")) SWIG_fail; +- matchpathcon_fini(); +- resultobj = SWIG_Py_Void(); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_matchpathcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- mode_t arg2 ; +- security_context_t *arg3 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- unsigned int val2 ; +- int ecode2 = 0 ; +- security_context_t temp3 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- arg3 = &temp3; +- if (!PyArg_ParseTuple(args,(char *)"OO:matchpathcon",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "matchpathcon" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); +- if (!SWIG_IsOK(ecode2)) { +- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "matchpathcon" "', argument " "2"" of type '" "mode_t""'"); +- } +- arg2 = (mode_t)(val2); +- result = (int)matchpathcon((char const *)arg1,arg2,arg3); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg3) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg3)); +- freecon(*arg3); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_matchpathcon_index(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- mode_t arg2 ; +- security_context_t *arg3 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- unsigned int val2 ; +- int ecode2 = 0 ; +- security_context_t temp3 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- arg3 = &temp3; +- if (!PyArg_ParseTuple(args,(char *)"OO:matchpathcon_index",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "matchpathcon_index" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); +- if (!SWIG_IsOK(ecode2)) { +- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "matchpathcon_index" "', argument " "2"" of type '" "mode_t""'"); +- } +- arg2 = (mode_t)(val2); +- result = (int)matchpathcon_index((char const *)arg1,arg2,arg3); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg3) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg3)); +- freecon(*arg3); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_matchpathcon_filespec_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- ino_t arg1 ; +- int arg2 ; +- char *arg3 = (char *) 0 ; +- int result; +- void *argp1 ; +- int res1 = 0 ; +- int val2 ; +- int ecode2 = 0 ; +- int res3 ; +- char *buf3 = 0 ; +- int alloc3 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"OOO:matchpathcon_filespec_add",&obj0,&obj1,&obj2)) SWIG_fail; +- { +- res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_ino_t, 0 ); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "matchpathcon_filespec_add" "', argument " "1"" of type '" "ino_t""'"); +- } +- if (!argp1) { +- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "matchpathcon_filespec_add" "', argument " "1"" of type '" "ino_t""'"); +- } else { +- arg1 = *((ino_t *)(argp1)); +- } +- } +- ecode2 = SWIG_AsVal_int(obj1, &val2); +- if (!SWIG_IsOK(ecode2)) { +- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "matchpathcon_filespec_add" "', argument " "2"" of type '" "int""'"); +- } +- arg2 = (int)(val2); +- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); +- if (!SWIG_IsOK(res3)) { +- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "matchpathcon_filespec_add" "', argument " "3"" of type '" "char const *""'"); +- } +- arg3 = (char *)(buf3); +- result = (int)matchpathcon_filespec_add(arg1,arg2,(char const *)arg3); +- resultobj = SWIG_From_int((int)(result)); +- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); +- return resultobj; +-fail: +- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_matchpathcon_filespec_destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- +- if (!PyArg_ParseTuple(args,(char *)":matchpathcon_filespec_destroy")) SWIG_fail; +- matchpathcon_filespec_destroy(); +- resultobj = SWIG_Py_Void(); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_matchpathcon_filespec_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- +- if (!PyArg_ParseTuple(args,(char *)":matchpathcon_filespec_eval")) SWIG_fail; +- matchpathcon_filespec_eval(); +- resultobj = SWIG_Py_Void(); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_matchpathcon_checkmatches(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:matchpathcon_checkmatches",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "matchpathcon_checkmatches" "', argument " "1"" of type '" "char *""'"); +- } +- arg1 = (char *)(buf1); +- matchpathcon_checkmatches(arg1); +- resultobj = SWIG_Py_Void(); +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_matchmediacon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- security_context_t *arg2 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- security_context_t temp2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; +- if (!PyArg_ParseTuple(args,(char *)"O:matchmediacon",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "matchmediacon" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- result = (int)matchmediacon((char const *)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); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_getenforcemode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- int *arg1 = (int *) 0 ; +- int result; +- int temp1 ; +- int res1 = SWIG_TMPOBJ ; +- +- arg1 = &temp1; +- if (!PyArg_ParseTuple(args,(char *)":selinux_getenforcemode")) SWIG_fail; +- result = (int)selinux_getenforcemode(arg1); +- resultobj = SWIG_From_int((int)(result)); +- if (SWIG_IsTmpObj(res1)) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1))); +- } else { +- int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ; +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags)); +- } +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_getpolicytype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char **arg1 = (char **) 0 ; +- int result; +- char *temp1 = 0 ; +- +- arg1 = &temp1; +- if (!PyArg_ParseTuple(args,(char *)":selinux_getpolicytype")) SWIG_fail; +- result = (int)selinux_getpolicytype(arg1); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg1) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1)); +- free(*arg1); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_policy_root(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":selinux_policy_root")) SWIG_fail; +- result = (char *)selinux_policy_root(); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_binary_policy_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":selinux_binary_policy_path")) SWIG_fail; +- result = (char *)selinux_binary_policy_path(); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_failsafe_context_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":selinux_failsafe_context_path")) SWIG_fail; +- result = (char *)selinux_failsafe_context_path(); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_removable_context_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":selinux_removable_context_path")) SWIG_fail; +- result = (char *)selinux_removable_context_path(); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_default_context_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":selinux_default_context_path")) SWIG_fail; +- result = (char *)selinux_default_context_path(); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_user_contexts_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":selinux_user_contexts_path")) SWIG_fail; +- result = (char *)selinux_user_contexts_path(); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_file_context_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":selinux_file_context_path")) SWIG_fail; +- result = (char *)selinux_file_context_path(); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_file_context_homedir_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":selinux_file_context_homedir_path")) SWIG_fail; +- result = (char *)selinux_file_context_homedir_path(); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_file_context_local_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":selinux_file_context_local_path")) SWIG_fail; +- result = (char *)selinux_file_context_local_path(); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_homedir_context_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":selinux_homedir_context_path")) SWIG_fail; +- result = (char *)selinux_homedir_context_path(); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_media_context_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":selinux_media_context_path")) SWIG_fail; +- result = (char *)selinux_media_context_path(); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_x_context_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":selinux_x_context_path")) SWIG_fail; +- result = (char *)selinux_x_context_path(); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_contexts_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":selinux_contexts_path")) SWIG_fail; +- result = (char *)selinux_contexts_path(); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_securetty_types_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":selinux_securetty_types_path")) SWIG_fail; +- result = (char *)selinux_securetty_types_path(); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_booleans_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":selinux_booleans_path")) SWIG_fail; +- result = (char *)selinux_booleans_path(); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_customizable_types_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":selinux_customizable_types_path")) SWIG_fail; +- result = (char *)selinux_customizable_types_path(); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_users_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":selinux_users_path")) SWIG_fail; +- result = (char *)selinux_users_path(); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_usersconf_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":selinux_usersconf_path")) SWIG_fail; +- result = (char *)selinux_usersconf_path(); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_translations_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":selinux_translations_path")) SWIG_fail; +- result = (char *)selinux_translations_path(); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_netfilter_context_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":selinux_netfilter_context_path")) SWIG_fail; +- result = (char *)selinux_netfilter_context_path(); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":selinux_path")) SWIG_fail; +- result = (char *)selinux_path(); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_check_passwd_access(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- access_vector_t arg1 ; +- int result; +- unsigned int val1 ; +- int ecode1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:selinux_check_passwd_access",&obj0)) SWIG_fail; +- ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1); +- if (!SWIG_IsOK(ecode1)) { +- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "selinux_check_passwd_access" "', argument " "1"" of type '" "access_vector_t""'"); +- } +- arg1 = (access_vector_t)(val1); +- result = (int)selinux_check_passwd_access(arg1); +- resultobj = SWIG_From_int((int)(result)); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_checkPasswdAccess(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- access_vector_t arg1 ; +- int result; +- unsigned int val1 ; +- int ecode1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:checkPasswdAccess",&obj0)) SWIG_fail; +- ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1); +- if (!SWIG_IsOK(ecode1)) { +- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "checkPasswdAccess" "', argument " "1"" of type '" "access_vector_t""'"); +- } +- arg1 = (access_vector_t)(val1); +- result = (int)checkPasswdAccess(arg1); +- resultobj = SWIG_From_int((int)(result)); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_check_securetty_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:selinux_check_securetty_context",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_check_securetty_context" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- result = (int)selinux_check_securetty_context(arg1); +- 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_set_selinuxmnt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:set_selinuxmnt",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_selinuxmnt" "', argument " "1"" of type '" "char *""'"); +- } +- arg1 = (char *)(buf1); +- set_selinuxmnt(arg1); +- resultobj = SWIG_Py_Void(); +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_rpm_execcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- unsigned int arg1 ; +- char *arg2 = (char *) 0 ; +- char **arg3 ; +- char **arg4 ; +- int result; +- unsigned int val1 ; +- int ecode1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- PyObject * obj3 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"OOOO:rpm_execcon",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; +- ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1); +- if (!SWIG_IsOK(ecode1)) { +- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "rpm_execcon" "', argument " "1"" of type '" "unsigned int""'"); +- } +- arg1 = (unsigned int)(val1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rpm_execcon" "', argument " "2"" of type '" "char const *""'"); +- } +- arg2 = (char *)(buf2); +- { +- int i, size; +- PyObject * s; +- +- if (!PySequence_Check(obj2)) { +- PyErr_SetString(PyExc_ValueError, "Expected a sequence"); +- return NULL; +- } +- +- size = PySequence_Size(obj2); +- +- arg3 = (char**) malloc(size + 1); +- +- for(i = 0; i < size; i++) { +- if (!PyString_Check(PySequence_GetItem(obj2, i))) { +- PyErr_SetString(PyExc_ValueError, "Sequence must contain only strings"); +- return NULL; +- } +- } +- +- for(i = 0; i < size; i++) { +- s = PySequence_GetItem(obj2, i); +- arg3[i] = (char*) malloc(PyString_Size(s) + 1); +- strcpy(arg3[i], PyString_AsString(s)); +- } +- arg3[size] = NULL; +- } +- { +- int i, size; +- PyObject * s; +- +- if (!PySequence_Check(obj3)) { +- PyErr_SetString(PyExc_ValueError, "Expected a sequence"); +- return NULL; +- } +- +- size = PySequence_Size(obj3); +- +- arg4 = (char**) malloc(size + 1); +- +- for(i = 0; i < size; i++) { +- if (!PyString_Check(PySequence_GetItem(obj3, i))) { +- PyErr_SetString(PyExc_ValueError, "Sequence must contain only strings"); +- return NULL; +- } +- } +- +- for(i = 0; i < size; i++) { +- s = PySequence_GetItem(obj3, i); +- arg4[i] = (char*) malloc(PyString_Size(s) + 1); +- strcpy(arg4[i], PyString_AsString(s)); +- } +- arg4[size] = NULL; +- } +- result = (int)rpm_execcon(arg1,(char const *)arg2,(char *const (*))arg3,(char *const (*))arg4); +- resultobj = SWIG_From_int((int)(result)); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- { +- int i = 0; +- while(arg3[i]) { +- free(arg3[i]); +- i++; +- } +- free(arg3); +- } +- { +- int i = 0; +- while(arg4[i]) { +- free(arg4[i]); +- i++; +- } +- free(arg4); +- } +- return resultobj; +-fail: +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- { +- int i = 0; +- while(arg3[i]) { +- free(arg3[i]); +- i++; +- } +- free(arg3); +- } +- { +- int i = 0; +- while(arg4[i]) { +- free(arg4[i]); +- i++; +- } +- free(arg4); +- } +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_is_context_customizable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:is_context_customizable",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_context_customizable" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- result = (int)is_context_customizable(arg1); +- 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_selinux_trans_to_raw_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- security_context_t *arg2 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- security_context_t temp2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; +- if (!PyArg_ParseTuple(args,(char *)"O:selinux_trans_to_raw_context",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_trans_to_raw_context" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- result = (int)selinux_trans_to_raw_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); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_raw_to_trans_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) 0 ; +- security_context_t *arg2 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- security_context_t temp2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; +- if (!PyArg_ParseTuple(args,(char *)"O:selinux_raw_to_trans_context",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_raw_to_trans_context" "', argument " "1"" of type '" "security_context_t""'"); +- } +- arg1 = (security_context_t)(buf1); +- result = (int)selinux_raw_to_trans_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); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_getseuserbyname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- char **arg2 = (char **) 0 ; +- char **arg3 = (char **) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- char *temp2 = 0 ; +- char *temp3 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; +- arg3 = &temp3; +- if (!PyArg_ParseTuple(args,(char *)"O:getseuserbyname",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getseuserbyname" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- result = (int)getseuserbyname((char const *)arg1,arg2,arg3); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg2) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg2)); +- free(*arg2); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- if (*arg3) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg3)); +- free(*arg3); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_file_context_cmp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t arg1 = (security_context_t) (security_context_t)0 ; +- security_context_t arg2 = (security_context_t) (security_context_t)0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"OO:selinux_file_context_cmp",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_file_context_cmp" "', argument " "1"" of type '" "security_context_t const""'"); +- } +- arg1 = (security_context_t)(buf1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "selinux_file_context_cmp" "', argument " "2"" of type '" "security_context_t const""'"); +- } +- arg2 = (security_context_t)(buf2); +- result = (int)selinux_file_context_cmp(arg1,arg2); +- resultobj = SWIG_From_int((int)(result)); +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_selinux_file_context_verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- mode_t arg2 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- unsigned int val2 ; +- int ecode2 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"OO:selinux_file_context_verify",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_file_context_verify" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); +- if (!SWIG_IsOK(ecode2)) { +- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "selinux_file_context_verify" "', argument " "2"" of type '" "mode_t""'"); +- } +- arg2 = (mode_t)(val2); +- result = (int)selinux_file_context_verify((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_selinux_lsetfilecon_default(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- PyObject * obj0 = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)"O:selinux_lsetfilecon_default",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_lsetfilecon_default" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- result = (int)selinux_lsetfilecon_default((char const *)arg1); +- 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_selinux_default_type_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *result = 0 ; +- +- if (!PyArg_ParseTuple(args,(char *)":selinux_default_type_path")) SWIG_fail; +- result = (char *)selinux_default_type_path(); +- resultobj = SWIG_FromCharPtr((const char *)result); +- return resultobj; +-fail: +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_get_default_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- char **arg2 = (char **) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- char *temp2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; +- if (!PyArg_ParseTuple(args,(char *)"O:get_default_type",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_default_type" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- result = (int)get_default_type((char const *)arg1,arg2); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg2) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg2)); +- free(*arg2); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_get_ordered_context_list(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- security_context_t arg2 = (security_context_t) 0 ; +- security_context_t **arg3 = (security_context_t **) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- security_context_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if (!PyArg_ParseTuple(args,(char *)"OO:get_ordered_context_list",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_ordered_context_list" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_ordered_context_list" "', argument " "2"" of type '" "security_context_t""'"); +- } +- arg2 = (security_context_t)(buf2); +- result = (int)get_ordered_context_list((char const *)arg1,arg2,arg3); +- resultobj = SWIG_From_int((int)(result)); +- { +- PyObject* plist; +- int i; +- +- if (*arg3) { +- plist = PyList_New(result); +- for (i = 0; i < result; i++) { +- PyList_SetItem(plist, i, PyString_FromString((*arg3)[i])); +- } +- } else { +- plist = PyList_New(0); +- } +- /* Only return the Python list, don't need to return the length anymore */ +- resultobj = plist; +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- { +- if (*arg3) freeconary(*arg3); +- } +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- { +- if (*arg3) freeconary(*arg3); +- } +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_get_ordered_context_list_with_level(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- char *arg2 = (char *) 0 ; +- security_context_t arg3 = (security_context_t) 0 ; +- security_context_t **arg4 = (security_context_t **) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- int res3 ; +- char *buf3 = 0 ; +- int alloc3 = 0 ; +- security_context_t *temp4 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- { +- arg4 = &temp4; +- } +- if (!PyArg_ParseTuple(args,(char *)"OOO:get_ordered_context_list_with_level",&obj0,&obj1,&obj2)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_ordered_context_list_with_level" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_ordered_context_list_with_level" "', argument " "2"" of type '" "char const *""'"); +- } +- arg2 = (char *)(buf2); +- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); +- if (!SWIG_IsOK(res3)) { +- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "get_ordered_context_list_with_level" "', argument " "3"" of type '" "security_context_t""'"); +- } +- arg3 = (security_context_t)(buf3); +- result = (int)get_ordered_context_list_with_level((char const *)arg1,(char const *)arg2,arg3,arg4); +- resultobj = SWIG_From_int((int)(result)); +- { +- PyObject* plist; +- int i; +- +- if (*arg4) { +- plist = PyList_New(result); +- for (i = 0; i < result; i++) { +- PyList_SetItem(plist, i, PyString_FromString((*arg4)[i])); +- } +- } else { +- plist = PyList_New(0); +- } +- /* Only return the Python list, don't need to return the length anymore */ +- resultobj = plist; +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); +- { +- if (*arg4) freeconary(*arg4); +- } +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); +- { +- if (*arg4) freeconary(*arg4); +- } +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_get_default_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- security_context_t arg2 = (security_context_t) 0 ; +- security_context_t *arg3 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- security_context_t temp3 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- arg3 = &temp3; +- if (!PyArg_ParseTuple(args,(char *)"OO:get_default_context",&obj0,&obj1)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_default_context" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_default_context" "', argument " "2"" of type '" "security_context_t""'"); +- } +- arg2 = (security_context_t)(buf2); +- result = (int)get_default_context((char const *)arg1,arg2,arg3); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg3) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg3)); +- freecon(*arg3); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_get_default_context_with_level(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- char *arg2 = (char *) 0 ; +- security_context_t arg3 = (security_context_t) 0 ; +- security_context_t *arg4 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- int res3 ; +- char *buf3 = 0 ; +- int alloc3 = 0 ; +- security_context_t temp4 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- arg4 = &temp4; +- if (!PyArg_ParseTuple(args,(char *)"OOO:get_default_context_with_level",&obj0,&obj1,&obj2)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_default_context_with_level" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_default_context_with_level" "', argument " "2"" of type '" "char const *""'"); +- } +- arg2 = (char *)(buf2); +- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); +- if (!SWIG_IsOK(res3)) { +- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "get_default_context_with_level" "', argument " "3"" of type '" "security_context_t""'"); +- } +- arg3 = (security_context_t)(buf3); +- result = (int)get_default_context_with_level((char const *)arg1,(char const *)arg2,arg3,arg4); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg4) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg4)); +- freecon(*arg4); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_get_default_context_with_role(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- char *arg2 = (char *) 0 ; +- security_context_t arg3 = (security_context_t) 0 ; +- security_context_t *arg4 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- int res3 ; +- char *buf3 = 0 ; +- int alloc3 = 0 ; +- security_context_t temp4 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- arg4 = &temp4; +- if (!PyArg_ParseTuple(args,(char *)"OOO:get_default_context_with_role",&obj0,&obj1,&obj2)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_default_context_with_role" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_default_context_with_role" "', argument " "2"" of type '" "char const *""'"); +- } +- arg2 = (char *)(buf2); +- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); +- if (!SWIG_IsOK(res3)) { +- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "get_default_context_with_role" "', argument " "3"" of type '" "security_context_t""'"); +- } +- arg3 = (security_context_t)(buf3); +- result = (int)get_default_context_with_role((char const *)arg1,(char const *)arg2,arg3,arg4); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg4) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg4)); +- freecon(*arg4); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_get_default_context_with_rolelevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- char *arg2 = (char *) 0 ; +- char *arg3 = (char *) 0 ; +- security_context_t arg4 = (security_context_t) 0 ; +- security_context_t *arg5 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- int res2 ; +- char *buf2 = 0 ; +- int alloc2 = 0 ; +- int res3 ; +- char *buf3 = 0 ; +- int alloc3 = 0 ; +- int res4 ; +- char *buf4 = 0 ; +- int alloc4 = 0 ; +- security_context_t temp5 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- PyObject * obj3 = 0 ; +- +- arg5 = &temp5; +- if (!PyArg_ParseTuple(args,(char *)"OOOO:get_default_context_with_rolelevel",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_default_context_with_rolelevel" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); +- if (!SWIG_IsOK(res2)) { +- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_default_context_with_rolelevel" "', argument " "2"" of type '" "char const *""'"); +- } +- arg2 = (char *)(buf2); +- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); +- if (!SWIG_IsOK(res3)) { +- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "get_default_context_with_rolelevel" "', argument " "3"" of type '" "char const *""'"); +- } +- arg3 = (char *)(buf3); +- res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4); +- if (!SWIG_IsOK(res4)) { +- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "get_default_context_with_rolelevel" "', argument " "4"" of type '" "security_context_t""'"); +- } +- arg4 = (security_context_t)(buf4); +- result = (int)get_default_context_with_rolelevel((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg5) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg5)); +- freecon(*arg5); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); +- if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); +- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); +- if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); +- return NULL; +-} +- +- +-SWIGINTERN PyObject *_wrap_query_user_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- security_context_t *arg1 = (security_context_t *) 0 ; +- security_context_t *arg2 = (security_context_t *) 0 ; +- int result; +- security_context_t temp1 = 0 ; +- security_context_t temp2 = 0 ; +- +- arg1 = &temp1; +- arg2 = &temp2; +- if (!PyArg_ParseTuple(args,(char *)":query_user_context")) SWIG_fail; +- result = (int)query_user_context(arg1,arg2); +- resultobj = SWIG_From_int((int)(result)); +- if (*arg1) { +- resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1)); +- freecon(*arg1); +- } +- else { +- Py_INCREF(Py_None); +- resultobj = SWIG_Python_AppendOutput(resultobj, Py_None); +- } +- 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_manual_user_enter_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +- PyObject *resultobj = 0; +- char *arg1 = (char *) 0 ; +- security_context_t *arg2 = (security_context_t *) 0 ; +- int result; +- int res1 ; +- char *buf1 = 0 ; +- int alloc1 = 0 ; +- security_context_t temp2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; +- if (!PyArg_ParseTuple(args,(char *)"O:manual_user_enter_context",&obj0)) SWIG_fail; +- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); +- if (!SWIG_IsOK(res1)) { +- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "manual_user_enter_context" "', argument " "1"" of type '" "char const *""'"); +- } +- arg1 = (char *)(buf1); +- result = (int)manual_user_enter_context((char const *)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); +- } +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return resultobj; +-fail: +- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); +- return NULL; +-} +- +- +-static PyMethodDef SwigMethods[] = { +- { (char *)"is_selinux_enabled", _wrap_is_selinux_enabled, METH_VARARGS, NULL}, +- { (char *)"is_selinux_mls_enabled", _wrap_is_selinux_mls_enabled, METH_VARARGS, NULL}, +- { (char *)"getcon", _wrap_getcon, METH_VARARGS, NULL}, +- { (char *)"getcon_raw", _wrap_getcon_raw, METH_VARARGS, NULL}, +- { (char *)"setcon", _wrap_setcon, METH_VARARGS, NULL}, +- { (char *)"setcon_raw", _wrap_setcon_raw, METH_VARARGS, NULL}, +- { (char *)"getpidcon", _wrap_getpidcon, METH_VARARGS, NULL}, +- { (char *)"getpidcon_raw", _wrap_getpidcon_raw, METH_VARARGS, NULL}, +- { (char *)"getprevcon", _wrap_getprevcon, METH_VARARGS, NULL}, +- { (char *)"getprevcon_raw", _wrap_getprevcon_raw, METH_VARARGS, NULL}, +- { (char *)"getexeccon", _wrap_getexeccon, METH_VARARGS, NULL}, +- { (char *)"getexeccon_raw", _wrap_getexeccon_raw, METH_VARARGS, NULL}, +- { (char *)"setexeccon", _wrap_setexeccon, METH_VARARGS, NULL}, +- { (char *)"setexeccon_raw", _wrap_setexeccon_raw, METH_VARARGS, NULL}, +- { (char *)"getfscreatecon", _wrap_getfscreatecon, METH_VARARGS, NULL}, +- { (char *)"getfscreatecon_raw", _wrap_getfscreatecon_raw, METH_VARARGS, NULL}, +- { (char *)"setfscreatecon", _wrap_setfscreatecon, METH_VARARGS, NULL}, +- { (char *)"setfscreatecon_raw", _wrap_setfscreatecon_raw, METH_VARARGS, NULL}, +- { (char *)"getkeycreatecon", _wrap_getkeycreatecon, METH_VARARGS, NULL}, +- { (char *)"getkeycreatecon_raw", _wrap_getkeycreatecon_raw, METH_VARARGS, NULL}, +- { (char *)"setkeycreatecon", _wrap_setkeycreatecon, METH_VARARGS, NULL}, +- { (char *)"setkeycreatecon_raw", _wrap_setkeycreatecon_raw, METH_VARARGS, NULL}, +- { (char *)"getsockcreatecon", _wrap_getsockcreatecon, METH_VARARGS, NULL}, +- { (char *)"getsockcreatecon_raw", _wrap_getsockcreatecon_raw, METH_VARARGS, NULL}, +- { (char *)"setsockcreatecon", _wrap_setsockcreatecon, METH_VARARGS, NULL}, +- { (char *)"setsockcreatecon_raw", _wrap_setsockcreatecon_raw, METH_VARARGS, NULL}, +- { (char *)"getfilecon", _wrap_getfilecon, METH_VARARGS, NULL}, +- { (char *)"getfilecon_raw", _wrap_getfilecon_raw, METH_VARARGS, NULL}, +- { (char *)"lgetfilecon", _wrap_lgetfilecon, METH_VARARGS, NULL}, +- { (char *)"lgetfilecon_raw", _wrap_lgetfilecon_raw, METH_VARARGS, NULL}, +- { (char *)"fgetfilecon", _wrap_fgetfilecon, METH_VARARGS, NULL}, +- { (char *)"fgetfilecon_raw", _wrap_fgetfilecon_raw, METH_VARARGS, NULL}, +- { (char *)"setfilecon", _wrap_setfilecon, METH_VARARGS, NULL}, +- { (char *)"setfilecon_raw", _wrap_setfilecon_raw, METH_VARARGS, NULL}, +- { (char *)"lsetfilecon", _wrap_lsetfilecon, METH_VARARGS, NULL}, +- { (char *)"lsetfilecon_raw", _wrap_lsetfilecon_raw, METH_VARARGS, NULL}, +- { (char *)"fsetfilecon", _wrap_fsetfilecon, METH_VARARGS, NULL}, +- { (char *)"fsetfilecon_raw", _wrap_fsetfilecon_raw, METH_VARARGS, NULL}, +- { (char *)"getpeercon", _wrap_getpeercon, METH_VARARGS, NULL}, +- { (char *)"getpeercon_raw", _wrap_getpeercon_raw, METH_VARARGS, NULL}, +- { (char *)"av_decision_allowed_set", _wrap_av_decision_allowed_set, METH_VARARGS, NULL}, +- { (char *)"av_decision_allowed_get", _wrap_av_decision_allowed_get, METH_VARARGS, NULL}, +- { (char *)"av_decision_decided_set", _wrap_av_decision_decided_set, METH_VARARGS, NULL}, +- { (char *)"av_decision_decided_get", _wrap_av_decision_decided_get, METH_VARARGS, NULL}, +- { (char *)"av_decision_auditallow_set", _wrap_av_decision_auditallow_set, METH_VARARGS, NULL}, +- { (char *)"av_decision_auditallow_get", _wrap_av_decision_auditallow_get, METH_VARARGS, NULL}, +- { (char *)"av_decision_auditdeny_set", _wrap_av_decision_auditdeny_set, METH_VARARGS, NULL}, +- { (char *)"av_decision_auditdeny_get", _wrap_av_decision_auditdeny_get, METH_VARARGS, NULL}, +- { (char *)"av_decision_seqno_set", _wrap_av_decision_seqno_set, METH_VARARGS, NULL}, +- { (char *)"av_decision_seqno_get", _wrap_av_decision_seqno_get, METH_VARARGS, NULL}, +- { (char *)"new_av_decision", _wrap_new_av_decision, METH_VARARGS, NULL}, +- { (char *)"delete_av_decision", _wrap_delete_av_decision, METH_VARARGS, NULL}, +- { (char *)"av_decision_swigregister", av_decision_swigregister, METH_VARARGS, NULL}, +- { (char *)"selinux_opt_type_set", _wrap_selinux_opt_type_set, METH_VARARGS, NULL}, +- { (char *)"selinux_opt_type_get", _wrap_selinux_opt_type_get, METH_VARARGS, NULL}, +- { (char *)"selinux_opt_value_set", _wrap_selinux_opt_value_set, METH_VARARGS, NULL}, +- { (char *)"selinux_opt_value_get", _wrap_selinux_opt_value_get, METH_VARARGS, NULL}, +- { (char *)"new_selinux_opt", _wrap_new_selinux_opt, METH_VARARGS, NULL}, +- { (char *)"delete_selinux_opt", _wrap_delete_selinux_opt, METH_VARARGS, NULL}, +- { (char *)"selinux_opt_swigregister", selinux_opt_swigregister, METH_VARARGS, NULL}, +- { (char *)"selinux_callback_func_log_set", _wrap_selinux_callback_func_log_set, METH_VARARGS, NULL}, +- { (char *)"selinux_callback_func_log_get", _wrap_selinux_callback_func_log_get, METH_VARARGS, NULL}, +- { (char *)"selinux_callback_func_audit_set", _wrap_selinux_callback_func_audit_set, METH_VARARGS, NULL}, +- { (char *)"selinux_callback_func_audit_get", _wrap_selinux_callback_func_audit_get, METH_VARARGS, NULL}, +- { (char *)"selinux_callback_func_validate_set", _wrap_selinux_callback_func_validate_set, METH_VARARGS, NULL}, +- { (char *)"selinux_callback_func_validate_get", _wrap_selinux_callback_func_validate_get, METH_VARARGS, NULL}, +- { (char *)"new_selinux_callback", _wrap_new_selinux_callback, METH_VARARGS, NULL}, +- { (char *)"delete_selinux_callback", _wrap_delete_selinux_callback, METH_VARARGS, NULL}, +- { (char *)"selinux_callback_swigregister", selinux_callback_swigregister, METH_VARARGS, NULL}, +- { (char *)"selinux_set_callback", _wrap_selinux_set_callback, METH_VARARGS, NULL}, +- { (char *)"security_compute_av", _wrap_security_compute_av, METH_VARARGS, NULL}, +- { (char *)"security_compute_av_raw", _wrap_security_compute_av_raw, METH_VARARGS, NULL}, +- { (char *)"security_compute_create", _wrap_security_compute_create, METH_VARARGS, NULL}, +- { (char *)"security_compute_create_raw", _wrap_security_compute_create_raw, METH_VARARGS, NULL}, +- { (char *)"security_compute_relabel", _wrap_security_compute_relabel, METH_VARARGS, NULL}, +- { (char *)"security_compute_relabel_raw", _wrap_security_compute_relabel_raw, METH_VARARGS, NULL}, +- { (char *)"security_compute_member", _wrap_security_compute_member, METH_VARARGS, NULL}, +- { (char *)"security_compute_member_raw", _wrap_security_compute_member_raw, METH_VARARGS, NULL}, +- { (char *)"security_compute_user", _wrap_security_compute_user, METH_VARARGS, NULL}, +- { (char *)"security_compute_user_raw", _wrap_security_compute_user_raw, METH_VARARGS, NULL}, +- { (char *)"security_load_policy", _wrap_security_load_policy, METH_VARARGS, NULL}, +- { (char *)"security_get_initial_context", _wrap_security_get_initial_context, METH_VARARGS, NULL}, +- { (char *)"security_get_initial_context_raw", _wrap_security_get_initial_context_raw, METH_VARARGS, NULL}, +- { (char *)"selinux_mkload_policy", _wrap_selinux_mkload_policy, METH_VARARGS, NULL}, +- { (char *)"selinux_init_load_policy", _wrap_selinux_init_load_policy, METH_VARARGS, NULL}, +- { (char *)"SELboolean_name_set", _wrap_SELboolean_name_set, METH_VARARGS, NULL}, +- { (char *)"SELboolean_name_get", _wrap_SELboolean_name_get, METH_VARARGS, NULL}, +- { (char *)"SELboolean_value_set", _wrap_SELboolean_value_set, METH_VARARGS, NULL}, +- { (char *)"SELboolean_value_get", _wrap_SELboolean_value_get, METH_VARARGS, NULL}, +- { (char *)"new_SELboolean", _wrap_new_SELboolean, METH_VARARGS, NULL}, +- { (char *)"delete_SELboolean", _wrap_delete_SELboolean, METH_VARARGS, NULL}, +- { (char *)"SELboolean_swigregister", SELboolean_swigregister, METH_VARARGS, NULL}, +- { (char *)"security_set_boolean_list", _wrap_security_set_boolean_list, METH_VARARGS, NULL}, +- { (char *)"security_load_booleans", _wrap_security_load_booleans, METH_VARARGS, NULL}, +- { (char *)"security_check_context", _wrap_security_check_context, METH_VARARGS, NULL}, +- { (char *)"security_check_context_raw", _wrap_security_check_context_raw, METH_VARARGS, NULL}, +- { (char *)"security_canonicalize_context", _wrap_security_canonicalize_context, METH_VARARGS, NULL}, +- { (char *)"security_canonicalize_context_raw", _wrap_security_canonicalize_context_raw, METH_VARARGS, NULL}, +- { (char *)"security_getenforce", _wrap_security_getenforce, METH_VARARGS, NULL}, +- { (char *)"security_setenforce", _wrap_security_setenforce, METH_VARARGS, NULL}, +- { (char *)"security_disable", _wrap_security_disable, METH_VARARGS, NULL}, +- { (char *)"security_policyvers", _wrap_security_policyvers, METH_VARARGS, NULL}, +- { (char *)"security_get_boolean_names", _wrap_security_get_boolean_names, METH_VARARGS, NULL}, +- { (char *)"security_get_boolean_pending", _wrap_security_get_boolean_pending, METH_VARARGS, NULL}, +- { (char *)"security_get_boolean_active", _wrap_security_get_boolean_active, METH_VARARGS, NULL}, +- { (char *)"security_set_boolean", _wrap_security_set_boolean, METH_VARARGS, NULL}, +- { (char *)"security_commit_booleans", _wrap_security_commit_booleans, METH_VARARGS, NULL}, +- { (char *)"security_class_mapping_name_set", _wrap_security_class_mapping_name_set, METH_VARARGS, NULL}, +- { (char *)"security_class_mapping_name_get", _wrap_security_class_mapping_name_get, METH_VARARGS, NULL}, +- { (char *)"security_class_mapping_perms_set", _wrap_security_class_mapping_perms_set, METH_VARARGS, NULL}, +- { (char *)"security_class_mapping_perms_get", _wrap_security_class_mapping_perms_get, METH_VARARGS, NULL}, +- { (char *)"new_security_class_mapping", _wrap_new_security_class_mapping, METH_VARARGS, NULL}, +- { (char *)"delete_security_class_mapping", _wrap_delete_security_class_mapping, METH_VARARGS, NULL}, +- { (char *)"security_class_mapping_swigregister", security_class_mapping_swigregister, METH_VARARGS, NULL}, +- { (char *)"selinux_set_mapping", _wrap_selinux_set_mapping, METH_VARARGS, NULL}, +- { (char *)"string_to_security_class", _wrap_string_to_security_class, METH_VARARGS, NULL}, +- { (char *)"security_class_to_string", _wrap_security_class_to_string, METH_VARARGS, NULL}, +- { (char *)"security_av_perm_to_string", _wrap_security_av_perm_to_string, METH_VARARGS, NULL}, +- { (char *)"string_to_av_perm", _wrap_string_to_av_perm, METH_VARARGS, NULL}, +- { (char *)"security_av_string", _wrap_security_av_string, METH_VARARGS, NULL}, +- { (char *)"print_access_vector", _wrap_print_access_vector, METH_VARARGS, NULL}, +- { (char *)"set_matchpathcon_flags", _wrap_set_matchpathcon_flags, METH_VARARGS, NULL}, +- { (char *)"matchpathcon_init", _wrap_matchpathcon_init, METH_VARARGS, NULL}, +- { (char *)"matchpathcon_init_prefix", _wrap_matchpathcon_init_prefix, METH_VARARGS, NULL}, +- { (char *)"matchpathcon_fini", _wrap_matchpathcon_fini, METH_VARARGS, NULL}, +- { (char *)"matchpathcon", _wrap_matchpathcon, METH_VARARGS, NULL}, +- { (char *)"matchpathcon_index", _wrap_matchpathcon_index, METH_VARARGS, NULL}, +- { (char *)"matchpathcon_filespec_add", _wrap_matchpathcon_filespec_add, METH_VARARGS, NULL}, +- { (char *)"matchpathcon_filespec_destroy", _wrap_matchpathcon_filespec_destroy, METH_VARARGS, NULL}, +- { (char *)"matchpathcon_filespec_eval", _wrap_matchpathcon_filespec_eval, METH_VARARGS, NULL}, +- { (char *)"matchpathcon_checkmatches", _wrap_matchpathcon_checkmatches, METH_VARARGS, NULL}, +- { (char *)"matchmediacon", _wrap_matchmediacon, METH_VARARGS, NULL}, +- { (char *)"selinux_getenforcemode", _wrap_selinux_getenforcemode, METH_VARARGS, NULL}, +- { (char *)"selinux_getpolicytype", _wrap_selinux_getpolicytype, METH_VARARGS, NULL}, +- { (char *)"selinux_policy_root", _wrap_selinux_policy_root, METH_VARARGS, NULL}, +- { (char *)"selinux_binary_policy_path", _wrap_selinux_binary_policy_path, METH_VARARGS, NULL}, +- { (char *)"selinux_failsafe_context_path", _wrap_selinux_failsafe_context_path, METH_VARARGS, NULL}, +- { (char *)"selinux_removable_context_path", _wrap_selinux_removable_context_path, METH_VARARGS, NULL}, +- { (char *)"selinux_default_context_path", _wrap_selinux_default_context_path, METH_VARARGS, NULL}, +- { (char *)"selinux_user_contexts_path", _wrap_selinux_user_contexts_path, METH_VARARGS, NULL}, +- { (char *)"selinux_file_context_path", _wrap_selinux_file_context_path, METH_VARARGS, NULL}, +- { (char *)"selinux_file_context_homedir_path", _wrap_selinux_file_context_homedir_path, METH_VARARGS, NULL}, +- { (char *)"selinux_file_context_local_path", _wrap_selinux_file_context_local_path, METH_VARARGS, NULL}, +- { (char *)"selinux_homedir_context_path", _wrap_selinux_homedir_context_path, METH_VARARGS, NULL}, +- { (char *)"selinux_media_context_path", _wrap_selinux_media_context_path, METH_VARARGS, NULL}, +- { (char *)"selinux_x_context_path", _wrap_selinux_x_context_path, METH_VARARGS, NULL}, +- { (char *)"selinux_contexts_path", _wrap_selinux_contexts_path, METH_VARARGS, NULL}, +- { (char *)"selinux_securetty_types_path", _wrap_selinux_securetty_types_path, METH_VARARGS, NULL}, +- { (char *)"selinux_booleans_path", _wrap_selinux_booleans_path, METH_VARARGS, NULL}, +- { (char *)"selinux_customizable_types_path", _wrap_selinux_customizable_types_path, METH_VARARGS, NULL}, +- { (char *)"selinux_users_path", _wrap_selinux_users_path, METH_VARARGS, NULL}, +- { (char *)"selinux_usersconf_path", _wrap_selinux_usersconf_path, METH_VARARGS, NULL}, +- { (char *)"selinux_translations_path", _wrap_selinux_translations_path, METH_VARARGS, NULL}, +- { (char *)"selinux_netfilter_context_path", _wrap_selinux_netfilter_context_path, METH_VARARGS, NULL}, +- { (char *)"selinux_path", _wrap_selinux_path, METH_VARARGS, NULL}, +- { (char *)"selinux_check_passwd_access", _wrap_selinux_check_passwd_access, METH_VARARGS, NULL}, +- { (char *)"checkPasswdAccess", _wrap_checkPasswdAccess, METH_VARARGS, NULL}, +- { (char *)"selinux_check_securetty_context", _wrap_selinux_check_securetty_context, METH_VARARGS, NULL}, +- { (char *)"set_selinuxmnt", _wrap_set_selinuxmnt, METH_VARARGS, NULL}, +- { (char *)"rpm_execcon", _wrap_rpm_execcon, METH_VARARGS, NULL}, +- { (char *)"is_context_customizable", _wrap_is_context_customizable, METH_VARARGS, NULL}, +- { (char *)"selinux_trans_to_raw_context", _wrap_selinux_trans_to_raw_context, METH_VARARGS, NULL}, +- { (char *)"selinux_raw_to_trans_context", _wrap_selinux_raw_to_trans_context, METH_VARARGS, NULL}, +- { (char *)"getseuserbyname", _wrap_getseuserbyname, METH_VARARGS, NULL}, +- { (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 *)"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}, +- { (char *)"get_ordered_context_list_with_level", _wrap_get_ordered_context_list_with_level, METH_VARARGS, NULL}, +- { (char *)"get_default_context", _wrap_get_default_context, METH_VARARGS, NULL}, +- { (char *)"get_default_context_with_level", _wrap_get_default_context_with_level, METH_VARARGS, NULL}, +- { (char *)"get_default_context_with_role", _wrap_get_default_context_with_role, METH_VARARGS, NULL}, +- { (char *)"get_default_context_with_rolelevel", _wrap_get_default_context_with_rolelevel, METH_VARARGS, NULL}, +- { (char *)"query_user_context", _wrap_query_user_context, METH_VARARGS, NULL}, +- { (char *)"manual_user_enter_context", _wrap_manual_user_enter_context, METH_VARARGS, NULL}, +- { NULL, NULL, 0, NULL } +-}; +- +- +-/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ +- +-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 *", 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_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_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_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_pid_t = {"_p_pid_t", "pid_t *", 0, 0, (void*)0, 0}; +-static swig_type_info _swigt__p_security_class_mapping = {"_p_security_class_mapping", "struct security_class_mapping *", 0, 0, (void*)0, 0}; +-static swig_type_info _swigt__p_selinux_callback = {"_p_selinux_callback", "union selinux_callback *", 0, 0, (void*)0, 0}; +-static swig_type_info _swigt__p_selinux_opt = {"_p_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 *", 0, 0, (void*)0, 0}; +-static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|security_class_t *", 0, 0, (void*)0, 0}; +- +-static swig_type_info *swig_type_initial[] = { +- &_swigt__p_SELboolean, +- &_swigt__p_av_decision, +- &_swigt__p_char, +- &_swigt__p_f_int_p_q_const__char_v_______int, +- &_swigt__p_f_p_p_char__int, +- &_swigt__p_f_p_void_unsigned_short_p_char_size_t__int, +- &_swigt__p_ino_t, +- &_swigt__p_int, +- &_swigt__p_p_char, +- &_swigt__p_p_p_char, +- &_swigt__p_pid_t, +- &_swigt__p_security_class_mapping, +- &_swigt__p_selinux_callback, +- &_swigt__p_selinux_opt, +- &_swigt__p_unsigned_int, +- &_swigt__p_unsigned_short, +-}; +- +-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_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_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_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_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_pid_t[] = { {&_swigt__p_pid_t, 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_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}}; +-static swig_cast_info _swigc__p_unsigned_short[] = { {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}}; +- +-static swig_cast_info *swig_cast_initial[] = { +- _swigc__p_SELboolean, +- _swigc__p_av_decision, +- _swigc__p_char, +- _swigc__p_f_int_p_q_const__char_v_______int, +- _swigc__p_f_p_p_char__int, +- _swigc__p_f_p_void_unsigned_short_p_char_size_t__int, +- _swigc__p_ino_t, +- _swigc__p_int, +- _swigc__p_p_char, +- _swigc__p_p_p_char, +- _swigc__p_pid_t, +- _swigc__p_security_class_mapping, +- _swigc__p_selinux_callback, +- _swigc__p_selinux_opt, +- _swigc__p_unsigned_int, +- _swigc__p_unsigned_short, +-}; +- +- +-/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ +- +-static swig_const_info swig_const_table[] = { +-{0, 0, 0, 0.0, 0, 0}}; +- +-#ifdef __cplusplus +-} +-#endif +-/* ----------------------------------------------------------------------------- +- * Type initialization: +- * This problem is tough by the requirement that no dynamic +- * memory is used. Also, since swig_type_info structures store pointers to +- * swig_cast_info structures and swig_cast_info structures store pointers back +- * to swig_type_info structures, we need some lookup code at initialization. +- * The idea is that swig generates all the structures that are needed. +- * The runtime then collects these partially filled structures. +- * The SWIG_InitializeModule function takes these initial arrays out of +- * swig_module, and does all the lookup, filling in the swig_module.types +- * array with the correct data and linking the correct swig_cast_info +- * structures together. +- * +- * The generated swig_type_info structures are assigned staticly to an initial +- * array. We just loop through that array, and handle each type individually. +- * First we lookup if this type has been already loaded, and if so, use the +- * loaded structure instead of the generated one. Then we have to fill in the +- * cast linked list. The cast data is initially stored in something like a +- * two-dimensional array. Each row corresponds to a type (there are the same +- * number of rows as there are in the swig_type_initial array). Each entry in +- * a column is one of the swig_cast_info structures for that type. +- * The cast_initial array is actually an array of arrays, because each row has +- * a variable number of columns. So to actually build the cast linked list, +- * we find the array of casts associated with the type, and loop through it +- * adding the casts to the list. The one last trick we need to do is making +- * sure the type pointer in the swig_cast_info struct is correct. +- * +- * First off, we lookup the cast->type name to see if it is already loaded. +- * There are three cases to handle: +- * 1) If the cast->type has already been loaded AND the type we are adding +- * casting info to has not been loaded (it is in this module), THEN we +- * replace the cast->type pointer with the type pointer that has already +- * been loaded. +- * 2) If BOTH types (the one we are adding casting info to, and the +- * cast->type) are loaded, THEN the cast info has already been loaded by +- * the previous module so we just ignore it. +- * 3) Finally, if cast->type has not already been loaded, then we add that +- * swig_cast_info to the linked list (because the cast->type) pointer will +- * be correct. +- * ----------------------------------------------------------------------------- */ +- +-#ifdef __cplusplus +-extern "C" { +-#if 0 +-} /* c-mode */ +-#endif +-#endif +- +-#if 0 +-#define SWIGRUNTIME_DEBUG +-#endif +- +- +-SWIGRUNTIME void +-SWIG_InitializeModule(void *clientdata) { +- size_t i; +- swig_module_info *module_head, *iter; +- int found; +- +- clientdata = clientdata; +- +- /* check to see if the circular list has been setup, if not, set it up */ +- if (swig_module.next==0) { +- /* Initialize the swig_module */ +- swig_module.type_initial = swig_type_initial; +- swig_module.cast_initial = swig_cast_initial; +- swig_module.next = &swig_module; +- } +- +- /* Try and load any already created modules */ +- module_head = SWIG_GetModule(clientdata); +- if (!module_head) { +- /* This is the first module loaded for this interpreter */ +- /* so set the swig module into the interpreter */ +- SWIG_SetModule(clientdata, &swig_module); +- module_head = &swig_module; +- } else { +- /* the interpreter has loaded a SWIG module, but has it loaded this one? */ +- found=0; +- iter=module_head; +- do { +- if (iter==&swig_module) { +- found=1; +- break; +- } +- iter=iter->next; +- } while (iter!= module_head); +- +- /* if the is found in the list, then all is done and we may leave */ +- if (found) return; +- /* otherwise we must add out module into the list */ +- swig_module.next = module_head->next; +- module_head->next = &swig_module; +- } +- +- /* Now work on filling in swig_module.types */ +-#ifdef SWIGRUNTIME_DEBUG +- printf("SWIG_InitializeModule: size %d\n", swig_module.size); +-#endif +- for (i = 0; i < swig_module.size; ++i) { +- swig_type_info *type = 0; +- swig_type_info *ret; +- swig_cast_info *cast; +- +-#ifdef SWIGRUNTIME_DEBUG +- printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); +-#endif +- +- /* if there is another module already loaded */ +- if (swig_module.next != &swig_module) { +- type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); +- } +- if (type) { +- /* Overwrite clientdata field */ +-#ifdef SWIGRUNTIME_DEBUG +- printf("SWIG_InitializeModule: found type %s\n", type->name); +-#endif +- if (swig_module.type_initial[i]->clientdata) { +- type->clientdata = swig_module.type_initial[i]->clientdata; +-#ifdef SWIGRUNTIME_DEBUG +- printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); +-#endif +- } +- } else { +- type = swig_module.type_initial[i]; +- } +- +- /* Insert casting types */ +- cast = swig_module.cast_initial[i]; +- while (cast->type) { +- /* Don't need to add information already in the list */ +- ret = 0; +-#ifdef SWIGRUNTIME_DEBUG +- printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); +-#endif +- if (swig_module.next != &swig_module) { +- ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); +-#ifdef SWIGRUNTIME_DEBUG +- if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); +-#endif +- } +- if (ret) { +- if (type == swig_module.type_initial[i]) { +-#ifdef SWIGRUNTIME_DEBUG +- printf("SWIG_InitializeModule: skip old type %s\n", ret->name); +-#endif +- cast->type = ret; +- ret = 0; +- } else { +- /* Check for casting already in the list */ +- swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); +-#ifdef SWIGRUNTIME_DEBUG +- if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); +-#endif +- if (!ocast) ret = 0; +- } +- } +- +- if (!ret) { +-#ifdef SWIGRUNTIME_DEBUG +- printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); +-#endif +- if (type->cast) { +- type->cast->prev = cast; +- cast->next = type->cast; +- } +- type->cast = cast; +- } +- cast++; +- } +- /* Set entry in modules->types array equal to the type */ +- swig_module.types[i] = type; +- } +- swig_module.types[i] = 0; +- +-#ifdef SWIGRUNTIME_DEBUG +- printf("**** SWIG_InitializeModule: Cast List ******\n"); +- for (i = 0; i < swig_module.size; ++i) { +- int j = 0; +- swig_cast_info *cast = swig_module.cast_initial[i]; +- printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); +- while (cast->type) { +- printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); +- cast++; +- ++j; +- } +- printf("---- Total casts: %d\n",j); +- } +- printf("**** SWIG_InitializeModule: Cast List ******\n"); +-#endif +-} +- +-/* This function will propagate the clientdata field of type to +-* any new swig_type_info structures that have been added into the list +-* of equivalent types. It is like calling +-* SWIG_TypeClientData(type, clientdata) a second time. +-*/ +-SWIGRUNTIME void +-SWIG_PropagateClientData(void) { +- size_t i; +- swig_cast_info *equiv; +- static int init_run = 0; +- +- if (init_run) return; +- init_run = 1; +- +- for (i = 0; i < swig_module.size; i++) { +- if (swig_module.types[i]->clientdata) { +- equiv = swig_module.types[i]->cast; +- while (equiv) { +- if (!equiv->converter) { +- if (equiv->type && !equiv->type->clientdata) +- SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); +- } +- equiv = equiv->next; +- } +- } +- } +-} +- +-#ifdef __cplusplus +-#if 0 +-{ +- /* c-mode */ +-#endif +-} +-#endif +- +- +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +- /* Python-specific SWIG API */ +-#define SWIG_newvarlink() SWIG_Python_newvarlink() +-#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) +-#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) +- +- /* ----------------------------------------------------------------------------- +- * global variable support code. +- * ----------------------------------------------------------------------------- */ +- +- typedef struct swig_globalvar { +- char *name; /* Name of global variable */ +- PyObject *(*get_attr)(void); /* Return the current value */ +- int (*set_attr)(PyObject *); /* Set the value */ +- struct swig_globalvar *next; +- } swig_globalvar; +- +- typedef struct swig_varlinkobject { +- PyObject_HEAD +- swig_globalvar *vars; +- } swig_varlinkobject; +- +- SWIGINTERN PyObject * +- swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) { +- return PyString_FromString(""); +- } +- +- SWIGINTERN PyObject * +- swig_varlink_str(swig_varlinkobject *v) { +- PyObject *str = PyString_FromString("("); +- swig_globalvar *var; +- for (var = v->vars; var; var=var->next) { +- PyString_ConcatAndDel(&str,PyString_FromString(var->name)); +- if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", ")); +- } +- PyString_ConcatAndDel(&str,PyString_FromString(")")); +- return str; +- } +- +- SWIGINTERN int +- swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) { +- PyObject *str = swig_varlink_str(v); +- fprintf(fp,"Swig global variables "); +- fprintf(fp,"%s\n", PyString_AsString(str)); +- Py_DECREF(str); +- return 0; +- } +- +- SWIGINTERN void +- swig_varlink_dealloc(swig_varlinkobject *v) { +- swig_globalvar *var = v->vars; +- while (var) { +- swig_globalvar *n = var->next; +- free(var->name); +- free(var); +- var = n; +- } +- } +- +- SWIGINTERN PyObject * +- swig_varlink_getattr(swig_varlinkobject *v, char *n) { +- PyObject *res = NULL; +- swig_globalvar *var = v->vars; +- while (var) { +- if (strcmp(var->name,n) == 0) { +- res = (*var->get_attr)(); +- break; +- } +- var = var->next; +- } +- if (res == NULL && !PyErr_Occurred()) { +- PyErr_SetString(PyExc_NameError,"Unknown C global variable"); +- } +- return res; +- } +- +- SWIGINTERN int +- swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { +- int res = 1; +- swig_globalvar *var = v->vars; +- while (var) { +- if (strcmp(var->name,n) == 0) { +- res = (*var->set_attr)(p); +- break; +- } +- var = var->next; +- } +- if (res == 1 && !PyErr_Occurred()) { +- PyErr_SetString(PyExc_NameError,"Unknown C global variable"); +- } +- return res; +- } +- +- SWIGINTERN PyTypeObject* +- swig_varlink_type(void) { +- static char varlink__doc__[] = "Swig var link object"; +- static PyTypeObject varlink_type; +- static int type_init = 0; +- if (!type_init) { +- const PyTypeObject tmp +- = { +- PyObject_HEAD_INIT(NULL) +- 0, /* Number of items in variable part (ob_size) */ +- (char *)"swigvarlink", /* Type name (tp_name) */ +- sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */ +- 0, /* Itemsize (tp_itemsize) */ +- (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */ +- (printfunc) swig_varlink_print, /* Print (tp_print) */ +- (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */ +- (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */ +- 0, /* tp_compare */ +- (reprfunc) swig_varlink_repr, /* tp_repr */ +- 0, /* tp_as_number */ +- 0, /* tp_as_sequence */ +- 0, /* tp_as_mapping */ +- 0, /* tp_hash */ +- 0, /* tp_call */ +- (reprfunc)swig_varlink_str, /* tp_str */ +- 0, /* tp_getattro */ +- 0, /* tp_setattro */ +- 0, /* tp_as_buffer */ +- 0, /* tp_flags */ +- varlink__doc__, /* tp_doc */ +- 0, /* tp_traverse */ +- 0, /* tp_clear */ +- 0, /* tp_richcompare */ +- 0, /* tp_weaklistoffset */ +-#if PY_VERSION_HEX >= 0x02020000 +- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ +-#endif +-#if PY_VERSION_HEX >= 0x02030000 +- 0, /* tp_del */ +-#endif +-#ifdef COUNT_ALLOCS +- 0,0,0,0 /* tp_alloc -> tp_next */ +-#endif +- }; +- varlink_type = tmp; +- varlink_type.ob_type = &PyType_Type; +- type_init = 1; +- } +- return &varlink_type; +- } +- +- /* Create a variable linking object for use later */ +- SWIGINTERN PyObject * +- SWIG_Python_newvarlink(void) { +- swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type()); +- if (result) { +- result->vars = 0; +- } +- return ((PyObject*) result); +- } +- +- SWIGINTERN void +- SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { +- swig_varlinkobject *v = (swig_varlinkobject *) p; +- swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); +- if (gv) { +- size_t size = strlen(name)+1; +- gv->name = (char *)malloc(size); +- if (gv->name) { +- strncpy(gv->name,name,size); +- gv->get_attr = get_attr; +- gv->set_attr = set_attr; +- gv->next = v->vars; +- } +- } +- v->vars = gv; +- } +- +- SWIGINTERN PyObject * +- SWIG_globals(void) { +- static PyObject *_SWIG_globals = 0; +- if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink(); +- return _SWIG_globals; +- } +- +- /* ----------------------------------------------------------------------------- +- * constants/methods manipulation +- * ----------------------------------------------------------------------------- */ +- +- /* Install Constants */ +- SWIGINTERN void +- SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) { +- PyObject *obj = 0; +- size_t i; +- for (i = 0; constants[i].type; ++i) { +- switch(constants[i].type) { +- case SWIG_PY_POINTER: +- obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0); +- break; +- case SWIG_PY_BINARY: +- obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); +- break; +- default: +- obj = 0; +- break; +- } +- if (obj) { +- PyDict_SetItemString(d, constants[i].name, obj); +- Py_DECREF(obj); +- } +- } +- } +- +- /* -----------------------------------------------------------------------------*/ +- /* Fix SwigMethods to carry the callback ptrs when needed */ +- /* -----------------------------------------------------------------------------*/ +- +- SWIGINTERN void +- SWIG_Python_FixMethods(PyMethodDef *methods, +- swig_const_info *const_table, +- swig_type_info **types, +- swig_type_info **types_initial) { +- size_t i; +- for (i = 0; methods[i].ml_name; ++i) { +- const char *c = methods[i].ml_doc; +- if (c && (c = strstr(c, "swig_ptr: "))) { +- int j; +- swig_const_info *ci = 0; +- const char *name = c + 10; +- for (j = 0; const_table[j].type; ++j) { +- if (strncmp(const_table[j].name, name, +- strlen(const_table[j].name)) == 0) { +- ci = &(const_table[j]); +- break; +- } +- } +- if (ci) { +- size_t shift = (ci->ptype) - types; +- swig_type_info *ty = types_initial[shift]; +- size_t ldoc = (c - methods[i].ml_doc); +- size_t lptr = strlen(ty->name)+2*sizeof(void*)+2; +- char *ndoc = (char*)malloc(ldoc + lptr + 10); +- if (ndoc) { +- char *buff = ndoc; +- void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0; +- if (ptr) { +- strncpy(buff, methods[i].ml_doc, ldoc); +- buff += ldoc; +- strncpy(buff, "swig_ptr: ", 10); +- buff += 10; +- SWIG_PackVoidPtr(buff, ptr, ty->name, lptr); +- methods[i].ml_doc = ndoc; +- } +- } +- } +- } +- } +- } +- +-#ifdef __cplusplus +-} +-#endif +- +-/* -----------------------------------------------------------------------------* +- * Partial Init method +- * -----------------------------------------------------------------------------*/ +- +-#ifdef __cplusplus +-extern "C" +-#endif +-SWIGEXPORT void SWIG_init(void) { +- PyObject *m, *d; +- +- /* Fix SwigMethods to carry the callback ptrs when needed */ +- SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial); +- +- m = Py_InitModule((char *) SWIG_name, SwigMethods); +- d = PyModule_GetDict(m); +- +- SWIG_InitializeModule(0); +- SWIG_InstallConstants(d,swig_const_table); +- +- +- SWIG_Python_SetConstant(d, "SELINUX_CB_LOG",SWIG_From_int((int)(0))); +- SWIG_Python_SetConstant(d, "SELINUX_CB_AUDIT",SWIG_From_int((int)(1))); +- SWIG_Python_SetConstant(d, "SELINUX_CB_VALIDATE",SWIG_From_int((int)(2))); +- SWIG_Python_SetConstant(d, "SELINUX_ERROR",SWIG_From_int((int)(0))); +- SWIG_Python_SetConstant(d, "SELINUX_WARNING",SWIG_From_int((int)(1))); +- SWIG_Python_SetConstant(d, "SELINUX_INFO",SWIG_From_int((int)(2))); +- SWIG_Python_SetConstant(d, "SELINUX_AVC",SWIG_From_int((int)(3))); +- 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, "SELINUX_DEFAULTUSER",SWIG_FromCharPtr("user_u")); +-} +- +diff --exclude-from=exclude -N -u -r nsalibselinux/utils/matchpathcon.c libselinux-2.0.35/utils/matchpathcon.c --- nsalibselinux/utils/matchpathcon.c 2007-07-16 14:20:45.000000000 -0400 -+++ libselinux-2.0.34/utils/matchpathcon.c 2007-09-18 16:32:31.000000000 -0400 ++++ libselinux-2.0.35/utils/matchpathcon.c 2007-09-27 10:22:29.000000000 -0400 @@ -17,10 +17,24 @@ exit(1); } diff --git a/libselinux.spec b/libselinux.spec index 7eec55f..41eac4e 100644 --- a/libselinux.spec +++ b/libselinux.spec @@ -2,7 +2,7 @@ Summary: SELinux library and simple utilities Name: libselinux Version: 2.0.35 -Release: 1%{?dist} +Release: 2%{?dist} License: Public domain (uncopyrighted) Group: System Environment/Libraries Source: http://www.nsa.gov/selinux/archives/%{name}-%{version}.tgz @@ -123,6 +123,9 @@ exit 0 %{_libdir}/python*/site-packages/selinux.py* %changelog +* Thu Sep 27 2007 Dan Walsh - 2.0.35-2 +- Fix segfault on missing file_context file + * Wed Sep 26 2007 Dan Walsh - 2.0.35-1 - Upgrade to upstream * Make netlink socket close-on-exec to avoid descriptor leakage from Dan Walsh.