From 3652b31671265d94014b90d5025be0de348e86a0 Mon Sep 17 00:00:00 2001 From: Daniel J Walsh Date: Mon, 8 Jun 2009 19:05:19 +0000 Subject: [PATCH] - Update to upstream Ruby bindings from David Quigley. --- .cvsignore | 1 + libsemanage-rhat.patch | 6024 +++++++++++++++++++++++++++++++++++++++- libsemanage.spec | 8 +- sources | 2 +- 4 files changed, 6027 insertions(+), 8 deletions(-) diff --git a/.cvsignore b/.cvsignore index 31a2e72..50ed183 100644 --- a/.cvsignore +++ b/.cvsignore @@ -105,3 +105,4 @@ libsemanage-2.0.28.tgz libsemanage-2.0.29.tgz libsemanage-2.0.30.tgz libsemanage-2.0.31.tgz +libsemanage-2.0.32.tgz diff --git a/libsemanage-rhat.patch b/libsemanage-rhat.patch index 3ef4579..937000a 100644 --- a/libsemanage-rhat.patch +++ b/libsemanage-rhat.patch @@ -1,6 +1,6 @@ diff --exclude-from=exclude -N -u -r nsalibsemanage/src/direct_api.c libsemanage-2.0.31/src/direct_api.c --- nsalibsemanage/src/direct_api.c 2009-01-13 08:45:35.000000000 -0500 -+++ libsemanage-2.0.31/src/direct_api.c 2009-04-09 11:49:42.000000000 -0400 ++++ libsemanage-2.0.31/src/direct_api.c 2009-06-02 14:54:20.000000000 -0400 @@ -991,7 +991,7 @@ int retval = -1; @@ -57,7 +57,7 @@ diff --exclude-from=exclude -N -u -r nsalibsemanage/src/direct_api.c libsemanage diff --exclude-from=exclude -N -u -r nsalibsemanage/src/genhomedircon.c libsemanage-2.0.31/src/genhomedircon.c --- nsalibsemanage/src/genhomedircon.c 2008-08-28 09:34:24.000000000 -0400 -+++ libsemanage-2.0.31/src/genhomedircon.c 2009-03-26 14:55:01.000000000 -0400 ++++ libsemanage-2.0.31/src/genhomedircon.c 2009-06-02 14:54:20.000000000 -0400 @@ -794,6 +794,12 @@ * /root */ continue; @@ -73,7 +73,7 @@ diff --exclude-from=exclude -N -u -r nsalibsemanage/src/genhomedircon.c libseman *errors = STATUS_ERR; diff --exclude-from=exclude -N -u -r nsalibsemanage/src/handle.c libsemanage-2.0.31/src/handle.c --- nsalibsemanage/src/handle.c 2008-11-14 17:10:15.000000000 -0500 -+++ libsemanage-2.0.31/src/handle.c 2009-03-26 14:55:01.000000000 -0400 ++++ libsemanage-2.0.31/src/handle.c 2009-06-02 14:54:20.000000000 -0400 @@ -264,7 +264,7 @@ assert(sh != NULL && sh->funcs != NULL && sh->funcs->commit != NULL); if (!sh->is_in_transaction) { @@ -85,16 +85,1110 @@ diff --exclude-from=exclude -N -u -r nsalibsemanage/src/handle.c libsemanage-2.0 retval = sh->funcs->commit(sh); diff --exclude-from=exclude -N -u -r nsalibsemanage/src/semanage.conf libsemanage-2.0.31/src/semanage.conf --- nsalibsemanage/src/semanage.conf 2008-08-28 09:34:24.000000000 -0400 -+++ libsemanage-2.0.31/src/semanage.conf 2009-03-26 14:55:01.000000000 -0400 ++++ libsemanage-2.0.31/src/semanage.conf 2009-06-02 14:54:20.000000000 -0400 @@ -35,4 +35,4 @@ # given in . Change this setting if a different # version is necessary. #policy-version = 19 - +expand-check=0 +diff --exclude-from=exclude -N -u -r nsalibsemanage/src/semanage.py libsemanage-2.0.31/src/semanage.py +--- nsalibsemanage/src/semanage.py 2009-01-13 08:45:35.000000000 -0500 ++++ libsemanage-2.0.31/src/semanage.py 2009-06-02 14:59:55.000000000 -0400 +@@ -1,12 +1,32 @@ + # This file was automatically generated by SWIG (http://www.swig.org). +-# Version 1.3.35 ++# Version 1.3.39 + # +-# Don't modify this file, modify the SWIG interface instead. ++# Do not make changes to this file unless you know what you are doing--modify ++# the SWIG interface file instead. + # This file is compatible with both classic and new-style classes. + +-import _semanage +-import new +-new_instancemethod = new.instancemethod ++from sys import version_info ++if version_info >= (2,6,0): ++ def swig_import_helper(): ++ from os.path import dirname ++ import imp ++ fp = None ++ try: ++ fp, pathname, description = imp.find_module('_semanage', [dirname(__file__)]) ++ except ImportError: ++ import _semanage ++ return _semanage ++ if fp is not None: ++ try: ++ _mod = imp.load_module('_semanage', fp, pathname, description) ++ finally: ++ fp.close() ++ return _mod ++ _semanage = swig_import_helper() ++ del swig_import_helper ++else: ++ import _semanage ++del version_info + try: + _swig_property = property + except NameError: +@@ -14,7 +34,7 @@ + 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': ++ if type(value).__name__ == 'SwigPyObject': + self.__dict__[name] = value + return + method = class_type.__swig_setmethods__.get(name,None) +@@ -31,204 +51,715 @@ + if (name == "thisown"): return self.this.own() + method = class_type.__swig_getmethods__.get(name,None) + if method: return method(self) +- raise AttributeError,name ++ 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 ++ _object = object + _newclass = 1 + except AttributeError: + class _object : pass + _newclass = 0 +-del types + + + SEMANAGE_MSG_ERR = _semanage.SEMANAGE_MSG_ERR + SEMANAGE_MSG_WARN = _semanage.SEMANAGE_MSG_WARN + SEMANAGE_MSG_INFO = _semanage.SEMANAGE_MSG_INFO ++ ++def semanage_msg_get_level(*args): ++ return _semanage.semanage_msg_get_level(*args) + semanage_msg_get_level = _semanage.semanage_msg_get_level ++ ++def semanage_msg_get_channel(*args): ++ return _semanage.semanage_msg_get_channel(*args) + semanage_msg_get_channel = _semanage.semanage_msg_get_channel ++ ++def semanage_msg_get_fname(*args): ++ return _semanage.semanage_msg_get_fname(*args) + semanage_msg_get_fname = _semanage.semanage_msg_get_fname ++ ++def semanage_msg_set_callback(*args): ++ return _semanage.semanage_msg_set_callback(*args) + semanage_msg_set_callback = _semanage.semanage_msg_set_callback ++ ++def semanage_handle_create(): ++ return _semanage.semanage_handle_create() + semanage_handle_create = _semanage.semanage_handle_create ++ ++def semanage_handle_destroy(*args): ++ return _semanage.semanage_handle_destroy(*args) + semanage_handle_destroy = _semanage.semanage_handle_destroy + SEMANAGE_CON_INVALID = _semanage.SEMANAGE_CON_INVALID + SEMANAGE_CON_DIRECT = _semanage.SEMANAGE_CON_DIRECT + SEMANAGE_CON_POLSERV_LOCAL = _semanage.SEMANAGE_CON_POLSERV_LOCAL + SEMANAGE_CON_POLSERV_REMOTE = _semanage.SEMANAGE_CON_POLSERV_REMOTE ++ ++def semanage_select_store(*args): ++ return _semanage.semanage_select_store(*args) + semanage_select_store = _semanage.semanage_select_store ++ ++def semanage_reload_policy(*args): ++ return _semanage.semanage_reload_policy(*args) + semanage_reload_policy = _semanage.semanage_reload_policy ++ ++def semanage_set_reload(*args): ++ return _semanage.semanage_set_reload(*args) + semanage_set_reload = _semanage.semanage_set_reload ++ ++def semanage_set_rebuild(*args): ++ return _semanage.semanage_set_rebuild(*args) + semanage_set_rebuild = _semanage.semanage_set_rebuild ++ ++def semanage_set_create_store(*args): ++ return _semanage.semanage_set_create_store(*args) + semanage_set_create_store = _semanage.semanage_set_create_store ++ ++def semanage_set_disable_dontaudit(*args): ++ return _semanage.semanage_set_disable_dontaudit(*args) + semanage_set_disable_dontaudit = _semanage.semanage_set_disable_dontaudit ++ ++def semanage_is_managed(*args): ++ return _semanage.semanage_is_managed(*args) + semanage_is_managed = _semanage.semanage_is_managed ++ ++def semanage_connect(*args): ++ return _semanage.semanage_connect(*args) + semanage_connect = _semanage.semanage_connect ++ ++def semanage_disconnect(*args): ++ return _semanage.semanage_disconnect(*args) + semanage_disconnect = _semanage.semanage_disconnect ++ ++def semanage_begin_transaction(*args): ++ return _semanage.semanage_begin_transaction(*args) + semanage_begin_transaction = _semanage.semanage_begin_transaction ++ ++def semanage_commit(*args): ++ return _semanage.semanage_commit(*args) + semanage_commit = _semanage.semanage_commit + SEMANAGE_CAN_READ = _semanage.SEMANAGE_CAN_READ + SEMANAGE_CAN_WRITE = _semanage.SEMANAGE_CAN_WRITE ++ ++def semanage_access_check(*args): ++ return _semanage.semanage_access_check(*args) + semanage_access_check = _semanage.semanage_access_check ++ ++def semanage_is_connected(*args): ++ return _semanage.semanage_is_connected(*args) + semanage_is_connected = _semanage.semanage_is_connected ++ ++def semanage_mls_enabled(*args): ++ return _semanage.semanage_mls_enabled(*args) + semanage_mls_enabled = _semanage.semanage_mls_enabled ++ ++def semanage_module_install(*args): ++ return _semanage.semanage_module_install(*args) + semanage_module_install = _semanage.semanage_module_install ++ ++def semanage_module_install_file(*args): ++ return _semanage.semanage_module_install_file(*args) + semanage_module_install_file = _semanage.semanage_module_install_file ++ ++def semanage_module_upgrade(*args): ++ return _semanage.semanage_module_upgrade(*args) + semanage_module_upgrade = _semanage.semanage_module_upgrade ++ ++def semanage_module_upgrade_file(*args): ++ return _semanage.semanage_module_upgrade_file(*args) + semanage_module_upgrade_file = _semanage.semanage_module_upgrade_file ++ ++def semanage_module_install_base(*args): ++ return _semanage.semanage_module_install_base(*args) + semanage_module_install_base = _semanage.semanage_module_install_base ++ ++def semanage_module_install_base_file(*args): ++ return _semanage.semanage_module_install_base_file(*args) + semanage_module_install_base_file = _semanage.semanage_module_install_base_file ++ ++def semanage_module_remove(*args): ++ return _semanage.semanage_module_remove(*args) + semanage_module_remove = _semanage.semanage_module_remove ++ ++def semanage_module_list(*args): ++ return _semanage.semanage_module_list(*args) + semanage_module_list = _semanage.semanage_module_list ++ ++def semanage_module_info_datum_destroy(*args): ++ return _semanage.semanage_module_info_datum_destroy(*args) + semanage_module_info_datum_destroy = _semanage.semanage_module_info_datum_destroy ++ ++def semanage_module_list_nth(*args): ++ return _semanage.semanage_module_list_nth(*args) + semanage_module_list_nth = _semanage.semanage_module_list_nth ++ ++def semanage_module_get_name(*args): ++ return _semanage.semanage_module_get_name(*args) + semanage_module_get_name = _semanage.semanage_module_get_name ++ ++def semanage_module_get_version(*args): ++ return _semanage.semanage_module_get_version(*args) + semanage_module_get_version = _semanage.semanage_module_get_version ++ ++def semanage_context_get_user(*args): ++ return _semanage.semanage_context_get_user(*args) + semanage_context_get_user = _semanage.semanage_context_get_user ++ ++def semanage_context_set_user(*args): ++ return _semanage.semanage_context_set_user(*args) + semanage_context_set_user = _semanage.semanage_context_set_user ++ ++def semanage_context_get_role(*args): ++ return _semanage.semanage_context_get_role(*args) + semanage_context_get_role = _semanage.semanage_context_get_role ++ ++def semanage_context_set_role(*args): ++ return _semanage.semanage_context_set_role(*args) + semanage_context_set_role = _semanage.semanage_context_set_role ++ ++def semanage_context_get_type(*args): ++ return _semanage.semanage_context_get_type(*args) + semanage_context_get_type = _semanage.semanage_context_get_type ++ ++def semanage_context_set_type(*args): ++ return _semanage.semanage_context_set_type(*args) + semanage_context_set_type = _semanage.semanage_context_set_type ++ ++def semanage_context_get_mls(*args): ++ return _semanage.semanage_context_get_mls(*args) + semanage_context_get_mls = _semanage.semanage_context_get_mls ++ ++def semanage_context_set_mls(*args): ++ return _semanage.semanage_context_set_mls(*args) + semanage_context_set_mls = _semanage.semanage_context_set_mls ++ ++def semanage_context_create(*args): ++ return _semanage.semanage_context_create(*args) + semanage_context_create = _semanage.semanage_context_create ++ ++def semanage_context_clone(*args): ++ return _semanage.semanage_context_clone(*args) + semanage_context_clone = _semanage.semanage_context_clone ++ ++def semanage_context_free(*args): ++ return _semanage.semanage_context_free(*args) + semanage_context_free = _semanage.semanage_context_free ++ ++def semanage_context_from_string(*args): ++ return _semanage.semanage_context_from_string(*args) + semanage_context_from_string = _semanage.semanage_context_from_string ++ ++def semanage_context_to_string(*args): ++ return _semanage.semanage_context_to_string(*args) + semanage_context_to_string = _semanage.semanage_context_to_string ++ ++def semanage_bool_key_create(*args): ++ return _semanage.semanage_bool_key_create(*args) + semanage_bool_key_create = _semanage.semanage_bool_key_create ++ ++def semanage_bool_key_extract(*args): ++ return _semanage.semanage_bool_key_extract(*args) + semanage_bool_key_extract = _semanage.semanage_bool_key_extract ++ ++def semanage_bool_key_free(*args): ++ return _semanage.semanage_bool_key_free(*args) + semanage_bool_key_free = _semanage.semanage_bool_key_free ++ ++def semanage_bool_compare(*args): ++ return _semanage.semanage_bool_compare(*args) + semanage_bool_compare = _semanage.semanage_bool_compare ++ ++def semanage_bool_compare2(*args): ++ return _semanage.semanage_bool_compare2(*args) + semanage_bool_compare2 = _semanage.semanage_bool_compare2 ++ ++def semanage_bool_get_name(*args): ++ return _semanage.semanage_bool_get_name(*args) + semanage_bool_get_name = _semanage.semanage_bool_get_name ++ ++def semanage_bool_set_name(*args): ++ return _semanage.semanage_bool_set_name(*args) + semanage_bool_set_name = _semanage.semanage_bool_set_name ++ ++def semanage_bool_get_value(*args): ++ return _semanage.semanage_bool_get_value(*args) + semanage_bool_get_value = _semanage.semanage_bool_get_value ++ ++def semanage_bool_set_value(*args): ++ return _semanage.semanage_bool_set_value(*args) + semanage_bool_set_value = _semanage.semanage_bool_set_value ++ ++def semanage_bool_create(*args): ++ return _semanage.semanage_bool_create(*args) + semanage_bool_create = _semanage.semanage_bool_create ++ ++def semanage_bool_clone(*args): ++ return _semanage.semanage_bool_clone(*args) + semanage_bool_clone = _semanage.semanage_bool_clone ++ ++def semanage_bool_free(*args): ++ return _semanage.semanage_bool_free(*args) + semanage_bool_free = _semanage.semanage_bool_free ++ ++def semanage_bool_query(*args): ++ return _semanage.semanage_bool_query(*args) + semanage_bool_query = _semanage.semanage_bool_query ++ ++def semanage_bool_exists(*args): ++ return _semanage.semanage_bool_exists(*args) + semanage_bool_exists = _semanage.semanage_bool_exists ++ ++def semanage_bool_count(*args): ++ return _semanage.semanage_bool_count(*args) + semanage_bool_count = _semanage.semanage_bool_count ++ ++def semanage_bool_iterate(*args): ++ return _semanage.semanage_bool_iterate(*args) + semanage_bool_iterate = _semanage.semanage_bool_iterate ++ ++def semanage_bool_list(*args): ++ return _semanage.semanage_bool_list(*args) + semanage_bool_list = _semanage.semanage_bool_list ++ ++def semanage_bool_modify_local(*args): ++ return _semanage.semanage_bool_modify_local(*args) + semanage_bool_modify_local = _semanage.semanage_bool_modify_local ++ ++def semanage_bool_del_local(*args): ++ return _semanage.semanage_bool_del_local(*args) + semanage_bool_del_local = _semanage.semanage_bool_del_local ++ ++def semanage_bool_query_local(*args): ++ return _semanage.semanage_bool_query_local(*args) + semanage_bool_query_local = _semanage.semanage_bool_query_local ++ ++def semanage_bool_exists_local(*args): ++ return _semanage.semanage_bool_exists_local(*args) + semanage_bool_exists_local = _semanage.semanage_bool_exists_local ++ ++def semanage_bool_count_local(*args): ++ return _semanage.semanage_bool_count_local(*args) + semanage_bool_count_local = _semanage.semanage_bool_count_local ++ ++def semanage_bool_iterate_local(*args): ++ return _semanage.semanage_bool_iterate_local(*args) + semanage_bool_iterate_local = _semanage.semanage_bool_iterate_local ++ ++def semanage_bool_list_local(*args): ++ return _semanage.semanage_bool_list_local(*args) + semanage_bool_list_local = _semanage.semanage_bool_list_local ++ ++def semanage_bool_set_active(*args): ++ return _semanage.semanage_bool_set_active(*args) + semanage_bool_set_active = _semanage.semanage_bool_set_active ++ ++def semanage_bool_query_active(*args): ++ return _semanage.semanage_bool_query_active(*args) + semanage_bool_query_active = _semanage.semanage_bool_query_active ++ ++def semanage_bool_exists_active(*args): ++ return _semanage.semanage_bool_exists_active(*args) + semanage_bool_exists_active = _semanage.semanage_bool_exists_active ++ ++def semanage_bool_count_active(*args): ++ return _semanage.semanage_bool_count_active(*args) + semanage_bool_count_active = _semanage.semanage_bool_count_active ++ ++def semanage_bool_iterate_active(*args): ++ return _semanage.semanage_bool_iterate_active(*args) + semanage_bool_iterate_active = _semanage.semanage_bool_iterate_active ++ ++def semanage_bool_list_active(*args): ++ return _semanage.semanage_bool_list_active(*args) + semanage_bool_list_active = _semanage.semanage_bool_list_active ++ ++def semanage_iface_compare(*args): ++ return _semanage.semanage_iface_compare(*args) + semanage_iface_compare = _semanage.semanage_iface_compare ++ ++def semanage_iface_compare2(*args): ++ return _semanage.semanage_iface_compare2(*args) + semanage_iface_compare2 = _semanage.semanage_iface_compare2 ++ ++def semanage_iface_key_create(*args): ++ return _semanage.semanage_iface_key_create(*args) + semanage_iface_key_create = _semanage.semanage_iface_key_create ++ ++def semanage_iface_key_extract(*args): ++ return _semanage.semanage_iface_key_extract(*args) + semanage_iface_key_extract = _semanage.semanage_iface_key_extract ++ ++def semanage_iface_key_free(*args): ++ return _semanage.semanage_iface_key_free(*args) + semanage_iface_key_free = _semanage.semanage_iface_key_free ++ ++def semanage_iface_get_name(*args): ++ return _semanage.semanage_iface_get_name(*args) + semanage_iface_get_name = _semanage.semanage_iface_get_name ++ ++def semanage_iface_set_name(*args): ++ return _semanage.semanage_iface_set_name(*args) + semanage_iface_set_name = _semanage.semanage_iface_set_name ++ ++def semanage_iface_get_ifcon(*args): ++ return _semanage.semanage_iface_get_ifcon(*args) + semanage_iface_get_ifcon = _semanage.semanage_iface_get_ifcon ++ ++def semanage_iface_set_ifcon(*args): ++ return _semanage.semanage_iface_set_ifcon(*args) + semanage_iface_set_ifcon = _semanage.semanage_iface_set_ifcon ++ ++def semanage_iface_get_msgcon(*args): ++ return _semanage.semanage_iface_get_msgcon(*args) + semanage_iface_get_msgcon = _semanage.semanage_iface_get_msgcon ++ ++def semanage_iface_set_msgcon(*args): ++ return _semanage.semanage_iface_set_msgcon(*args) + semanage_iface_set_msgcon = _semanage.semanage_iface_set_msgcon ++ ++def semanage_iface_create(*args): ++ return _semanage.semanage_iface_create(*args) + semanage_iface_create = _semanage.semanage_iface_create ++ ++def semanage_iface_clone(*args): ++ return _semanage.semanage_iface_clone(*args) + semanage_iface_clone = _semanage.semanage_iface_clone ++ ++def semanage_iface_free(*args): ++ return _semanage.semanage_iface_free(*args) + semanage_iface_free = _semanage.semanage_iface_free ++ ++def semanage_iface_modify_local(*args): ++ return _semanage.semanage_iface_modify_local(*args) + semanage_iface_modify_local = _semanage.semanage_iface_modify_local ++ ++def semanage_iface_del_local(*args): ++ return _semanage.semanage_iface_del_local(*args) + semanage_iface_del_local = _semanage.semanage_iface_del_local ++ ++def semanage_iface_query_local(*args): ++ return _semanage.semanage_iface_query_local(*args) + semanage_iface_query_local = _semanage.semanage_iface_query_local ++ ++def semanage_iface_exists_local(*args): ++ return _semanage.semanage_iface_exists_local(*args) + semanage_iface_exists_local = _semanage.semanage_iface_exists_local ++ ++def semanage_iface_count_local(*args): ++ return _semanage.semanage_iface_count_local(*args) + semanage_iface_count_local = _semanage.semanage_iface_count_local ++ ++def semanage_iface_iterate_local(*args): ++ return _semanage.semanage_iface_iterate_local(*args) + semanage_iface_iterate_local = _semanage.semanage_iface_iterate_local ++ ++def semanage_iface_list_local(*args): ++ return _semanage.semanage_iface_list_local(*args) + semanage_iface_list_local = _semanage.semanage_iface_list_local ++ ++def semanage_iface_query(*args): ++ return _semanage.semanage_iface_query(*args) + semanage_iface_query = _semanage.semanage_iface_query ++ ++def semanage_iface_exists(*args): ++ return _semanage.semanage_iface_exists(*args) + semanage_iface_exists = _semanage.semanage_iface_exists ++ ++def semanage_iface_count(*args): ++ return _semanage.semanage_iface_count(*args) + semanage_iface_count = _semanage.semanage_iface_count ++ ++def semanage_iface_iterate(*args): ++ return _semanage.semanage_iface_iterate(*args) + semanage_iface_iterate = _semanage.semanage_iface_iterate ++ ++def semanage_iface_list(*args): ++ return _semanage.semanage_iface_list(*args) + semanage_iface_list = _semanage.semanage_iface_list ++ ++def semanage_user_key_create(*args): ++ return _semanage.semanage_user_key_create(*args) + semanage_user_key_create = _semanage.semanage_user_key_create ++ ++def semanage_user_key_extract(*args): ++ return _semanage.semanage_user_key_extract(*args) + semanage_user_key_extract = _semanage.semanage_user_key_extract ++ ++def semanage_user_key_free(*args): ++ return _semanage.semanage_user_key_free(*args) + semanage_user_key_free = _semanage.semanage_user_key_free ++ ++def semanage_user_compare(*args): ++ return _semanage.semanage_user_compare(*args) + semanage_user_compare = _semanage.semanage_user_compare ++ ++def semanage_user_compare2(*args): ++ return _semanage.semanage_user_compare2(*args) + semanage_user_compare2 = _semanage.semanage_user_compare2 ++ ++def semanage_user_get_name(*args): ++ return _semanage.semanage_user_get_name(*args) + semanage_user_get_name = _semanage.semanage_user_get_name ++ ++def semanage_user_set_name(*args): ++ return _semanage.semanage_user_set_name(*args) + semanage_user_set_name = _semanage.semanage_user_set_name ++ ++def semanage_user_get_prefix(*args): ++ return _semanage.semanage_user_get_prefix(*args) + semanage_user_get_prefix = _semanage.semanage_user_get_prefix ++ ++def semanage_user_set_prefix(*args): ++ return _semanage.semanage_user_set_prefix(*args) + semanage_user_set_prefix = _semanage.semanage_user_set_prefix ++ ++def semanage_user_get_mlslevel(*args): ++ return _semanage.semanage_user_get_mlslevel(*args) + semanage_user_get_mlslevel = _semanage.semanage_user_get_mlslevel ++ ++def semanage_user_set_mlslevel(*args): ++ return _semanage.semanage_user_set_mlslevel(*args) + semanage_user_set_mlslevel = _semanage.semanage_user_set_mlslevel ++ ++def semanage_user_get_mlsrange(*args): ++ return _semanage.semanage_user_get_mlsrange(*args) + semanage_user_get_mlsrange = _semanage.semanage_user_get_mlsrange ++ ++def semanage_user_set_mlsrange(*args): ++ return _semanage.semanage_user_set_mlsrange(*args) + semanage_user_set_mlsrange = _semanage.semanage_user_set_mlsrange ++ ++def semanage_user_get_num_roles(*args): ++ return _semanage.semanage_user_get_num_roles(*args) + semanage_user_get_num_roles = _semanage.semanage_user_get_num_roles ++ ++def semanage_user_add_role(*args): ++ return _semanage.semanage_user_add_role(*args) + semanage_user_add_role = _semanage.semanage_user_add_role ++ ++def semanage_user_del_role(*args): ++ return _semanage.semanage_user_del_role(*args) + semanage_user_del_role = _semanage.semanage_user_del_role ++ ++def semanage_user_has_role(*args): ++ return _semanage.semanage_user_has_role(*args) + semanage_user_has_role = _semanage.semanage_user_has_role ++ ++def semanage_user_get_roles(*args): ++ return _semanage.semanage_user_get_roles(*args) + semanage_user_get_roles = _semanage.semanage_user_get_roles ++ ++def semanage_user_set_roles(*args): ++ return _semanage.semanage_user_set_roles(*args) + semanage_user_set_roles = _semanage.semanage_user_set_roles ++ ++def semanage_user_create(*args): ++ return _semanage.semanage_user_create(*args) + semanage_user_create = _semanage.semanage_user_create ++ ++def semanage_user_clone(*args): ++ return _semanage.semanage_user_clone(*args) + semanage_user_clone = _semanage.semanage_user_clone ++ ++def semanage_user_free(*args): ++ return _semanage.semanage_user_free(*args) + semanage_user_free = _semanage.semanage_user_free ++ ++def semanage_user_modify_local(*args): ++ return _semanage.semanage_user_modify_local(*args) + semanage_user_modify_local = _semanage.semanage_user_modify_local ++ ++def semanage_user_del_local(*args): ++ return _semanage.semanage_user_del_local(*args) + semanage_user_del_local = _semanage.semanage_user_del_local ++ ++def semanage_user_query_local(*args): ++ return _semanage.semanage_user_query_local(*args) + semanage_user_query_local = _semanage.semanage_user_query_local ++ ++def semanage_user_exists_local(*args): ++ return _semanage.semanage_user_exists_local(*args) + semanage_user_exists_local = _semanage.semanage_user_exists_local ++ ++def semanage_user_count_local(*args): ++ return _semanage.semanage_user_count_local(*args) + semanage_user_count_local = _semanage.semanage_user_count_local ++ ++def semanage_user_iterate_local(*args): ++ return _semanage.semanage_user_iterate_local(*args) + semanage_user_iterate_local = _semanage.semanage_user_iterate_local ++ ++def semanage_user_list_local(*args): ++ return _semanage.semanage_user_list_local(*args) + semanage_user_list_local = _semanage.semanage_user_list_local ++ ++def semanage_user_query(*args): ++ return _semanage.semanage_user_query(*args) + semanage_user_query = _semanage.semanage_user_query ++ ++def semanage_user_exists(*args): ++ return _semanage.semanage_user_exists(*args) + semanage_user_exists = _semanage.semanage_user_exists ++ ++def semanage_user_count(*args): ++ return _semanage.semanage_user_count(*args) + semanage_user_count = _semanage.semanage_user_count ++ ++def semanage_user_iterate(*args): ++ return _semanage.semanage_user_iterate(*args) + semanage_user_iterate = _semanage.semanage_user_iterate ++ ++def semanage_user_list(*args): ++ return _semanage.semanage_user_list(*args) + semanage_user_list = _semanage.semanage_user_list + SEMANAGE_PROTO_UDP = _semanage.SEMANAGE_PROTO_UDP + SEMANAGE_PROTO_TCP = _semanage.SEMANAGE_PROTO_TCP ++ ++def semanage_port_compare(*args): ++ return _semanage.semanage_port_compare(*args) + semanage_port_compare = _semanage.semanage_port_compare ++ ++def semanage_port_compare2(*args): ++ return _semanage.semanage_port_compare2(*args) + semanage_port_compare2 = _semanage.semanage_port_compare2 ++ ++def semanage_port_key_create(*args): ++ return _semanage.semanage_port_key_create(*args) + semanage_port_key_create = _semanage.semanage_port_key_create ++ ++def semanage_port_key_extract(*args): ++ return _semanage.semanage_port_key_extract(*args) + semanage_port_key_extract = _semanage.semanage_port_key_extract ++ ++def semanage_port_key_free(*args): ++ return _semanage.semanage_port_key_free(*args) + semanage_port_key_free = _semanage.semanage_port_key_free ++ ++def semanage_port_get_proto(*args): ++ return _semanage.semanage_port_get_proto(*args) + semanage_port_get_proto = _semanage.semanage_port_get_proto ++ ++def semanage_port_set_proto(*args): ++ return _semanage.semanage_port_set_proto(*args) + semanage_port_set_proto = _semanage.semanage_port_set_proto ++ ++def semanage_port_get_proto_str(*args): ++ return _semanage.semanage_port_get_proto_str(*args) + semanage_port_get_proto_str = _semanage.semanage_port_get_proto_str ++ ++def semanage_port_get_low(*args): ++ return _semanage.semanage_port_get_low(*args) + semanage_port_get_low = _semanage.semanage_port_get_low ++ ++def semanage_port_get_high(*args): ++ return _semanage.semanage_port_get_high(*args) + semanage_port_get_high = _semanage.semanage_port_get_high ++ ++def semanage_port_set_port(*args): ++ return _semanage.semanage_port_set_port(*args) + semanage_port_set_port = _semanage.semanage_port_set_port ++ ++def semanage_port_set_range(*args): ++ return _semanage.semanage_port_set_range(*args) + semanage_port_set_range = _semanage.semanage_port_set_range ++ ++def semanage_port_get_con(*args): ++ return _semanage.semanage_port_get_con(*args) + semanage_port_get_con = _semanage.semanage_port_get_con ++ ++def semanage_port_set_con(*args): ++ return _semanage.semanage_port_set_con(*args) + semanage_port_set_con = _semanage.semanage_port_set_con ++ ++def semanage_port_create(*args): ++ return _semanage.semanage_port_create(*args) + semanage_port_create = _semanage.semanage_port_create ++ ++def semanage_port_clone(*args): ++ return _semanage.semanage_port_clone(*args) + semanage_port_clone = _semanage.semanage_port_clone ++ ++def semanage_port_free(*args): ++ return _semanage.semanage_port_free(*args) + semanage_port_free = _semanage.semanage_port_free ++ ++def semanage_port_modify_local(*args): ++ return _semanage.semanage_port_modify_local(*args) + semanage_port_modify_local = _semanage.semanage_port_modify_local ++ ++def semanage_port_del_local(*args): ++ return _semanage.semanage_port_del_local(*args) + semanage_port_del_local = _semanage.semanage_port_del_local ++ ++def semanage_port_query_local(*args): ++ return _semanage.semanage_port_query_local(*args) + semanage_port_query_local = _semanage.semanage_port_query_local ++ ++def semanage_port_exists_local(*args): ++ return _semanage.semanage_port_exists_local(*args) + semanage_port_exists_local = _semanage.semanage_port_exists_local ++ ++def semanage_port_count_local(*args): ++ return _semanage.semanage_port_count_local(*args) + semanage_port_count_local = _semanage.semanage_port_count_local ++ ++def semanage_port_iterate_local(*args): ++ return _semanage.semanage_port_iterate_local(*args) + semanage_port_iterate_local = _semanage.semanage_port_iterate_local ++ ++def semanage_port_list_local(*args): ++ return _semanage.semanage_port_list_local(*args) + semanage_port_list_local = _semanage.semanage_port_list_local ++ ++def semanage_port_query(*args): ++ return _semanage.semanage_port_query(*args) + semanage_port_query = _semanage.semanage_port_query ++ ++def semanage_port_exists(*args): ++ return _semanage.semanage_port_exists(*args) + semanage_port_exists = _semanage.semanage_port_exists ++ ++def semanage_port_count(*args): ++ return _semanage.semanage_port_count(*args) + semanage_port_count = _semanage.semanage_port_count ++ ++def semanage_port_iterate(*args): ++ return _semanage.semanage_port_iterate(*args) + semanage_port_iterate = _semanage.semanage_port_iterate ++ ++def semanage_port_list(*args): ++ return _semanage.semanage_port_list(*args) + semanage_port_list = _semanage.semanage_port_list ++ ++def semanage_fcontext_compare(*args): ++ return _semanage.semanage_fcontext_compare(*args) + semanage_fcontext_compare = _semanage.semanage_fcontext_compare ++ ++def semanage_fcontext_compare2(*args): ++ return _semanage.semanage_fcontext_compare2(*args) + semanage_fcontext_compare2 = _semanage.semanage_fcontext_compare2 ++ ++def semanage_fcontext_key_create(*args): ++ return _semanage.semanage_fcontext_key_create(*args) + semanage_fcontext_key_create = _semanage.semanage_fcontext_key_create ++ ++def semanage_fcontext_key_extract(*args): ++ return _semanage.semanage_fcontext_key_extract(*args) + semanage_fcontext_key_extract = _semanage.semanage_fcontext_key_extract ++ ++def semanage_fcontext_key_free(*args): ++ return _semanage.semanage_fcontext_key_free(*args) + semanage_fcontext_key_free = _semanage.semanage_fcontext_key_free ++ ++def semanage_fcontext_get_expr(*args): ++ return _semanage.semanage_fcontext_get_expr(*args) + semanage_fcontext_get_expr = _semanage.semanage_fcontext_get_expr ++ ++def semanage_fcontext_set_expr(*args): ++ return _semanage.semanage_fcontext_set_expr(*args) + semanage_fcontext_set_expr = _semanage.semanage_fcontext_set_expr + SEMANAGE_FCONTEXT_ALL = _semanage.SEMANAGE_FCONTEXT_ALL + SEMANAGE_FCONTEXT_REG = _semanage.SEMANAGE_FCONTEXT_REG +@@ -238,86 +769,323 @@ + SEMANAGE_FCONTEXT_SOCK = _semanage.SEMANAGE_FCONTEXT_SOCK + SEMANAGE_FCONTEXT_LINK = _semanage.SEMANAGE_FCONTEXT_LINK + SEMANAGE_FCONTEXT_PIPE = _semanage.SEMANAGE_FCONTEXT_PIPE ++ ++def semanage_fcontext_get_type(*args): ++ return _semanage.semanage_fcontext_get_type(*args) + semanage_fcontext_get_type = _semanage.semanage_fcontext_get_type ++ ++def semanage_fcontext_get_type_str(*args): ++ return _semanage.semanage_fcontext_get_type_str(*args) + semanage_fcontext_get_type_str = _semanage.semanage_fcontext_get_type_str ++ ++def semanage_fcontext_set_type(*args): ++ return _semanage.semanage_fcontext_set_type(*args) + semanage_fcontext_set_type = _semanage.semanage_fcontext_set_type ++ ++def semanage_fcontext_get_con(*args): ++ return _semanage.semanage_fcontext_get_con(*args) + semanage_fcontext_get_con = _semanage.semanage_fcontext_get_con ++ ++def semanage_fcontext_set_con(*args): ++ return _semanage.semanage_fcontext_set_con(*args) + semanage_fcontext_set_con = _semanage.semanage_fcontext_set_con ++ ++def semanage_fcontext_create(*args): ++ return _semanage.semanage_fcontext_create(*args) + semanage_fcontext_create = _semanage.semanage_fcontext_create ++ ++def semanage_fcontext_clone(*args): ++ return _semanage.semanage_fcontext_clone(*args) + semanage_fcontext_clone = _semanage.semanage_fcontext_clone ++ ++def semanage_fcontext_free(*args): ++ return _semanage.semanage_fcontext_free(*args) + semanage_fcontext_free = _semanage.semanage_fcontext_free ++ ++def semanage_fcontext_modify_local(*args): ++ return _semanage.semanage_fcontext_modify_local(*args) + semanage_fcontext_modify_local = _semanage.semanage_fcontext_modify_local ++ ++def semanage_fcontext_del_local(*args): ++ return _semanage.semanage_fcontext_del_local(*args) + semanage_fcontext_del_local = _semanage.semanage_fcontext_del_local ++ ++def semanage_fcontext_query_local(*args): ++ return _semanage.semanage_fcontext_query_local(*args) + semanage_fcontext_query_local = _semanage.semanage_fcontext_query_local ++ ++def semanage_fcontext_exists_local(*args): ++ return _semanage.semanage_fcontext_exists_local(*args) + semanage_fcontext_exists_local = _semanage.semanage_fcontext_exists_local ++ ++def semanage_fcontext_count_local(*args): ++ return _semanage.semanage_fcontext_count_local(*args) + semanage_fcontext_count_local = _semanage.semanage_fcontext_count_local ++ ++def semanage_fcontext_iterate_local(*args): ++ return _semanage.semanage_fcontext_iterate_local(*args) + semanage_fcontext_iterate_local = _semanage.semanage_fcontext_iterate_local ++ ++def semanage_fcontext_list_local(*args): ++ return _semanage.semanage_fcontext_list_local(*args) + semanage_fcontext_list_local = _semanage.semanage_fcontext_list_local ++ ++def semanage_fcontext_query(*args): ++ return _semanage.semanage_fcontext_query(*args) + semanage_fcontext_query = _semanage.semanage_fcontext_query ++ ++def semanage_fcontext_exists(*args): ++ return _semanage.semanage_fcontext_exists(*args) + semanage_fcontext_exists = _semanage.semanage_fcontext_exists ++ ++def semanage_fcontext_count(*args): ++ return _semanage.semanage_fcontext_count(*args) + semanage_fcontext_count = _semanage.semanage_fcontext_count ++ ++def semanage_fcontext_iterate(*args): ++ return _semanage.semanage_fcontext_iterate(*args) + semanage_fcontext_iterate = _semanage.semanage_fcontext_iterate ++ ++def semanage_fcontext_list(*args): ++ return _semanage.semanage_fcontext_list(*args) + semanage_fcontext_list = _semanage.semanage_fcontext_list ++ ++def semanage_seuser_key_create(*args): ++ return _semanage.semanage_seuser_key_create(*args) + semanage_seuser_key_create = _semanage.semanage_seuser_key_create ++ ++def semanage_seuser_key_extract(*args): ++ return _semanage.semanage_seuser_key_extract(*args) + semanage_seuser_key_extract = _semanage.semanage_seuser_key_extract ++ ++def semanage_seuser_key_free(*args): ++ return _semanage.semanage_seuser_key_free(*args) + semanage_seuser_key_free = _semanage.semanage_seuser_key_free ++ ++def semanage_seuser_compare(*args): ++ return _semanage.semanage_seuser_compare(*args) + semanage_seuser_compare = _semanage.semanage_seuser_compare ++ ++def semanage_seuser_compare2(*args): ++ return _semanage.semanage_seuser_compare2(*args) + semanage_seuser_compare2 = _semanage.semanage_seuser_compare2 ++ ++def semanage_seuser_get_name(*args): ++ return _semanage.semanage_seuser_get_name(*args) + semanage_seuser_get_name = _semanage.semanage_seuser_get_name ++ ++def semanage_seuser_set_name(*args): ++ return _semanage.semanage_seuser_set_name(*args) + semanage_seuser_set_name = _semanage.semanage_seuser_set_name ++ ++def semanage_seuser_get_sename(*args): ++ return _semanage.semanage_seuser_get_sename(*args) + semanage_seuser_get_sename = _semanage.semanage_seuser_get_sename ++ ++def semanage_seuser_set_sename(*args): ++ return _semanage.semanage_seuser_set_sename(*args) + semanage_seuser_set_sename = _semanage.semanage_seuser_set_sename ++ ++def semanage_seuser_get_mlsrange(*args): ++ return _semanage.semanage_seuser_get_mlsrange(*args) + semanage_seuser_get_mlsrange = _semanage.semanage_seuser_get_mlsrange ++ ++def semanage_seuser_set_mlsrange(*args): ++ return _semanage.semanage_seuser_set_mlsrange(*args) + semanage_seuser_set_mlsrange = _semanage.semanage_seuser_set_mlsrange ++ ++def semanage_seuser_create(*args): ++ return _semanage.semanage_seuser_create(*args) + semanage_seuser_create = _semanage.semanage_seuser_create ++ ++def semanage_seuser_clone(*args): ++ return _semanage.semanage_seuser_clone(*args) + semanage_seuser_clone = _semanage.semanage_seuser_clone ++ ++def semanage_seuser_free(*args): ++ return _semanage.semanage_seuser_free(*args) + semanage_seuser_free = _semanage.semanage_seuser_free ++ ++def semanage_seuser_modify_local(*args): ++ return _semanage.semanage_seuser_modify_local(*args) + semanage_seuser_modify_local = _semanage.semanage_seuser_modify_local ++ ++def semanage_seuser_del_local(*args): ++ return _semanage.semanage_seuser_del_local(*args) + semanage_seuser_del_local = _semanage.semanage_seuser_del_local ++ ++def semanage_seuser_query_local(*args): ++ return _semanage.semanage_seuser_query_local(*args) + semanage_seuser_query_local = _semanage.semanage_seuser_query_local ++ ++def semanage_seuser_exists_local(*args): ++ return _semanage.semanage_seuser_exists_local(*args) + semanage_seuser_exists_local = _semanage.semanage_seuser_exists_local ++ ++def semanage_seuser_count_local(*args): ++ return _semanage.semanage_seuser_count_local(*args) + semanage_seuser_count_local = _semanage.semanage_seuser_count_local ++ ++def semanage_seuser_iterate_local(*args): ++ return _semanage.semanage_seuser_iterate_local(*args) + semanage_seuser_iterate_local = _semanage.semanage_seuser_iterate_local ++ ++def semanage_seuser_list_local(*args): ++ return _semanage.semanage_seuser_list_local(*args) + semanage_seuser_list_local = _semanage.semanage_seuser_list_local ++ ++def semanage_seuser_query(*args): ++ return _semanage.semanage_seuser_query(*args) + semanage_seuser_query = _semanage.semanage_seuser_query ++ ++def semanage_seuser_exists(*args): ++ return _semanage.semanage_seuser_exists(*args) + semanage_seuser_exists = _semanage.semanage_seuser_exists ++ ++def semanage_seuser_count(*args): ++ return _semanage.semanage_seuser_count(*args) + semanage_seuser_count = _semanage.semanage_seuser_count ++ ++def semanage_seuser_iterate(*args): ++ return _semanage.semanage_seuser_iterate(*args) + semanage_seuser_iterate = _semanage.semanage_seuser_iterate ++ ++def semanage_seuser_list(*args): ++ return _semanage.semanage_seuser_list(*args) + semanage_seuser_list = _semanage.semanage_seuser_list + SEMANAGE_PROTO_IP4 = _semanage.SEMANAGE_PROTO_IP4 + SEMANAGE_PROTO_IP6 = _semanage.SEMANAGE_PROTO_IP6 ++ ++def semanage_node_compare(*args): ++ return _semanage.semanage_node_compare(*args) + semanage_node_compare = _semanage.semanage_node_compare ++ ++def semanage_node_compare2(*args): ++ return _semanage.semanage_node_compare2(*args) + semanage_node_compare2 = _semanage.semanage_node_compare2 ++ ++def semanage_node_key_create(*args): ++ return _semanage.semanage_node_key_create(*args) + semanage_node_key_create = _semanage.semanage_node_key_create ++ ++def semanage_node_key_extract(*args): ++ return _semanage.semanage_node_key_extract(*args) + semanage_node_key_extract = _semanage.semanage_node_key_extract ++ ++def semanage_node_key_free(*args): ++ return _semanage.semanage_node_key_free(*args) + semanage_node_key_free = _semanage.semanage_node_key_free ++ ++def semanage_node_get_addr(*args): ++ return _semanage.semanage_node_get_addr(*args) + semanage_node_get_addr = _semanage.semanage_node_get_addr ++ ++def semanage_node_get_addr_bytes(*args): ++ return _semanage.semanage_node_get_addr_bytes(*args) + semanage_node_get_addr_bytes = _semanage.semanage_node_get_addr_bytes ++ ++def semanage_node_set_addr(*args): ++ return _semanage.semanage_node_set_addr(*args) + semanage_node_set_addr = _semanage.semanage_node_set_addr ++ ++def semanage_node_set_addr_bytes(*args): ++ return _semanage.semanage_node_set_addr_bytes(*args) + semanage_node_set_addr_bytes = _semanage.semanage_node_set_addr_bytes ++ ++def semanage_node_get_mask(*args): ++ return _semanage.semanage_node_get_mask(*args) + semanage_node_get_mask = _semanage.semanage_node_get_mask ++ ++def semanage_node_get_mask_bytes(*args): ++ return _semanage.semanage_node_get_mask_bytes(*args) + semanage_node_get_mask_bytes = _semanage.semanage_node_get_mask_bytes ++ ++def semanage_node_set_mask(*args): ++ return _semanage.semanage_node_set_mask(*args) + semanage_node_set_mask = _semanage.semanage_node_set_mask ++ ++def semanage_node_set_mask_bytes(*args): ++ return _semanage.semanage_node_set_mask_bytes(*args) + semanage_node_set_mask_bytes = _semanage.semanage_node_set_mask_bytes ++ ++def semanage_node_get_proto(*args): ++ return _semanage.semanage_node_get_proto(*args) + semanage_node_get_proto = _semanage.semanage_node_get_proto ++ ++def semanage_node_set_proto(*args): ++ return _semanage.semanage_node_set_proto(*args) + semanage_node_set_proto = _semanage.semanage_node_set_proto ++ ++def semanage_node_get_proto_str(*args): ++ return _semanage.semanage_node_get_proto_str(*args) + semanage_node_get_proto_str = _semanage.semanage_node_get_proto_str ++ ++def semanage_node_get_con(*args): ++ return _semanage.semanage_node_get_con(*args) + semanage_node_get_con = _semanage.semanage_node_get_con ++ ++def semanage_node_set_con(*args): ++ return _semanage.semanage_node_set_con(*args) + semanage_node_set_con = _semanage.semanage_node_set_con ++ ++def semanage_node_create(*args): ++ return _semanage.semanage_node_create(*args) + semanage_node_create = _semanage.semanage_node_create ++ ++def semanage_node_clone(*args): ++ return _semanage.semanage_node_clone(*args) + semanage_node_clone = _semanage.semanage_node_clone ++ ++def semanage_node_free(*args): ++ return _semanage.semanage_node_free(*args) + semanage_node_free = _semanage.semanage_node_free ++ ++def semanage_node_modify_local(*args): ++ return _semanage.semanage_node_modify_local(*args) + semanage_node_modify_local = _semanage.semanage_node_modify_local ++ ++def semanage_node_del_local(*args): ++ return _semanage.semanage_node_del_local(*args) + semanage_node_del_local = _semanage.semanage_node_del_local ++ ++def semanage_node_query_local(*args): ++ return _semanage.semanage_node_query_local(*args) + semanage_node_query_local = _semanage.semanage_node_query_local ++ ++def semanage_node_exists_local(*args): ++ return _semanage.semanage_node_exists_local(*args) + semanage_node_exists_local = _semanage.semanage_node_exists_local ++ ++def semanage_node_count_local(*args): ++ return _semanage.semanage_node_count_local(*args) + semanage_node_count_local = _semanage.semanage_node_count_local ++ ++def semanage_node_iterate_local(*args): ++ return _semanage.semanage_node_iterate_local(*args) + semanage_node_iterate_local = _semanage.semanage_node_iterate_local ++ ++def semanage_node_list_local(*args): ++ return _semanage.semanage_node_list_local(*args) + semanage_node_list_local = _semanage.semanage_node_list_local ++ ++def semanage_node_query(*args): ++ return _semanage.semanage_node_query(*args) + semanage_node_query = _semanage.semanage_node_query ++ ++def semanage_node_exists(*args): ++ return _semanage.semanage_node_exists(*args) + semanage_node_exists = _semanage.semanage_node_exists ++ ++def semanage_node_count(*args): ++ return _semanage.semanage_node_count(*args) + semanage_node_count = _semanage.semanage_node_count ++ ++def semanage_node_iterate(*args): ++ return _semanage.semanage_node_iterate(*args) + semanage_node_iterate = _semanage.semanage_node_iterate ++ ++def semanage_node_list(*args): ++ return _semanage.semanage_node_list(*args) + semanage_node_list = _semanage.semanage_node_list + + diff --exclude-from=exclude -N -u -r nsalibsemanage/src/semanage_store.c libsemanage-2.0.31/src/semanage_store.c --- nsalibsemanage/src/semanage_store.c 2009-01-13 08:45:35.000000000 -0500 -+++ libsemanage-2.0.31/src/semanage_store.c 2009-03-26 14:55:01.000000000 -0400 ++++ libsemanage-2.0.31/src/semanage_store.c 2009-06-02 14:54:20.000000000 -0400 @@ -440,8 +440,6 @@ char tmp[PATH_MAX]; char buf[4192]; @@ -114,3 +1208,4923 @@ diff --exclude-from=exclude -N -u -r nsalibsemanage/src/semanage_store.c libsema goto cleanup; } } +diff --exclude-from=exclude -N -u -r nsalibsemanage/src/semanageswig_python.i libsemanage-2.0.31/src/semanageswig_python.i +--- nsalibsemanage/src/semanageswig_python.i 2008-08-28 09:34:24.000000000 -0400 ++++ libsemanage-2.0.31/src/semanageswig_python.i 2009-06-02 14:59:46.000000000 -0400 +@@ -27,6 +27,7 @@ + #define STATUS_SUCCESS 0 + #define STATUS_ERR -1 + %} ++typedef int (struct semanage_handle_t *); + + %wrapper %{ + +diff --exclude-from=exclude -N -u -r nsalibsemanage/src/semanageswig_wrap.c libsemanage-2.0.31/src/semanageswig_wrap.c +--- nsalibsemanage/src/semanageswig_wrap.c 2009-01-13 08:45:35.000000000 -0500 ++++ libsemanage-2.0.31/src/semanageswig_wrap.c 2009-06-02 14:59:55.000000000 -0400 +@@ -1,6 +1,6 @@ + /* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). +- * Version 1.3.35 ++ * Version 1.3.39 + * + * 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 +@@ -10,6 +10,7 @@ + + #define SWIGPYTHON + #define SWIG_PYTHON_DIRECTOR_NO_VTABLE ++ + /* ----------------------------------------------------------------------------- + * This section contains generic SWIG labels for method/variable + * declarations/attributes, and other compiler dependent labels. +@@ -52,6 +53,12 @@ + # endif + #endif + ++#ifndef SWIG_MSC_UNSUPPRESS_4505 ++# if defined(_MSC_VER) ++# pragma warning(disable : 4505) /* unreferenced local function has been removed */ ++# endif ++#endif ++ + #ifndef SWIGUNUSEDPARM + # ifdef __cplusplus + # define SWIGUNUSEDPARM(p) +@@ -120,7 +127,7 @@ + /* ----------------------------------------------------------------------------- + * swigrun.swg + * +- * This file contains generic CAPI SWIG runtime support for pointer ++ * This file contains generic C API SWIG runtime support for pointer + * type checking. + * ----------------------------------------------------------------------------- */ + +@@ -139,11 +146,11 @@ + + /* + 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'. ++ 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. ++ But only do this if strictly necessary, ie, if you have problems ++ with your compiler or suchlike. + */ + + #ifndef SWIGRUNTIME +@@ -170,14 +177,14 @@ + /* + Flags/methods for returning states. + +- The swig conversion methods, as ConvertPtr, return and integer ++ 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: ++ In old versions of SWIG, code such as the following was usually written: + + if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { + // success code +@@ -185,7 +192,7 @@ + //fail code + } + +- Now you can be more explicit as: ++ Now you can be more explicit: + + int res = SWIG_ConvertPtr(obj,vptr,ty.flags); + if (SWIG_IsOK(res)) { +@@ -194,7 +201,7 @@ + // fail code + } + +- that seems to be the same, but now you can also do ++ which is the same really, but now you can also do + + Type *ptr; + int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); +@@ -212,7 +219,7 @@ + + 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 ++ also requires SWIG_ConvertPtr to return new result values, such as + + int SWIG_ConvertPtr(obj, ptr,...) { + if () { +@@ -230,7 +237,7 @@ + + 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. ++ 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 +@@ -244,9 +251,8 @@ + 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) +@@ -271,7 +277,6 @@ + #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 +@@ -294,8 +299,6 @@ + #endif + + +- +- + #include + + #ifdef __cplusplus +@@ -392,40 +395,58 @@ + } + + +-/* 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); ++ if (ty) { ++ swig_cast_info *iter = ty->cast; ++ while (iter) { ++ if (strcmp(iter->type->name, c) == 0) { ++ 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; + } + +-/* Same as previous function, except strcmp is replaced with a pointer comparison */ ++/* ++ Identical to SWIG_TypeCheck, 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); ++SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) { ++ if (ty) { ++ swig_cast_info *iter = ty->cast; ++ while (iter) { ++ if (iter->type == from) { ++ 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; + } + + /* +@@ -704,6 +725,67 @@ + + + ++/* Compatibility marcos for Python 3 */ ++#if PY_VERSION_HEX >= 0x03000000 ++ ++#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type) ++#define PyInt_Check(x) PyLong_Check(x) ++#define PyInt_AsLong(x) PyLong_AsLong(x) ++#define PyInt_FromLong(x) PyLong_FromLong(x) ++#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args) ++ ++#endif ++ ++#ifndef Py_TYPE ++# define Py_TYPE(op) ((op)->ob_type) ++#endif ++ ++/* SWIG APIs for compatibility of both Python 2 & 3 */ ++ ++#if PY_VERSION_HEX >= 0x03000000 ++# define SWIG_Python_str_FromFormat PyUnicode_FromFormat ++#else ++# define SWIG_Python_str_FromFormat PyString_FromFormat ++#endif ++ ++ ++/* Warning: This function will allocate a new string in Python 3, ++ * so please call SWIG_Python_str_DelForPy3(x) to free the space. ++ */ ++SWIGINTERN char* ++SWIG_Python_str_AsChar(PyObject *str) ++{ ++#if PY_VERSION_HEX >= 0x03000000 ++ char *cstr; ++ char *newstr; ++ int len; ++ str = PyUnicode_AsUTF8String(str); ++ PyBytes_AsStringAndSize(str, &cstr, &len); ++ newstr = (char *) malloc(len+1); ++ memcpy(newstr, cstr, len+1); ++ Py_XDECREF(str); ++ return newstr; ++#else ++ return PyString_AsString(str); ++#endif ++} ++ ++#if PY_VERSION_HEX >= 0x03000000 ++# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) ) ++#else ++# define SWIG_Python_str_DelForPy3(x) ++#endif ++ ++ ++SWIGINTERN PyObject* ++SWIG_Python_str_FromChar(const char *c) ++{ ++#if PY_VERSION_HEX >= 0x03000000 ++ return PyUnicode_FromString(c); ++#else ++ return PyString_FromString(c); ++#endif ++} + + /* Add PyOS_snprintf for old Pythons */ + #if PY_VERSION_HEX < 0x02020000 +@@ -750,6 +832,7 @@ + # define PyObject_GenericGetAttr 0 + # endif + #endif ++ + /* Py_NotImplemented is defined in 2.1 and up. */ + #if PY_VERSION_HEX < 0x02010000 + # ifndef Py_NotImplemented +@@ -757,7 +840,6 @@ + # endif + #endif + +- + /* A crude PyString_AsStringAndSize implementation for old Pythons */ + #if PY_VERSION_HEX < 0x02010000 + # ifndef PyString_AsStringAndSize +@@ -772,7 +854,6 @@ + # endif + #endif + +- + /* PyBool_FromLong for old Pythons */ + #if PY_VERSION_HEX < 0x02030000 + static +@@ -850,10 +931,13 @@ + + if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback); + if (value) { ++ char *tmp; + PyObject *old_str = PyObject_Str(value); + PyErr_Clear(); + Py_XINCREF(type); +- PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg); ++ ++ PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg); ++ SWIG_Python_str_DelForPy3(tmp); + Py_DECREF(old_str); + Py_DECREF(value); + } else { +@@ -861,8 +945,6 @@ + } + } + +- +- + #if defined(SWIG_PYTHON_NO_THREADS) + # if defined(SWIG_PYTHON_THREADS) + # undef SWIG_PYTHON_THREADS +@@ -959,6 +1041,20 @@ + swig_type_info **ptype; + } swig_const_info; + ++ ++/* ----------------------------------------------------------------------------- ++ * Wrapper of PyInstanceMethod_New() used in Python 3 ++ * It is exported to the generated module, used for -fastproxy ++ * ----------------------------------------------------------------------------- */ ++SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *self, PyObject *func) ++{ ++#if PY_VERSION_HEX >= 0x03000000 ++ return PyInstanceMethod_New(func); ++#else ++ return NULL; ++#endif ++} ++ + #ifdef __cplusplus + #if 0 + { /* cc-mode */ +@@ -1011,7 +1107,7 @@ + + #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_NewClientData(obj) SwigPyClientData_New(obj) + + #define SWIG_SetErrorObj SWIG_Python_SetErrorObj + #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg +@@ -1207,7 +1303,7 @@ + return none; + } + +-/* PySwigClientData */ ++/* SwigPyClientData */ + + typedef struct { + PyObject *klass; +@@ -1216,30 +1312,30 @@ + PyObject *destroy; + int delargs; + int implicitconv; +-} PySwigClientData; ++} SwigPyClientData; + + SWIGRUNTIMEINLINE int + SWIG_Python_CheckImplicit(swig_type_info *ty) + { +- PySwigClientData *data = (PySwigClientData *)ty->clientdata; ++ SwigPyClientData *data = (SwigPyClientData *)ty->clientdata; + return data ? data->implicitconv : 0; + } + + SWIGRUNTIMEINLINE PyObject * + SWIG_Python_ExceptionType(swig_type_info *desc) { +- PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0; ++ SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0; + PyObject *klass = data ? data->klass : 0; + return (klass ? klass : PyExc_RuntimeError); + } + + +-SWIGRUNTIME PySwigClientData * +-PySwigClientData_New(PyObject* obj) ++SWIGRUNTIME SwigPyClientData * ++SwigPyClientData_New(PyObject* obj) + { + if (!obj) { + return 0; + } else { +- PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData)); ++ SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData)); + /* the klass element */ + data->klass = obj; + Py_INCREF(data->klass); +@@ -1287,14 +1383,14 @@ + } + + SWIGRUNTIME void +-PySwigClientData_Del(PySwigClientData* data) ++SwigPyClientData_Del(SwigPyClientData* data) + { + Py_XDECREF(data->newraw); + Py_XDECREF(data->newargs); + Py_XDECREF(data->destroy); + } + +-/* =============== PySwigObject =====================*/ ++/* =============== SwigPyObject =====================*/ + + typedef struct { + PyObject_HEAD +@@ -1302,24 +1398,28 @@ + swig_type_info *ty; + int own; + PyObject *next; +-} PySwigObject; ++} SwigPyObject; + + SWIGRUNTIME PyObject * +-PySwigObject_long(PySwigObject *v) ++SwigPyObject_long(SwigPyObject *v) + { + return PyLong_FromVoidPtr(v->ptr); + } + + SWIGRUNTIME PyObject * +-PySwigObject_format(const char* fmt, PySwigObject *v) ++SwigPyObject_format(const char* fmt, SwigPyObject *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 (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) { ++ PyObject *ofmt = SWIG_Python_str_FromChar(fmt); + if (ofmt) { ++#if PY_VERSION_HEX >= 0x03000000 ++ res = PyUnicode_Format(ofmt,args); ++#else + res = PyString_Format(ofmt,args); ++#endif + Py_DECREF(ofmt); + } + Py_DECREF(args); +@@ -1329,49 +1429,59 @@ + } + + SWIGRUNTIME PyObject * +-PySwigObject_oct(PySwigObject *v) ++SwigPyObject_oct(SwigPyObject *v) + { +- return PySwigObject_format("%o",v); ++ return SwigPyObject_format("%o",v); + } + + SWIGRUNTIME PyObject * +-PySwigObject_hex(PySwigObject *v) ++SwigPyObject_hex(SwigPyObject *v) + { +- return PySwigObject_format("%x",v); ++ return SwigPyObject_format("%x",v); + } + + SWIGRUNTIME PyObject * + #ifdef METH_NOARGS +-PySwigObject_repr(PySwigObject *v) ++SwigPyObject_repr(SwigPyObject *v) + #else +-PySwigObject_repr(PySwigObject *v, PyObject *args) ++SwigPyObject_repr(SwigPyObject *v, PyObject *args) + #endif + { + const char *name = SWIG_TypePrettyName(v->ty); +- PyObject *hex = PySwigObject_hex(v); +- PyObject *repr = PyString_FromFormat("", name, PyString_AsString(hex)); ++ PyObject *hex = SwigPyObject_hex(v); ++ PyObject *repr = SWIG_Python_str_FromFormat("", name, hex); + Py_DECREF(hex); + if (v->next) { + #ifdef METH_NOARGS +- PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next); ++ PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next); + #else +- PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args); ++ PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args); + #endif ++#if PY_VERSION_HEX >= 0x03000000 ++ PyObject *joined = PyUnicode_Concat(repr, nrep); ++ Py_DecRef(repr); ++ Py_DecRef(nrep); ++ repr = joined; ++#else + PyString_ConcatAndDel(&repr,nrep); ++#endif + } + return repr; + } + + SWIGRUNTIME int +-PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) ++SwigPyObject_print(SwigPyObject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) + { ++ char *str; + #ifdef METH_NOARGS +- PyObject *repr = PySwigObject_repr(v); ++ PyObject *repr = SwigPyObject_repr(v); + #else +- PyObject *repr = PySwigObject_repr(v, NULL); ++ PyObject *repr = SwigPyObject_repr(v, NULL); + #endif + if (repr) { +- fputs(PyString_AsString(repr), fp); ++ str = SWIG_Python_str_AsChar(repr); ++ fputs(str, fp); ++ SWIG_Python_str_DelForPy3(str); + Py_DECREF(repr); + return 0; + } else { +@@ -1380,53 +1490,71 @@ + } + + SWIGRUNTIME PyObject * +-PySwigObject_str(PySwigObject *v) ++SwigPyObject_str(SwigPyObject *v) + { + char result[SWIG_BUFFER_SIZE]; + return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ? +- PyString_FromString(result) : 0; ++ SWIG_Python_str_FromChar(result) : 0; + } + + SWIGRUNTIME int +-PySwigObject_compare(PySwigObject *v, PySwigObject *w) ++SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w) + { + void *i = v->ptr; + void *j = w->ptr; + return (i < j) ? -1 : ((i > j) ? 1 : 0); + } + ++/* Added for Python 3.x, whould it also useful for Python 2.x? */ ++SWIGRUNTIME PyObject* ++SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op) ++{ ++ PyObject* res; ++ if( op != Py_EQ && op != Py_NE ) { ++ Py_INCREF(Py_NotImplemented); ++ return Py_NotImplemented; ++ } ++ if( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ) ++ res = Py_True; ++ else ++ res = Py_False; ++ Py_INCREF(res); ++ return res; ++} ++ ++ + SWIGRUNTIME PyTypeObject* _PySwigObject_type(void); + + SWIGRUNTIME PyTypeObject* +-PySwigObject_type(void) { ++SwigPyObject_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); ++SwigPyObject_Check(PyObject *op) { ++ return (Py_TYPE(op) == SwigPyObject_type()) ++ || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0); + } + + SWIGRUNTIME PyObject * +-PySwigObject_New(void *ptr, swig_type_info *ty, int own); ++SwigPyObject_New(void *ptr, swig_type_info *ty, int own); + + SWIGRUNTIME void +-PySwigObject_dealloc(PyObject *v) ++SwigPyObject_dealloc(PyObject *v) + { +- PySwigObject *sobj = (PySwigObject *) v; ++ SwigPyObject *sobj = (SwigPyObject *) v; + PyObject *next = sobj->next; + if (sobj->own == SWIG_POINTER_OWN) { + swig_type_info *ty = sobj->ty; +- PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0; ++ SwigPyClientData *data = ty ? (SwigPyClientData *) 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); ++ PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0); + res = SWIG_Python_CallFunctor(destroy, tmp); + Py_DECREF(tmp); + } else { +@@ -1448,15 +1576,15 @@ + } + + SWIGRUNTIME PyObject* +-PySwigObject_append(PyObject* v, PyObject* next) ++SwigPyObject_append(PyObject* v, PyObject* next) + { +- PySwigObject *sobj = (PySwigObject *) v; ++ SwigPyObject *sobj = (SwigPyObject *) v; + #ifndef METH_O + PyObject *tmp = 0; + if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL; + next = tmp; + #endif +- if (!PySwigObject_Check(next)) { ++ if (!SwigPyObject_Check(next)) { + return NULL; + } + sobj->next = next; +@@ -1466,12 +1594,12 @@ + + SWIGRUNTIME PyObject* + #ifdef METH_NOARGS +-PySwigObject_next(PyObject* v) ++SwigPyObject_next(PyObject* v) + #else +-PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) ++SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) + #endif + { +- PySwigObject *sobj = (PySwigObject *) v; ++ SwigPyObject *sobj = (SwigPyObject *) v; + if (sobj->next) { + Py_INCREF(sobj->next); + return sobj->next; +@@ -1482,30 +1610,30 @@ + + SWIGINTERN PyObject* + #ifdef METH_NOARGS +-PySwigObject_disown(PyObject *v) ++SwigPyObject_disown(PyObject *v) + #else +-PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) ++SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) + #endif + { +- PySwigObject *sobj = (PySwigObject *)v; ++ SwigPyObject *sobj = (SwigPyObject *)v; + sobj->own = 0; + return SWIG_Py_Void(); + } + + SWIGINTERN PyObject* + #ifdef METH_NOARGS +-PySwigObject_acquire(PyObject *v) ++SwigPyObject_acquire(PyObject *v) + #else +-PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) ++SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) + #endif + { +- PySwigObject *sobj = (PySwigObject *)v; ++ SwigPyObject *sobj = (SwigPyObject *)v; + sobj->own = SWIG_POINTER_OWN; + return SWIG_Py_Void(); + } + + SWIGINTERN PyObject* +-PySwigObject_own(PyObject *v, PyObject *args) ++SwigPyObject_own(PyObject *v, PyObject *args) + { + PyObject *val = 0; + #if (PY_VERSION_HEX < 0x02020000) +@@ -1518,20 +1646,20 @@ + } + else + { +- PySwigObject *sobj = (PySwigObject *)v; ++ SwigPyObject *sobj = (SwigPyObject *)v; + PyObject *obj = PyBool_FromLong(sobj->own); + if (val) { + #ifdef METH_NOARGS + if (PyObject_IsTrue(val)) { +- PySwigObject_acquire(v); ++ SwigPyObject_acquire(v); + } else { +- PySwigObject_disown(v); ++ SwigPyObject_disown(v); + } + #else + if (PyObject_IsTrue(val)) { +- PySwigObject_acquire(v,args); ++ SwigPyObject_acquire(v,args); + } else { +- PySwigObject_disown(v,args); ++ SwigPyObject_disown(v,args); + } + #endif + } +@@ -1542,30 +1670,30 @@ + #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"}, ++ {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"}, ++ {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"}, ++ {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, ++ {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"}, ++ {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"}, ++ {(char *)"__repr__",(PyCFunction)SwigPyObject_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"}, ++ {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"}, ++ {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"}, ++ {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, ++ {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"}, ++ {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"}, ++ {(char *)"__repr__",(PyCFunction)SwigPyObject_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) ++SwigPyObject_getattr(SwigPyObject *sobj,char *name) + { + return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name); + } +@@ -1575,11 +1703,14 @@ + _PySwigObject_type(void) { + static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; + +- static PyNumberMethods PySwigObject_as_number = { ++ static PyNumberMethods SwigPyObject_as_number = { + (binaryfunc)0, /*nb_add*/ + (binaryfunc)0, /*nb_subtract*/ + (binaryfunc)0, /*nb_multiply*/ ++ /* nb_divide removed in Python 3 */ ++#if PY_VERSION_HEX < 0x03000000 + (binaryfunc)0, /*nb_divide*/ ++#endif + (binaryfunc)0, /*nb_remainder*/ + (binaryfunc)0, /*nb_divmod*/ + (ternaryfunc)0,/*nb_power*/ +@@ -1593,13 +1724,23 @@ + 0, /*nb_and*/ + 0, /*nb_xor*/ + 0, /*nb_or*/ +- (coercion)0, /*nb_coerce*/ +- (unaryfunc)PySwigObject_long, /*nb_int*/ +- (unaryfunc)PySwigObject_long, /*nb_long*/ ++#if PY_VERSION_HEX < 0x03000000 ++ 0, /*nb_coerce*/ ++#endif ++ (unaryfunc)SwigPyObject_long, /*nb_int*/ ++#if PY_VERSION_HEX < 0x03000000 ++ (unaryfunc)SwigPyObject_long, /*nb_long*/ ++#else ++ 0, /*nb_reserved*/ ++#endif + (unaryfunc)0, /*nb_float*/ +- (unaryfunc)PySwigObject_oct, /*nb_oct*/ +- (unaryfunc)PySwigObject_hex, /*nb_hex*/ +-#if PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */ ++#if PY_VERSION_HEX < 0x03000000 ++ (unaryfunc)SwigPyObject_oct, /*nb_oct*/ ++ (unaryfunc)SwigPyObject_hex, /*nb_hex*/ ++#endif ++#if PY_VERSION_HEX >= 0x03000000 /* 3.0 */ ++ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */ ++#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */ + #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ +@@ -1608,32 +1749,41 @@ + #endif + }; + +- static PyTypeObject pyswigobject_type; ++ static PyTypeObject swigpyobject_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp + = { ++ /* PyOjbect header changed in Python 3 */ ++#if PY_VERSION_HEX >= 0x03000000 ++ PyVarObject_HEAD_INIT(&PyType_Type, 0) ++#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +- (char *)"PySwigObject", /* tp_name */ +- sizeof(PySwigObject), /* tp_basicsize */ ++#endif ++ (char *)"SwigPyObject", /* tp_name */ ++ sizeof(SwigPyObject), /* tp_basicsize */ + 0, /* tp_itemsize */ +- (destructor)PySwigObject_dealloc, /* tp_dealloc */ +- (printfunc)PySwigObject_print, /* tp_print */ ++ (destructor)SwigPyObject_dealloc, /* tp_dealloc */ ++ (printfunc)SwigPyObject_print, /* tp_print */ + #if PY_VERSION_HEX < 0x02020000 +- (getattrfunc)PySwigObject_getattr, /* tp_getattr */ ++ (getattrfunc)SwigPyObject_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 */ ++#if PY_VERSION_HEX >= 0x03000000 ++ 0, /* tp_reserved in 3.0.1 */ ++#else ++ (cmpfunc)SwigPyObject_compare, /* tp_compare */ ++#endif ++ (reprfunc)SwigPyObject_repr, /* tp_repr */ ++ &SwigPyObject_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 */ ++ (reprfunc)SwigPyObject_str, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ +@@ -1641,7 +1791,7 @@ + swigobject_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ +- 0, /* tp_richcompare */ ++ (richcmpfunc)SwigPyObject_richcompare, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + #if PY_VERSION_HEX >= 0x02020000 + 0, /* tp_iter */ +@@ -1658,11 +1808,11 @@ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ +- 0, /* tp_is_gc */ ++ 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ +- 0, /* tp_subclasses */ ++ 0, /* tp_subclasses */ + 0, /* tp_weaklist */ + #endif + #if PY_VERSION_HEX >= 0x02030000 +@@ -1672,17 +1822,20 @@ + 0,0,0,0 /* tp_alloc -> tp_next */ + #endif + }; +- pyswigobject_type = tmp; +- pyswigobject_type.ob_type = &PyType_Type; ++ swigpyobject_type = tmp; ++ /* for Python 3 we already assigned the ob_type in PyVarObject_HEAD_INIT() */ ++#if PY_VERSION_HEX < 0x03000000 ++ swigpyobject_type.ob_type = &PyType_Type; ++#endif + type_init = 1; + } +- return &pyswigobject_type; ++ return &swigpyobject_type; + } + + SWIGRUNTIME PyObject * +-PySwigObject_New(void *ptr, swig_type_info *ty, int own) ++SwigPyObject_New(void *ptr, swig_type_info *ty, int own) + { +- PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type()); ++ SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type()); + if (sobj) { + sobj->ptr = ptr; + sobj->ty = ty; +@@ -1701,10 +1854,10 @@ + void *pack; + swig_type_info *ty; + size_t size; +-} PySwigPacked; ++} SwigPyPacked; + + SWIGRUNTIME int +-PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags)) ++SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags)) + { + char result[SWIG_BUFFER_SIZE]; + fputs("pack, v->size, 0, sizeof(result))) { +- return PyString_FromFormat("", result, v->ty->name); ++ return SWIG_Python_str_FromFormat("", result, v->ty->name); + } else { +- return PyString_FromFormat("", v->ty->name); ++ return SWIG_Python_str_FromFormat("", v->ty->name); + } + } + + SWIGRUNTIME PyObject * +-PySwigPacked_str(PySwigPacked *v) ++SwigPyPacked_str(SwigPyPacked *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); ++ return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name); + } else { +- return PyString_FromString(v->ty->name); ++ return SWIG_Python_str_FromChar(v->ty->name); + } + } + + SWIGRUNTIME int +-PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w) ++SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w) + { + size_t i = v->size; + size_t j = w->size; +@@ -1751,22 +1904,22 @@ + SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void); + + SWIGRUNTIME PyTypeObject* +-PySwigPacked_type(void) { ++SwigPyPacked_type(void) { + static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type(); + return type; + } + + SWIGRUNTIMEINLINE int +-PySwigPacked_Check(PyObject *op) { ++SwigPyPacked_Check(PyObject *op) { + return ((op)->ob_type == _PySwigPacked_type()) +- || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0); ++ || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0); + } + + SWIGRUNTIME void +-PySwigPacked_dealloc(PyObject *v) ++SwigPyPacked_dealloc(PyObject *v) + { +- if (PySwigPacked_Check(v)) { +- PySwigPacked *sobj = (PySwigPacked *) v; ++ if (SwigPyPacked_Check(v)) { ++ SwigPyPacked *sobj = (SwigPyPacked *) v; + free(sobj->pack); + } + PyObject_DEL(v); +@@ -1775,28 +1928,37 @@ + SWIGRUNTIME PyTypeObject* + _PySwigPacked_type(void) { + static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; +- static PyTypeObject pyswigpacked_type; ++ static PyTypeObject swigpypacked_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp + = { ++ /* PyObject header changed in Python 3 */ ++#if PY_VERSION_HEX>=0x03000000 ++ PyVarObject_HEAD_INIT(&PyType_Type, 0) ++#else + PyObject_HEAD_INIT(NULL) +- 0, /* ob_size */ +- (char *)"PySwigPacked", /* tp_name */ +- sizeof(PySwigPacked), /* tp_basicsize */ ++ 0, /* ob_size */ ++#endif ++ (char *)"SwigPyPacked", /* tp_name */ ++ sizeof(SwigPyPacked), /* tp_basicsize */ + 0, /* tp_itemsize */ +- (destructor)PySwigPacked_dealloc, /* tp_dealloc */ +- (printfunc)PySwigPacked_print, /* tp_print */ ++ (destructor)SwigPyPacked_dealloc, /* tp_dealloc */ ++ (printfunc)SwigPyPacked_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 */ ++#if PY_VERSION_HEX>=0x03000000 ++ 0, /* tp_reserved in 3.0.1 */ ++#else ++ (cmpfunc)SwigPyPacked_compare, /* tp_compare */ ++#endif ++ (reprfunc)SwigPyPacked_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 */ ++ 0, /* tp_as_mapping */ ++ (hashfunc)0, /* tp_hash */ ++ (ternaryfunc)0, /* tp_call */ ++ (reprfunc)SwigPyPacked_str, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ +@@ -1835,17 +1997,20 @@ + 0,0,0,0 /* tp_alloc -> tp_next */ + #endif + }; +- pyswigpacked_type = tmp; +- pyswigpacked_type.ob_type = &PyType_Type; ++ swigpypacked_type = tmp; ++ /* for Python 3 the ob_type already assigned in PyVarObject_HEAD_INIT() */ ++#if PY_VERSION_HEX < 0x03000000 ++ swigpypacked_type.ob_type = &PyType_Type; ++#endif + type_init = 1; + } +- return &pyswigpacked_type; ++ return &swigpypacked_type; + } + + SWIGRUNTIME PyObject * +-PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty) ++SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty) + { +- PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type()); ++ SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type()); + if (sobj) { + void *pack = malloc(size); + if (pack) { +@@ -1862,10 +2027,10 @@ + } + + SWIGRUNTIME swig_type_info * +-PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size) ++SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size) + { +- if (PySwigPacked_Check(obj)) { +- PySwigPacked *sobj = (PySwigPacked *)obj; ++ if (SwigPyPacked_Check(obj)) { ++ SwigPyPacked *sobj = (SwigPyPacked *)obj; + if (sobj->size != size) return 0; + memcpy(ptr, sobj->pack, size); + return sobj->ty; +@@ -1881,7 +2046,7 @@ + SWIGRUNTIMEINLINE PyObject * + _SWIG_This(void) + { +- return PyString_FromString("this"); ++ return SWIG_Python_str_FromChar("this"); + } + + SWIGRUNTIME PyObject * +@@ -1893,11 +2058,16 @@ + + /* #define SWIG_PYTHON_SLOW_GETSET_THIS */ + +-SWIGRUNTIME PySwigObject * ++/* TODO: I don't know how to implement the fast getset in Python 3 right now */ ++#if PY_VERSION_HEX>=0x03000000 ++#define SWIG_PYTHON_SLOW_GETSET_THIS ++#endif ++ ++SWIGRUNTIME SwigPyObject * + SWIG_Python_GetSwigThis(PyObject *pyobj) + { +- if (PySwigObject_Check(pyobj)) { +- return (PySwigObject *) pyobj; ++ if (SwigPyObject_Check(pyobj)) { ++ return (SwigPyObject *) pyobj; + } else { + PyObject *obj = 0; + #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000)) +@@ -1933,12 +2103,12 @@ + return 0; + } + #endif +- if (obj && !PySwigObject_Check(obj)) { ++ if (obj && !SwigPyObject_Check(obj)) { + /* a PyObject is called 'this', try to get the 'real this' +- PySwigObject from it */ ++ SwigPyObject from it */ + return SWIG_Python_GetSwigThis(obj); + } +- return (PySwigObject *)obj; ++ return (SwigPyObject *)obj; + } + } + +@@ -1947,7 +2117,7 @@ + SWIGRUNTIME int + SWIG_Python_AcquirePtr(PyObject *obj, int own) { + if (own == SWIG_POINTER_OWN) { +- PySwigObject *sobj = SWIG_Python_GetSwigThis(obj); ++ SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj); + if (sobj) { + int oldown = sobj->own; + sobj->own = own; +@@ -1966,7 +2136,7 @@ + if (ptr) *ptr = 0; + return SWIG_OK; + } else { +- PySwigObject *sobj = SWIG_Python_GetSwigThis(obj); ++ SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj); + if (own) + *own = 0; + while (sobj) { +@@ -1980,7 +2150,7 @@ + } else { + swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); + if (!tc) { +- sobj = (PySwigObject *)sobj->next; ++ sobj = (SwigPyObject *)sobj->next; + } else { + if (ptr) { + int newmemory = 0; +@@ -2009,7 +2179,7 @@ + } else { + int res = SWIG_ERROR; + if (flags & SWIG_POINTER_IMPLICIT_CONV) { +- PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0; ++ SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; + if (data && !data->implicitconv) { + PyObject *klass = data->klass; + if (klass) { +@@ -2022,7 +2192,7 @@ + impconv = 0; + } + if (impconv) { +- PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv); ++ SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv); + if (iobj) { + void *vptr; + res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0); +@@ -2084,7 +2254,7 @@ + + 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); ++ swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz); + if (!to) return SWIG_ERROR; + if (ty) { + if (to != ty) { +@@ -2106,7 +2276,7 @@ + */ + + SWIGRUNTIME PyObject* +-SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this) ++SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) + { + #if (PY_VERSION_HEX >= 0x02020000) + PyObject *inst = 0; +@@ -2130,10 +2300,16 @@ + #endif + } + } else { ++#if PY_VERSION_HEX >= 0x03000000 ++ inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None); ++ PyObject_SetAttr(inst, SWIG_This(), swig_this); ++ Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG; ++#else + PyObject *dict = PyDict_New(); + PyDict_SetItem(dict, SWIG_This(), swig_this); + inst = PyInstance_NewRaw(data->newargs, dict); + Py_DECREF(dict); ++#endif + } + return inst; + #else +@@ -2196,9 +2372,9 @@ + if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) { + return NULL; + } else { +- PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]); ++ SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]); + if (sthis) { +- PySwigObject_append((PyObject*) sthis, obj[1]); ++ SwigPyObject_append((PyObject*) sthis, obj[1]); + } else { + SWIG_Python_SetSwigThis(obj[0], obj[1]); + } +@@ -2214,8 +2390,8 @@ + 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; ++ PyObject *robj = SwigPyObject_New(ptr, type, own); ++ SwigPyClientData *clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0; + if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) { + PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj); + if (inst) { +@@ -2231,7 +2407,7 @@ + + 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(); ++ return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void(); + } + + /* -----------------------------------------------------------------------------* +@@ -2302,8 +2478,8 @@ + 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); ++ SwigPyClientData *data = (SwigPyClientData *) ty->clientdata; ++ if (data) SwigPyClientData_Del(data); + } + } + Py_DECREF(SWIG_This()); +@@ -2313,8 +2489,13 @@ + SWIG_Python_SetModule(swig_module_info *swig_module) { + static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */ + ++#if PY_VERSION_HEX >= 0x03000000 ++ /* Add a dummy module object into sys.modules */ ++ PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION); ++#else + PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, + swig_empty_runtime_method_table); ++#endif + PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule); + if (pointer && module) { + PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer); +@@ -2334,7 +2515,7 @@ + SWIG_Python_TypeQuery(const char *type) + { + PyObject *cache = SWIG_Python_TypeCache(); +- PyObject *key = PyString_FromString(type); ++ PyObject *key = SWIG_Python_str_FromChar(type); + PyObject *obj = PyDict_GetItem(cache, key); + swig_type_info *descriptor; + if (obj) { +@@ -2361,21 +2542,23 @@ + + 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) { ++ char *tmp; + PyObject *old_str = PyObject_Str(value); + Py_XINCREF(type); + PyErr_Clear(); + if (infront) { +- PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str)); ++ PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str)); + } else { +- PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg); ++ PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg); + } ++ SWIG_Python_str_DelForPy3(tmp); + Py_DECREF(old_str); + } + return 1; +@@ -2398,9 +2581,9 @@ + } + + SWIGRUNTIMEINLINE const char * +-PySwigObject_GetDesc(PyObject *self) ++SwigPyObject_GetDesc(PyObject *self) + { +- PySwigObject *v = (PySwigObject *)self; ++ SwigPyObject *v = (SwigPyObject *)self; + swig_type_info *ty = v ? v->ty : 0; + return ty ? ty->str : (char*)""; + } +@@ -2410,10 +2593,10 @@ + { + if (type) { + #if defined(SWIG_COBJECT_TYPES) +- if (obj && PySwigObject_Check(obj)) { +- const char *otype = (const char *) PySwigObject_GetDesc(obj); ++ if (obj && SwigPyObject_Check(obj)) { ++ const char *otype = (const char *) SwigPyObject_GetDesc(obj); + if (otype) { +- PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received", ++ PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received", + type, otype); + return; + } +@@ -2423,10 +2606,11 @@ + 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; ++ const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0; + if (cstr) { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", + type, otype, cstr); ++ SWIG_Python_str_DelForPy3(cstr); + } else { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", + type, otype); +@@ -2448,10 +2632,12 @@ + void *result; + if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { + PyErr_Clear(); +- if (flags & SWIG_POINTER_EXCEPTION) { ++#if SWIG_POINTER_EXCEPTION ++ if (flags) { + SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); + SWIG_Python_ArgFail(argnum); + } ++#endif + } + return result; + } +@@ -2498,38 +2684,39 @@ + #define SWIGTYPE_p_p_semanage_context swig_types[21] + #define SWIGTYPE_p_p_semanage_fcontext swig_types[22] + #define SWIGTYPE_p_p_semanage_fcontext_key swig_types[23] +-#define SWIGTYPE_p_p_semanage_iface swig_types[24] +-#define SWIGTYPE_p_p_semanage_iface_key swig_types[25] +-#define SWIGTYPE_p_p_semanage_module_info swig_types[26] +-#define SWIGTYPE_p_p_semanage_node swig_types[27] +-#define SWIGTYPE_p_p_semanage_node_key swig_types[28] +-#define SWIGTYPE_p_p_semanage_port swig_types[29] +-#define SWIGTYPE_p_p_semanage_port_key swig_types[30] +-#define SWIGTYPE_p_p_semanage_seuser swig_types[31] +-#define SWIGTYPE_p_p_semanage_seuser_key swig_types[32] +-#define SWIGTYPE_p_p_semanage_user swig_types[33] +-#define SWIGTYPE_p_p_semanage_user_key swig_types[34] +-#define SWIGTYPE_p_semanage_bool swig_types[35] +-#define SWIGTYPE_p_semanage_bool_key swig_types[36] +-#define SWIGTYPE_p_semanage_context swig_types[37] +-#define SWIGTYPE_p_semanage_fcontext swig_types[38] +-#define SWIGTYPE_p_semanage_fcontext_key swig_types[39] +-#define SWIGTYPE_p_semanage_handle swig_types[40] +-#define SWIGTYPE_p_semanage_iface swig_types[41] +-#define SWIGTYPE_p_semanage_iface_key swig_types[42] +-#define SWIGTYPE_p_semanage_module_info swig_types[43] +-#define SWIGTYPE_p_semanage_node swig_types[44] +-#define SWIGTYPE_p_semanage_node_key swig_types[45] +-#define SWIGTYPE_p_semanage_port swig_types[46] +-#define SWIGTYPE_p_semanage_port_key swig_types[47] +-#define SWIGTYPE_p_semanage_seuser swig_types[48] +-#define SWIGTYPE_p_semanage_seuser_key swig_types[49] +-#define SWIGTYPE_p_semanage_user swig_types[50] +-#define SWIGTYPE_p_semanage_user_key swig_types[51] +-#define SWIGTYPE_p_size_t swig_types[52] +-#define SWIGTYPE_p_unsigned_int swig_types[53] +-static swig_type_info *swig_types[55]; +-static swig_module_info swig_module = {swig_types, 54, 0, 0, 0, 0}; ++#define SWIGTYPE_p_p_semanage_handle_t swig_types[24] ++#define SWIGTYPE_p_p_semanage_iface swig_types[25] ++#define SWIGTYPE_p_p_semanage_iface_key swig_types[26] ++#define SWIGTYPE_p_p_semanage_module_info swig_types[27] ++#define SWIGTYPE_p_p_semanage_node swig_types[28] ++#define SWIGTYPE_p_p_semanage_node_key swig_types[29] ++#define SWIGTYPE_p_p_semanage_port swig_types[30] ++#define SWIGTYPE_p_p_semanage_port_key swig_types[31] ++#define SWIGTYPE_p_p_semanage_seuser swig_types[32] ++#define SWIGTYPE_p_p_semanage_seuser_key swig_types[33] ++#define SWIGTYPE_p_p_semanage_user swig_types[34] ++#define SWIGTYPE_p_p_semanage_user_key swig_types[35] ++#define SWIGTYPE_p_semanage_bool swig_types[36] ++#define SWIGTYPE_p_semanage_bool_key swig_types[37] ++#define SWIGTYPE_p_semanage_context swig_types[38] ++#define SWIGTYPE_p_semanage_fcontext swig_types[39] ++#define SWIGTYPE_p_semanage_fcontext_key swig_types[40] ++#define SWIGTYPE_p_semanage_handle swig_types[41] ++#define SWIGTYPE_p_semanage_iface swig_types[42] ++#define SWIGTYPE_p_semanage_iface_key swig_types[43] ++#define SWIGTYPE_p_semanage_module_info swig_types[44] ++#define SWIGTYPE_p_semanage_node swig_types[45] ++#define SWIGTYPE_p_semanage_node_key swig_types[46] ++#define SWIGTYPE_p_semanage_port swig_types[47] ++#define SWIGTYPE_p_semanage_port_key swig_types[48] ++#define SWIGTYPE_p_semanage_seuser swig_types[49] ++#define SWIGTYPE_p_semanage_seuser_key swig_types[50] ++#define SWIGTYPE_p_semanage_user swig_types[51] ++#define SWIGTYPE_p_semanage_user_key swig_types[52] ++#define SWIGTYPE_p_size_t swig_types[53] ++#define SWIGTYPE_p_unsigned_int swig_types[54] ++static swig_type_info *swig_types[56]; ++static swig_module_info swig_module = {swig_types, 55, 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) + +@@ -2544,11 +2731,16 @@ + /*----------------------------------------------- + @(target):= _semanage.so + ------------------------------------------------*/ +-#define SWIG_init init_semanage ++#if PY_VERSION_HEX >= 0x03000000 ++# define SWIG_init PyInit__semanage + ++#else ++# define SWIG_init init_semanage ++ ++#endif + #define SWIG_name "_semanage" + +-#define SWIGVERSION 0x010335 ++#define SWIGVERSION 0x010339 + #define SWIG_VERSION SWIGVERSION + + +@@ -2595,7 +2787,11 @@ + return pchar_descriptor ? + SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void(); + } else { ++#if PY_VERSION_HEX >= 0x03000000 ++ return PyUnicode_FromStringAndSize(carray, (int)(size)); ++#else + return PyString_FromStringAndSize(carray, (int)(size)); ++#endif + } + } else { + return SWIG_Py_Void(); +@@ -2613,10 +2809,28 @@ + SWIGINTERN int + SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) + { +- if (PyString_Check(obj)) { ++#if PY_VERSION_HEX>=0x03000000 ++ if (PyUnicode_Check(obj)) ++#else ++ if (PyString_Check(obj)) ++#endif ++ { + char *cstr; Py_ssize_t len; ++#if PY_VERSION_HEX>=0x03000000 ++ if (!alloc && cptr) { ++ /* We can't allow converting without allocation, since the internal ++ representation of string in Python 3 is UCS-2/UCS-4 but we require ++ a UTF-8 representation. ++ TODO(bhy) More detailed explanation */ ++ return SWIG_RuntimeError; ++ } ++ obj = PyUnicode_AsUTF8String(obj); ++ PyBytes_AsStringAndSize(obj, &cstr, &len); ++ if(alloc) *alloc = SWIG_NEWOBJ; ++#else + PyString_AsStringAndSize(obj, &cstr, &len); +- if (cptr) { ++#endif ++ if (cptr) { + if (alloc) { + /* + In python the user should not be able to modify the inner +@@ -2641,10 +2855,16 @@ + *alloc = SWIG_OLDOBJ; + } + } else { +- *cptr = PyString_AsString(obj); ++ #if PY_VERSION_HEX>=0x03000000 ++ assert(0); /* Should never reach here in Python 3 */ ++ #endif ++ *cptr = SWIG_Python_str_AsChar(obj); + } + } + if (psize) *psize = len + 1; ++#if PY_VERSION_HEX>=0x03000000 ++ Py_XDECREF(obj); ++#endif + return SWIG_OK; + } else { + swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); +@@ -2947,10 +3167,10 @@ + SWIGINTERN PyObject *_wrap_semanage_msg_get_level(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_msg_get_level",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -2969,10 +3189,10 @@ + SWIGINTERN PyObject *_wrap_semanage_msg_get_channel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- char *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_msg_get_channel",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -2991,10 +3211,10 @@ + SWIGINTERN PyObject *_wrap_semanage_msg_get_fname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- char *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_msg_get_fname",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -3125,10 +3345,10 @@ + SWIGINTERN PyObject *_wrap_semanage_reload_policy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_reload_policy",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -3267,10 +3487,10 @@ + SWIGINTERN PyObject *_wrap_semanage_is_managed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_is_managed",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -3289,10 +3509,10 @@ + SWIGINTERN PyObject *_wrap_semanage_connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_connect",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -3311,10 +3531,10 @@ + SWIGINTERN PyObject *_wrap_semanage_disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_disconnect",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -3333,10 +3553,10 @@ + SWIGINTERN PyObject *_wrap_semanage_begin_transaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_begin_transaction",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -3355,10 +3575,10 @@ + SWIGINTERN PyObject *_wrap_semanage_commit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_commit",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -3377,10 +3597,10 @@ + SWIGINTERN PyObject *_wrap_semanage_access_check(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_access_check",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -3399,10 +3619,10 @@ + SWIGINTERN PyObject *_wrap_semanage_is_connected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_is_connected",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -3421,10 +3641,10 @@ + SWIGINTERN PyObject *_wrap_semanage_mls_enabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_mls_enabled",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -3445,7 +3665,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + char *arg2 = (char *) 0 ; + size_t arg3 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; +@@ -3456,6 +3675,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_module_install",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -3487,7 +3707,6 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + char *arg2 = (char *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; +@@ -3495,6 +3714,7 @@ + int alloc2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_module_install_file",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -3522,7 +3742,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + char *arg2 = (char *) 0 ; + size_t arg3 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; +@@ -3533,6 +3752,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_module_upgrade",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -3564,7 +3784,6 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + char *arg2 = (char *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; +@@ -3572,6 +3791,7 @@ + int alloc2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_module_upgrade_file",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -3599,7 +3819,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + char *arg2 = (char *) 0 ; + size_t arg3 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; +@@ -3610,6 +3829,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_module_install_base",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -3641,7 +3861,6 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + char *arg2 = (char *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; +@@ -3649,6 +3868,7 @@ + int alloc2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_module_install_base_file",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -3675,7 +3895,6 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + char *arg2 = (char *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; +@@ -3683,6 +3902,7 @@ + int alloc2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_module_remove",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -3710,13 +3930,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_module_info_t **arg2 = (semanage_module_info_t **) 0 ; + int *arg3 = (int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_module_info_t *temp2 = NULL ; + int temp3 ; + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -3770,13 +3990,13 @@ + PyObject *resultobj = 0; + semanage_module_info_t *arg1 = (semanage_module_info_t *) 0 ; + int arg2 ; +- semanage_module_info_t *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ semanage_module_info_t *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_module_list_nth",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_module_info, 0 | 0 ); +@@ -3800,10 +4020,10 @@ + SWIGINTERN PyObject *_wrap_semanage_module_get_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_module_info_t *arg1 = (semanage_module_info_t *) 0 ; +- char *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_module_get_name",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_module_info, 0 | 0 ); +@@ -3822,10 +4042,10 @@ + SWIGINTERN PyObject *_wrap_semanage_module_get_version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_module_info_t *arg1 = (semanage_module_info_t *) 0 ; +- char *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_module_get_version",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_module_info, 0 | 0 ); +@@ -3844,10 +4064,10 @@ + SWIGINTERN PyObject *_wrap_semanage_context_get_user(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_context_t *arg1 = (semanage_context_t *) 0 ; +- char *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_context_get_user",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_context, 0 | 0 ); +@@ -3868,7 +4088,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_context_t *arg2 = (semanage_context_t *) 0 ; + char *arg3 = (char *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -3879,6 +4098,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_context_set_user",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -3909,10 +4129,10 @@ + SWIGINTERN PyObject *_wrap_semanage_context_get_role(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_context_t *arg1 = (semanage_context_t *) 0 ; +- char *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_context_get_role",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_context, 0 | 0 ); +@@ -3933,7 +4153,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_context_t *arg2 = (semanage_context_t *) 0 ; + char *arg3 = (char *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -3944,6 +4163,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_context_set_role",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -3974,10 +4194,10 @@ + SWIGINTERN PyObject *_wrap_semanage_context_get_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_context_t *arg1 = (semanage_context_t *) 0 ; +- char *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_context_get_type",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_context, 0 | 0 ); +@@ -3998,7 +4218,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_context_t *arg2 = (semanage_context_t *) 0 ; + char *arg3 = (char *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -4009,6 +4228,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_context_set_type",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -4039,10 +4259,10 @@ + SWIGINTERN PyObject *_wrap_semanage_context_get_mls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_context_t *arg1 = (semanage_context_t *) 0 ; +- char *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_context_get_mls",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_context, 0 | 0 ); +@@ -4063,7 +4283,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_context_t *arg2 = (semanage_context_t *) 0 ; + char *arg3 = (char *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -4074,6 +4293,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_context_set_mls",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -4105,11 +4325,11 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_context_t **arg2 = (semanage_context_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_context_t *temp2 = NULL ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -4136,7 +4356,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_context_t *arg2 = (semanage_context_t *) 0 ; + semanage_context_t **arg3 = (semanage_context_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -4144,6 +4363,7 @@ + semanage_context_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -4196,7 +4416,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + char *arg2 = (char *) 0 ; + semanage_context_t **arg3 = (semanage_context_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; +@@ -4205,6 +4424,7 @@ + semanage_context_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -4238,7 +4458,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_context_t *arg2 = (semanage_context_t *) 0 ; + char **arg3 = (char **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -4246,6 +4465,7 @@ + char *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -4278,7 +4498,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + char *arg2 = (char *) 0 ; + semanage_bool_key_t **arg3 = (semanage_bool_key_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; +@@ -4287,6 +4506,7 @@ + semanage_bool_key_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -4320,7 +4540,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_bool_t *arg2 = (semanage_bool_t *) 0 ; + semanage_bool_key_t **arg3 = (semanage_bool_key_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -4328,6 +4547,7 @@ + semanage_bool_key_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -4379,13 +4599,13 @@ + PyObject *resultobj = 0; + semanage_bool_t *arg1 = (semanage_bool_t *) 0 ; + semanage_bool_key_t *arg2 = (semanage_bool_key_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_compare",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_bool, 0 | 0 ); +@@ -4410,13 +4630,13 @@ + PyObject *resultobj = 0; + semanage_bool_t *arg1 = (semanage_bool_t *) 0 ; + semanage_bool_t *arg2 = (semanage_bool_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_compare2",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_bool, 0 | 0 ); +@@ -4440,10 +4660,10 @@ + SWIGINTERN PyObject *_wrap_semanage_bool_get_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_bool_t *arg1 = (semanage_bool_t *) 0 ; +- char *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_bool_get_name",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_bool, 0 | 0 ); +@@ -4464,7 +4684,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_bool_t *arg2 = (semanage_bool_t *) 0 ; + char *arg3 = (char *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -4475,6 +4694,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_bool_set_name",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -4505,10 +4725,10 @@ + SWIGINTERN PyObject *_wrap_semanage_bool_get_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_bool_t *arg1 = (semanage_bool_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_bool_get_value",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_bool, 0 | 0 ); +@@ -4558,11 +4778,11 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_bool_t **arg2 = (semanage_bool_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_bool_t *temp2 = NULL ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -4589,7 +4809,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_bool_t *arg2 = (semanage_bool_t *) 0 ; + semanage_bool_t **arg3 = (semanage_bool_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -4597,6 +4816,7 @@ + semanage_bool_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -4649,7 +4869,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_bool_key_t *arg2 = (semanage_bool_key_t *) 0 ; + semanage_bool_t **arg3 = (semanage_bool_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -4657,6 +4876,7 @@ + semanage_bool_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -4688,7 +4908,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_bool_key_t *arg2 = (semanage_bool_key_t *) 0 ; + int *arg3 = (int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -4697,6 +4916,7 @@ + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + arg3 = &temp3; + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_exists",&obj0,&obj1)) SWIG_fail; +@@ -4728,12 +4948,12 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + unsigned int *arg2 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int temp2 ; + int res2 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:semanage_bool_count",&obj0)) SWIG_fail; +@@ -4761,13 +4981,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + int (*arg2)(semanage_bool_t const *,void *) = (int (*)(semanage_bool_t const *,void *)) 0 ; + void *arg3 = (void *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_bool_iterate",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -4798,13 +5018,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_bool_t ***arg2 = (semanage_bool_t ***) 0 ; + unsigned int *arg3 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_bool_t **temp2 = NULL ; + unsigned int temp3 ; + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -4843,7 +5063,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_bool_key_t *arg2 = (semanage_bool_key_t *) 0 ; + semanage_bool_t *arg3 = (semanage_bool_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -4853,6 +5072,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_bool_modify_local",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -4882,13 +5102,13 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_bool_key_t *arg2 = (semanage_bool_key_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_del_local",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -4914,7 +5134,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_bool_key_t *arg2 = (semanage_bool_key_t *) 0 ; + semanage_bool_t **arg3 = (semanage_bool_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -4922,6 +5141,7 @@ + semanage_bool_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -4953,7 +5173,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_bool_key_t *arg2 = (semanage_bool_key_t *) 0 ; + int *arg3 = (int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -4962,6 +5181,7 @@ + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + arg3 = &temp3; + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_exists_local",&obj0,&obj1)) SWIG_fail; +@@ -4993,12 +5213,12 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + unsigned int *arg2 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int temp2 ; + int res2 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:semanage_bool_count_local",&obj0)) SWIG_fail; +@@ -5026,13 +5246,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + int (*arg2)(semanage_bool_t const *,void *) = (int (*)(semanage_bool_t const *,void *)) 0 ; + void *arg3 = (void *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_bool_iterate_local",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -5063,13 +5283,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_bool_t ***arg2 = (semanage_bool_t ***) 0 ; + unsigned int *arg3 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_bool_t **temp2 = NULL ; + unsigned int temp3 ; + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -5108,7 +5328,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_bool_key_t *arg2 = (semanage_bool_key_t *) 0 ; + semanage_bool_t *arg3 = (semanage_bool_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -5118,6 +5337,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_bool_set_active",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -5148,7 +5368,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_bool_key_t *arg2 = (semanage_bool_key_t *) 0 ; + semanage_bool_t **arg3 = (semanage_bool_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -5156,6 +5375,7 @@ + semanage_bool_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -5187,7 +5407,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_bool_key_t *arg2 = (semanage_bool_key_t *) 0 ; + int *arg3 = (int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -5196,6 +5415,7 @@ + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + arg3 = &temp3; + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_exists_active",&obj0,&obj1)) SWIG_fail; +@@ -5227,12 +5447,12 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + unsigned int *arg2 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int temp2 ; + int res2 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:semanage_bool_count_active",&obj0)) SWIG_fail; +@@ -5260,13 +5480,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + int (*arg2)(semanage_bool_t const *,void *) = (int (*)(semanage_bool_t const *,void *)) 0 ; + void *arg3 = (void *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_bool_iterate_active",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -5297,13 +5517,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_bool_t ***arg2 = (semanage_bool_t ***) 0 ; + unsigned int *arg3 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_bool_t **temp2 = NULL ; + unsigned int temp3 ; + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -5341,13 +5561,13 @@ + PyObject *resultobj = 0; + semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; + semanage_iface_key_t *arg2 = (semanage_iface_key_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_compare",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_iface, 0 | 0 ); +@@ -5372,13 +5592,13 @@ + PyObject *resultobj = 0; + semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; + semanage_iface_t *arg2 = (semanage_iface_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_compare2",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_iface, 0 | 0 ); +@@ -5404,7 +5624,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + char *arg2 = (char *) 0 ; + semanage_iface_key_t **arg3 = (semanage_iface_key_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; +@@ -5413,6 +5632,7 @@ + semanage_iface_key_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -5446,7 +5666,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_iface_t *arg2 = (semanage_iface_t *) 0 ; + semanage_iface_key_t **arg3 = (semanage_iface_key_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -5454,6 +5673,7 @@ + semanage_iface_key_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -5504,10 +5724,10 @@ + SWIGINTERN PyObject *_wrap_semanage_iface_get_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; +- char *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_iface_get_name",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_iface, 0 | 0 ); +@@ -5528,7 +5748,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_iface_t *arg2 = (semanage_iface_t *) 0 ; + char *arg3 = (char *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -5539,6 +5758,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_set_name",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -5569,10 +5789,10 @@ + SWIGINTERN PyObject *_wrap_semanage_iface_get_ifcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; +- semanage_context_t *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ semanage_context_t *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_iface_get_ifcon",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_iface, 0 | 0 ); +@@ -5593,7 +5813,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_iface_t *arg2 = (semanage_iface_t *) 0 ; + semanage_context_t *arg3 = (semanage_context_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -5603,6 +5822,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_set_ifcon",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -5631,10 +5851,10 @@ + SWIGINTERN PyObject *_wrap_semanage_iface_get_msgcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; +- semanage_context_t *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ semanage_context_t *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_iface_get_msgcon",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_iface, 0 | 0 ); +@@ -5655,7 +5875,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_iface_t *arg2 = (semanage_iface_t *) 0 ; + semanage_context_t *arg3 = (semanage_context_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -5665,6 +5884,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_set_msgcon",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -5694,11 +5914,11 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_iface_t **arg2 = (semanage_iface_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_iface_t *temp2 = NULL ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -5725,7 +5945,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_iface_t *arg2 = (semanage_iface_t *) 0 ; + semanage_iface_t **arg3 = (semanage_iface_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -5733,6 +5952,7 @@ + semanage_iface_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -5785,7 +6005,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_iface_key_t *arg2 = (semanage_iface_key_t *) 0 ; + semanage_iface_t *arg3 = (semanage_iface_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -5795,6 +6014,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_modify_local",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -5824,13 +6044,13 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_iface_key_t *arg2 = (semanage_iface_key_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_del_local",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -5856,7 +6076,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_iface_key_t *arg2 = (semanage_iface_key_t *) 0 ; + semanage_iface_t **arg3 = (semanage_iface_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -5864,6 +6083,7 @@ + semanage_iface_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -5895,7 +6115,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_iface_key_t *arg2 = (semanage_iface_key_t *) 0 ; + int *arg3 = (int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -5904,6 +6123,7 @@ + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + arg3 = &temp3; + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_exists_local",&obj0,&obj1)) SWIG_fail; +@@ -5935,12 +6155,12 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + unsigned int *arg2 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int temp2 ; + int res2 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:semanage_iface_count_local",&obj0)) SWIG_fail; +@@ -5968,13 +6188,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + int (*arg2)(semanage_iface_t const *,void *) = (int (*)(semanage_iface_t const *,void *)) 0 ; + void *arg3 = (void *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_iterate_local",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -6005,13 +6225,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_iface_t ***arg2 = (semanage_iface_t ***) 0 ; + unsigned int *arg3 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_iface_t **temp2 = NULL ; + unsigned int temp3 ; + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -6050,7 +6270,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_iface_key_t *arg2 = (semanage_iface_key_t *) 0 ; + semanage_iface_t **arg3 = (semanage_iface_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -6058,6 +6277,7 @@ + semanage_iface_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -6089,7 +6309,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_iface_key_t *arg2 = (semanage_iface_key_t *) 0 ; + int *arg3 = (int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -6098,6 +6317,7 @@ + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + arg3 = &temp3; + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_exists",&obj0,&obj1)) SWIG_fail; +@@ -6129,12 +6349,12 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + unsigned int *arg2 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int temp2 ; + int res2 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:semanage_iface_count",&obj0)) SWIG_fail; +@@ -6162,13 +6382,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + int (*arg2)(semanage_iface_t const *,void *) = (int (*)(semanage_iface_t const *,void *)) 0 ; + void *arg3 = (void *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_iterate",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -6199,13 +6419,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_iface_t ***arg2 = (semanage_iface_t ***) 0 ; + unsigned int *arg3 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_iface_t **temp2 = NULL ; + unsigned int temp3 ; + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -6244,7 +6464,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + char *arg2 = (char *) 0 ; + semanage_user_key_t **arg3 = (semanage_user_key_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; +@@ -6253,6 +6472,7 @@ + semanage_user_key_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -6286,7 +6506,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_user_t *arg2 = (semanage_user_t *) 0 ; + semanage_user_key_t **arg3 = (semanage_user_key_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -6294,6 +6513,7 @@ + semanage_user_key_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -6345,13 +6565,13 @@ + PyObject *resultobj = 0; + semanage_user_t *arg1 = (semanage_user_t *) 0 ; + semanage_user_key_t *arg2 = (semanage_user_key_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_user_compare",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_user, 0 | 0 ); +@@ -6376,13 +6596,13 @@ + PyObject *resultobj = 0; + semanage_user_t *arg1 = (semanage_user_t *) 0 ; + semanage_user_t *arg2 = (semanage_user_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_user_compare2",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_user, 0 | 0 ); +@@ -6406,10 +6626,10 @@ + SWIGINTERN PyObject *_wrap_semanage_user_get_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_user_t *arg1 = (semanage_user_t *) 0 ; +- char *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_user_get_name",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_user, 0 | 0 ); +@@ -6430,7 +6650,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_user_t *arg2 = (semanage_user_t *) 0 ; + char *arg3 = (char *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -6441,6 +6660,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_set_name",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -6471,10 +6691,10 @@ + SWIGINTERN PyObject *_wrap_semanage_user_get_prefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_user_t *arg1 = (semanage_user_t *) 0 ; +- char *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_user_get_prefix",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_user, 0 | 0 ); +@@ -6495,7 +6715,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_user_t *arg2 = (semanage_user_t *) 0 ; + char *arg3 = (char *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -6506,6 +6725,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_set_prefix",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -6536,10 +6756,10 @@ + SWIGINTERN PyObject *_wrap_semanage_user_get_mlslevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_user_t *arg1 = (semanage_user_t *) 0 ; +- char *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_user_get_mlslevel",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_user, 0 | 0 ); +@@ -6560,7 +6780,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_user_t *arg2 = (semanage_user_t *) 0 ; + char *arg3 = (char *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -6571,6 +6790,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_set_mlslevel",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -6601,10 +6821,10 @@ + SWIGINTERN PyObject *_wrap_semanage_user_get_mlsrange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_user_t *arg1 = (semanage_user_t *) 0 ; +- char *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_user_get_mlsrange",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_user, 0 | 0 ); +@@ -6625,7 +6845,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_user_t *arg2 = (semanage_user_t *) 0 ; + char *arg3 = (char *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -6636,6 +6855,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_set_mlsrange",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -6666,10 +6886,10 @@ + SWIGINTERN PyObject *_wrap_semanage_user_get_num_roles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_user_t *arg1 = (semanage_user_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_user_get_num_roles",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_user, 0 | 0 ); +@@ -6690,7 +6910,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_user_t *arg2 = (semanage_user_t *) 0 ; + char *arg3 = (char *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -6701,6 +6920,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_add_role",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -6765,7 +6985,6 @@ + PyObject *resultobj = 0; + semanage_user_t *arg1 = (semanage_user_t *) 0 ; + char *arg2 = (char *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; +@@ -6773,6 +6992,7 @@ + int alloc2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_user_has_role",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_user, 0 | 0 ); +@@ -6801,7 +7021,6 @@ + semanage_user_t *arg2 = (semanage_user_t *) 0 ; + char ***arg3 = (char ***) 0 ; + unsigned int *arg4 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -6811,6 +7030,7 @@ + int res4 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -6855,7 +7075,6 @@ + semanage_user_t *arg2 = (semanage_user_t *) 0 ; + char **arg3 = (char **) 0 ; + unsigned int arg4 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -6866,6 +7085,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -6902,11 +7122,11 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_user_t **arg2 = (semanage_user_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_user_t *temp2 = NULL ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -6933,7 +7153,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_user_t *arg2 = (semanage_user_t *) 0 ; + semanage_user_t **arg3 = (semanage_user_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -6941,6 +7160,7 @@ + semanage_user_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -6993,7 +7213,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_user_key_t *arg2 = (semanage_user_key_t *) 0 ; + semanage_user_t *arg3 = (semanage_user_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -7003,6 +7222,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_modify_local",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -7032,13 +7252,13 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_user_key_t *arg2 = (semanage_user_key_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_user_del_local",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -7064,7 +7284,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_user_key_t *arg2 = (semanage_user_key_t *) 0 ; + semanage_user_t **arg3 = (semanage_user_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -7072,6 +7291,7 @@ + semanage_user_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -7103,7 +7323,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_user_key_t *arg2 = (semanage_user_key_t *) 0 ; + int *arg3 = (int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -7112,6 +7331,7 @@ + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + arg3 = &temp3; + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_user_exists_local",&obj0,&obj1)) SWIG_fail; +@@ -7143,12 +7363,12 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + unsigned int *arg2 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int temp2 ; + int res2 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:semanage_user_count_local",&obj0)) SWIG_fail; +@@ -7176,13 +7396,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + int (*arg2)(semanage_user_t const *,void *) = (int (*)(semanage_user_t const *,void *)) 0 ; + void *arg3 = (void *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_iterate_local",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -7213,13 +7433,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_user_t ***arg2 = (semanage_user_t ***) 0 ; + unsigned int *arg3 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_user_t **temp2 = NULL ; + unsigned int temp3 ; + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -7258,7 +7478,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_user_key_t *arg2 = (semanage_user_key_t *) 0 ; + semanage_user_t **arg3 = (semanage_user_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -7266,6 +7485,7 @@ + semanage_user_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -7297,7 +7517,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_user_key_t *arg2 = (semanage_user_key_t *) 0 ; + int *arg3 = (int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -7306,6 +7525,7 @@ + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + arg3 = &temp3; + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_user_exists",&obj0,&obj1)) SWIG_fail; +@@ -7337,12 +7557,12 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + unsigned int *arg2 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int temp2 ; + int res2 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:semanage_user_count",&obj0)) SWIG_fail; +@@ -7370,13 +7590,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + int (*arg2)(semanage_user_t const *,void *) = (int (*)(semanage_user_t const *,void *)) 0 ; + void *arg3 = (void *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_iterate",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -7407,13 +7627,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_user_t ***arg2 = (semanage_user_t ***) 0 ; + unsigned int *arg3 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_user_t **temp2 = NULL ; + unsigned int temp3 ; + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -7451,13 +7671,13 @@ + PyObject *resultobj = 0; + semanage_port_t *arg1 = (semanage_port_t *) 0 ; + semanage_port_key_t *arg2 = (semanage_port_key_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_port_compare",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_port, 0 | 0 ); +@@ -7482,13 +7702,13 @@ + PyObject *resultobj = 0; + semanage_port_t *arg1 = (semanage_port_t *) 0 ; + semanage_port_t *arg2 = (semanage_port_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_port_compare2",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_port, 0 | 0 ); +@@ -7516,7 +7736,6 @@ + int arg3 ; + int arg4 ; + semanage_port_key_t **arg5 = (semanage_port_key_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; +@@ -7530,6 +7749,7 @@ + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; ++ int result; + + { + arg5 = &temp5; +@@ -7571,7 +7791,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_port_t *arg2 = (semanage_port_t *) 0 ; + semanage_port_key_t **arg3 = (semanage_port_key_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -7579,6 +7798,7 @@ + semanage_port_key_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -7629,10 +7849,10 @@ + SWIGINTERN PyObject *_wrap_semanage_port_get_proto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_port_t *arg1 = (semanage_port_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_port_get_proto",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_port, 0 | 0 ); +@@ -7681,10 +7901,10 @@ + SWIGINTERN PyObject *_wrap_semanage_port_get_proto_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; +- char *result = 0 ; + int val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; ++ char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_port_get_proto_str",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); +@@ -7703,10 +7923,10 @@ + SWIGINTERN PyObject *_wrap_semanage_port_get_low(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_port_t *arg1 = (semanage_port_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_port_get_low",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_port, 0 | 0 ); +@@ -7725,10 +7945,10 @@ + SWIGINTERN PyObject *_wrap_semanage_port_get_high(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_port_t *arg1 = (semanage_port_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_port_get_high",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_port, 0 | 0 ); +@@ -7816,10 +8036,10 @@ + SWIGINTERN PyObject *_wrap_semanage_port_get_con(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_port_t *arg1 = (semanage_port_t *) 0 ; +- semanage_context_t *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ semanage_context_t *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_port_get_con",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_port, 0 | 0 ); +@@ -7840,7 +8060,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_port_t *arg2 = (semanage_port_t *) 0 ; + semanage_context_t *arg3 = (semanage_context_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -7850,6 +8069,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_port_set_con",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -7879,11 +8099,11 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_port_t **arg2 = (semanage_port_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_port_t *temp2 = NULL ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -7910,7 +8130,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_port_t *arg2 = (semanage_port_t *) 0 ; + semanage_port_t **arg3 = (semanage_port_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -7918,6 +8137,7 @@ + semanage_port_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -7970,7 +8190,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_port_key_t *arg2 = (semanage_port_key_t *) 0 ; + semanage_port_t *arg3 = (semanage_port_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -7980,6 +8199,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_port_modify_local",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -8009,13 +8229,13 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_port_key_t *arg2 = (semanage_port_key_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_port_del_local",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -8041,7 +8261,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_port_key_t *arg2 = (semanage_port_key_t *) 0 ; + semanage_port_t **arg3 = (semanage_port_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -8049,6 +8268,7 @@ + semanage_port_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -8080,7 +8300,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_port_key_t *arg2 = (semanage_port_key_t *) 0 ; + int *arg3 = (int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -8089,6 +8308,7 @@ + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + arg3 = &temp3; + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_port_exists_local",&obj0,&obj1)) SWIG_fail; +@@ -8120,12 +8340,12 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + unsigned int *arg2 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int temp2 ; + int res2 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:semanage_port_count_local",&obj0)) SWIG_fail; +@@ -8153,13 +8373,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + int (*arg2)(semanage_port_t const *,void *) = (int (*)(semanage_port_t const *,void *)) 0 ; + void *arg3 = (void *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_port_iterate_local",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -8190,13 +8410,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_port_t ***arg2 = (semanage_port_t ***) 0 ; + unsigned int *arg3 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_port_t **temp2 = NULL ; + unsigned int temp3 ; + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -8235,7 +8455,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_port_key_t *arg2 = (semanage_port_key_t *) 0 ; + semanage_port_t **arg3 = (semanage_port_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -8243,6 +8462,7 @@ + semanage_port_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -8274,7 +8494,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_port_key_t *arg2 = (semanage_port_key_t *) 0 ; + int *arg3 = (int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -8283,6 +8502,7 @@ + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + arg3 = &temp3; + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_port_exists",&obj0,&obj1)) SWIG_fail; +@@ -8314,12 +8534,12 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + unsigned int *arg2 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int temp2 ; + int res2 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:semanage_port_count",&obj0)) SWIG_fail; +@@ -8347,13 +8567,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + int (*arg2)(semanage_port_t const *,void *) = (int (*)(semanage_port_t const *,void *)) 0 ; + void *arg3 = (void *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_port_iterate",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -8384,13 +8604,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_port_t ***arg2 = (semanage_port_t ***) 0 ; + unsigned int *arg3 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_port_t **temp2 = NULL ; + unsigned int temp3 ; + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -8428,13 +8648,13 @@ + PyObject *resultobj = 0; + semanage_fcontext_t *arg1 = (semanage_fcontext_t *) 0 ; + semanage_fcontext_key_t *arg2 = (semanage_fcontext_key_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_compare",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_fcontext, 0 | 0 ); +@@ -8459,13 +8679,13 @@ + PyObject *resultobj = 0; + semanage_fcontext_t *arg1 = (semanage_fcontext_t *) 0 ; + semanage_fcontext_t *arg2 = (semanage_fcontext_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_compare2",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_fcontext, 0 | 0 ); +@@ -8492,7 +8712,6 @@ + char *arg2 = (char *) 0 ; + int arg3 ; + semanage_fcontext_key_t **arg4 = (semanage_fcontext_key_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; +@@ -8504,6 +8723,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + { + arg4 = &temp4; +@@ -8542,7 +8762,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_fcontext_t *arg2 = (semanage_fcontext_t *) 0 ; + semanage_fcontext_key_t **arg3 = (semanage_fcontext_key_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -8550,6 +8769,7 @@ + semanage_fcontext_key_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -8600,10 +8820,10 @@ + SWIGINTERN PyObject *_wrap_semanage_fcontext_get_expr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_fcontext_t *arg1 = (semanage_fcontext_t *) 0 ; +- char *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_get_expr",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_fcontext, 0 | 0 ); +@@ -8624,7 +8844,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_fcontext_t *arg2 = (semanage_fcontext_t *) 0 ; + char *arg3 = (char *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -8635,6 +8854,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_fcontext_set_expr",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -8665,10 +8885,10 @@ + SWIGINTERN PyObject *_wrap_semanage_fcontext_get_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_fcontext_t *arg1 = (semanage_fcontext_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_get_type",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_fcontext, 0 | 0 ); +@@ -8687,10 +8907,10 @@ + SWIGINTERN PyObject *_wrap_semanage_fcontext_get_type_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; +- char *result = 0 ; + int val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; ++ char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_get_type_str",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); +@@ -8739,10 +8959,10 @@ + SWIGINTERN PyObject *_wrap_semanage_fcontext_get_con(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_fcontext_t *arg1 = (semanage_fcontext_t *) 0 ; +- semanage_context_t *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ semanage_context_t *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_get_con",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_fcontext, 0 | 0 ); +@@ -8763,7 +8983,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_fcontext_t *arg2 = (semanage_fcontext_t *) 0 ; + semanage_context_t *arg3 = (semanage_context_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -8773,6 +8992,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_fcontext_set_con",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -8802,11 +9022,11 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_fcontext_t **arg2 = (semanage_fcontext_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_fcontext_t *temp2 = NULL ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -8833,7 +9053,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_fcontext_t *arg2 = (semanage_fcontext_t *) 0 ; + semanage_fcontext_t **arg3 = (semanage_fcontext_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -8841,6 +9060,7 @@ + semanage_fcontext_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -8893,7 +9113,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_fcontext_key_t *arg2 = (semanage_fcontext_key_t *) 0 ; + semanage_fcontext_t *arg3 = (semanage_fcontext_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -8903,6 +9122,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_fcontext_modify_local",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -8932,13 +9152,13 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_fcontext_key_t *arg2 = (semanage_fcontext_key_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_del_local",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -8964,7 +9184,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_fcontext_key_t *arg2 = (semanage_fcontext_key_t *) 0 ; + semanage_fcontext_t **arg3 = (semanage_fcontext_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -8972,6 +9191,7 @@ + semanage_fcontext_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -9003,7 +9223,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_fcontext_key_t *arg2 = (semanage_fcontext_key_t *) 0 ; + int *arg3 = (int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -9012,6 +9231,7 @@ + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + arg3 = &temp3; + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_exists_local",&obj0,&obj1)) SWIG_fail; +@@ -9043,12 +9263,12 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + unsigned int *arg2 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int temp2 ; + int res2 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_count_local",&obj0)) SWIG_fail; +@@ -9076,13 +9296,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + int (*arg2)(semanage_fcontext_t const *,void *) = (int (*)(semanage_fcontext_t const *,void *)) 0 ; + void *arg3 = (void *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_fcontext_iterate_local",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -9113,13 +9333,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_fcontext_t ***arg2 = (semanage_fcontext_t ***) 0 ; + unsigned int *arg3 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_fcontext_t **temp2 = NULL ; + unsigned int temp3 ; + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -9158,7 +9378,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_fcontext_key_t *arg2 = (semanage_fcontext_key_t *) 0 ; + semanage_fcontext_t **arg3 = (semanage_fcontext_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -9166,6 +9385,7 @@ + semanage_fcontext_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -9197,7 +9417,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_fcontext_key_t *arg2 = (semanage_fcontext_key_t *) 0 ; + int *arg3 = (int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -9206,6 +9425,7 @@ + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + arg3 = &temp3; + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_exists",&obj0,&obj1)) SWIG_fail; +@@ -9237,12 +9457,12 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + unsigned int *arg2 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int temp2 ; + int res2 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_count",&obj0)) SWIG_fail; +@@ -9270,13 +9490,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + int (*arg2)(semanage_fcontext_t const *,void *) = (int (*)(semanage_fcontext_t const *,void *)) 0 ; + void *arg3 = (void *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_fcontext_iterate",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -9307,13 +9527,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_fcontext_t ***arg2 = (semanage_fcontext_t ***) 0 ; + unsigned int *arg3 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_fcontext_t **temp2 = NULL ; + unsigned int temp3 ; + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -9352,7 +9572,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + char *arg2 = (char *) 0 ; + semanage_seuser_key_t **arg3 = (semanage_seuser_key_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; +@@ -9361,6 +9580,7 @@ + semanage_seuser_key_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -9394,7 +9614,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_seuser_t *arg2 = (semanage_seuser_t *) 0 ; + semanage_seuser_key_t **arg3 = (semanage_seuser_key_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -9402,6 +9621,7 @@ + semanage_seuser_key_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -9453,13 +9673,13 @@ + PyObject *resultobj = 0; + semanage_seuser_t *arg1 = (semanage_seuser_t *) 0 ; + semanage_seuser_key_t *arg2 = (semanage_seuser_key_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_compare",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_seuser, 0 | 0 ); +@@ -9484,13 +9704,13 @@ + PyObject *resultobj = 0; + semanage_seuser_t *arg1 = (semanage_seuser_t *) 0 ; + semanage_seuser_t *arg2 = (semanage_seuser_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_compare2",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_seuser, 0 | 0 ); +@@ -9514,10 +9734,10 @@ + SWIGINTERN PyObject *_wrap_semanage_seuser_get_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_seuser_t *arg1 = (semanage_seuser_t *) 0 ; +- char *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_get_name",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_seuser, 0 | 0 ); +@@ -9538,7 +9758,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_seuser_t *arg2 = (semanage_seuser_t *) 0 ; + char *arg3 = (char *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -9549,6 +9768,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_seuser_set_name",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -9579,10 +9799,10 @@ + SWIGINTERN PyObject *_wrap_semanage_seuser_get_sename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_seuser_t *arg1 = (semanage_seuser_t *) 0 ; +- char *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_get_sename",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_seuser, 0 | 0 ); +@@ -9603,7 +9823,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_seuser_t *arg2 = (semanage_seuser_t *) 0 ; + char *arg3 = (char *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -9614,6 +9833,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_seuser_set_sename",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -9644,10 +9864,10 @@ + SWIGINTERN PyObject *_wrap_semanage_seuser_get_mlsrange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_seuser_t *arg1 = (semanage_seuser_t *) 0 ; +- char *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_get_mlsrange",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_seuser, 0 | 0 ); +@@ -9668,7 +9888,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_seuser_t *arg2 = (semanage_seuser_t *) 0 ; + char *arg3 = (char *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -9679,6 +9898,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_seuser_set_mlsrange",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -9710,11 +9930,11 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_seuser_t **arg2 = (semanage_seuser_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_seuser_t *temp2 = NULL ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -9741,7 +9961,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_seuser_t *arg2 = (semanage_seuser_t *) 0 ; + semanage_seuser_t **arg3 = (semanage_seuser_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -9749,6 +9968,7 @@ + semanage_seuser_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -9801,7 +10021,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_seuser_key_t *arg2 = (semanage_seuser_key_t *) 0 ; + semanage_seuser_t *arg3 = (semanage_seuser_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -9811,6 +10030,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_seuser_modify_local",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -9840,13 +10060,13 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_seuser_key_t *arg2 = (semanage_seuser_key_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_del_local",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -9872,7 +10092,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_seuser_key_t *arg2 = (semanage_seuser_key_t *) 0 ; + semanage_seuser_t **arg3 = (semanage_seuser_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -9880,6 +10099,7 @@ + semanage_seuser_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -9911,7 +10131,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_seuser_key_t *arg2 = (semanage_seuser_key_t *) 0 ; + int *arg3 = (int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -9920,6 +10139,7 @@ + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + arg3 = &temp3; + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_exists_local",&obj0,&obj1)) SWIG_fail; +@@ -9951,12 +10171,12 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + unsigned int *arg2 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int temp2 ; + int res2 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_count_local",&obj0)) SWIG_fail; +@@ -9984,13 +10204,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + int (*arg2)(semanage_seuser_t const *,void *) = (int (*)(semanage_seuser_t const *,void *)) 0 ; + void *arg3 = (void *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_seuser_iterate_local",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -10021,13 +10241,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_seuser_t ***arg2 = (semanage_seuser_t ***) 0 ; + unsigned int *arg3 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_seuser_t **temp2 = NULL ; + unsigned int temp3 ; + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -10066,7 +10286,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_seuser_key_t *arg2 = (semanage_seuser_key_t *) 0 ; + semanage_seuser_t **arg3 = (semanage_seuser_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -10074,6 +10293,7 @@ + semanage_seuser_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -10105,7 +10325,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_seuser_key_t *arg2 = (semanage_seuser_key_t *) 0 ; + int *arg3 = (int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -10114,6 +10333,7 @@ + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + arg3 = &temp3; + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_exists",&obj0,&obj1)) SWIG_fail; +@@ -10145,12 +10365,12 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + unsigned int *arg2 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int temp2 ; + int res2 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_count",&obj0)) SWIG_fail; +@@ -10178,13 +10398,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + int (*arg2)(semanage_seuser_t const *,void *) = (int (*)(semanage_seuser_t const *,void *)) 0 ; + void *arg3 = (void *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_seuser_iterate",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -10215,13 +10435,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_seuser_t ***arg2 = (semanage_seuser_t ***) 0 ; + unsigned int *arg3 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_seuser_t **temp2 = NULL ; + unsigned int temp3 ; + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -10259,13 +10479,13 @@ + PyObject *resultobj = 0; + semanage_node_t *arg1 = (semanage_node_t *) 0 ; + semanage_node_key_t *arg2 = (semanage_node_key_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_node_compare",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_node, 0 | 0 ); +@@ -10290,13 +10510,13 @@ + PyObject *resultobj = 0; + semanage_node_t *arg1 = (semanage_node_t *) 0 ; + semanage_node_t *arg2 = (semanage_node_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_node_compare2",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_node, 0 | 0 ); +@@ -10324,7 +10544,6 @@ + char *arg3 = (char *) 0 ; + int arg4 ; + semanage_node_key_t **arg5 = (semanage_node_key_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; +@@ -10340,6 +10559,7 @@ + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; ++ int result; + + { + arg5 = &temp5; +@@ -10385,7 +10605,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_node_t *arg2 = (semanage_node_t *) 0 ; + semanage_node_key_t **arg3 = (semanage_node_key_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -10393,6 +10612,7 @@ + semanage_node_key_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -10445,7 +10665,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_node_t *arg2 = (semanage_node_t *) 0 ; + char **arg3 = (char **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -10453,6 +10672,7 @@ + char *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -10486,7 +10706,6 @@ + semanage_node_t *arg2 = (semanage_node_t *) 0 ; + char **arg3 = (char **) 0 ; + size_t *arg4 = (size_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -10496,6 +10715,7 @@ + int res4 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -10536,7 +10756,6 @@ + semanage_node_t *arg2 = (semanage_node_t *) 0 ; + int arg3 ; + char *arg4 = (char *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -10550,6 +10769,7 @@ + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:semanage_node_set_addr",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -10588,7 +10808,6 @@ + semanage_node_t *arg2 = (semanage_node_t *) 0 ; + char *arg3 = (char *) 0 ; + size_t arg4 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -10602,6 +10821,7 @@ + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:semanage_node_set_addr_bytes",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -10639,7 +10859,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_node_t *arg2 = (semanage_node_t *) 0 ; + char **arg3 = (char **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -10647,6 +10866,7 @@ + char *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -10680,7 +10900,6 @@ + semanage_node_t *arg2 = (semanage_node_t *) 0 ; + char **arg3 = (char **) 0 ; + size_t *arg4 = (size_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -10690,6 +10909,7 @@ + int res4 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -10730,7 +10950,6 @@ + semanage_node_t *arg2 = (semanage_node_t *) 0 ; + int arg3 ; + char *arg4 = (char *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -10744,6 +10963,7 @@ + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:semanage_node_set_mask",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -10782,7 +11002,6 @@ + semanage_node_t *arg2 = (semanage_node_t *) 0 ; + char *arg3 = (char *) 0 ; + size_t arg4 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -10796,6 +11015,7 @@ + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:semanage_node_set_mask_bytes",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -10831,10 +11051,10 @@ + SWIGINTERN PyObject *_wrap_semanage_node_get_proto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_node_t *arg1 = (semanage_node_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_node_get_proto",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_node, 0 | 0 ); +@@ -10883,10 +11103,10 @@ + SWIGINTERN PyObject *_wrap_semanage_node_get_proto_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; +- char *result = 0 ; + int val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; ++ char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_node_get_proto_str",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); +@@ -10905,10 +11125,10 @@ + SWIGINTERN PyObject *_wrap_semanage_node_get_con(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + semanage_node_t *arg1 = (semanage_node_t *) 0 ; +- semanage_context_t *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; ++ semanage_context_t *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:semanage_node_get_con",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_node, 0 | 0 ); +@@ -10929,7 +11149,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_node_t *arg2 = (semanage_node_t *) 0 ; + semanage_context_t *arg3 = (semanage_context_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -10939,6 +11158,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_node_set_con",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -10968,11 +11188,11 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_node_t **arg2 = (semanage_node_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_node_t *temp2 = NULL ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -10999,7 +11219,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_node_t *arg2 = (semanage_node_t *) 0 ; + semanage_node_t **arg3 = (semanage_node_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -11007,6 +11226,7 @@ + semanage_node_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -11059,7 +11279,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_node_key_t *arg2 = (semanage_node_key_t *) 0 ; + semanage_node_t *arg3 = (semanage_node_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -11069,6 +11288,7 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_node_modify_local",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -11098,13 +11318,13 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_node_key_t *arg2 = (semanage_node_key_t *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_node_del_local",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -11130,7 +11350,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_node_key_t *arg2 = (semanage_node_key_t *) 0 ; + semanage_node_t **arg3 = (semanage_node_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -11138,6 +11357,7 @@ + semanage_node_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -11169,7 +11389,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_node_key_t *arg2 = (semanage_node_key_t *) 0 ; + int *arg3 = (int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -11178,6 +11397,7 @@ + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + arg3 = &temp3; + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_node_exists_local",&obj0,&obj1)) SWIG_fail; +@@ -11209,12 +11429,12 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + unsigned int *arg2 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int temp2 ; + int res2 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:semanage_node_count_local",&obj0)) SWIG_fail; +@@ -11242,13 +11462,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + int (*arg2)(semanage_node_t const *,void *) = (int (*)(semanage_node_t const *,void *)) 0 ; + void *arg3 = (void *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_node_iterate_local",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -11279,13 +11499,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_node_t ***arg2 = (semanage_node_t ***) 0 ; + unsigned int *arg3 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_node_t **temp2 = NULL ; + unsigned int temp3 ; + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -11324,7 +11544,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_node_key_t *arg2 = (semanage_node_key_t *) 0 ; + semanage_node_t **arg3 = (semanage_node_t **) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -11332,6 +11551,7 @@ + semanage_node_t *temp3 = NULL ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + { + arg3 = &temp3; +@@ -11363,7 +11583,6 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_node_key_t *arg2 = (semanage_node_key_t *) 0 ; + int *arg3 = (int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; +@@ -11372,6 +11591,7 @@ + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ int result; + + arg3 = &temp3; + if (!PyArg_ParseTuple(args,(char *)"OO:semanage_node_exists",&obj0,&obj1)) SWIG_fail; +@@ -11403,12 +11623,12 @@ + PyObject *resultobj = 0; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + unsigned int *arg2 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int temp2 ; + int res2 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:semanage_node_count",&obj0)) SWIG_fail; +@@ -11436,13 +11656,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + int (*arg2)(semanage_node_t const *,void *) = (int (*)(semanage_node_t const *,void *)) 0 ; + void *arg3 = (void *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; ++ int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_node_iterate",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); +@@ -11473,13 +11693,13 @@ + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; + semanage_node_t ***arg2 = (semanage_node_t ***) 0 ; + unsigned int *arg3 = (unsigned int *) 0 ; +- int result; + void *argp1 = 0 ; + int res1 = 0 ; + semanage_node_t **temp2 = NULL ; + unsigned int temp3 ; + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; ++ int result; + + { + arg2 = &temp2; +@@ -11514,6 +11734,7 @@ + + + static PyMethodDef SwigMethods[] = { ++ { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL}, + { (char *)"semanage_msg_get_level", _wrap_semanage_msg_get_level, METH_VARARGS, NULL}, + { (char *)"semanage_msg_get_channel", _wrap_semanage_msg_get_channel, METH_VARARGS, NULL}, + { (char *)"semanage_msg_get_fname", _wrap_semanage_msg_get_fname, METH_VARARGS, NULL}, +@@ -11794,6 +12015,7 @@ + static swig_type_info _swigt__p_p_semanage_context = {"_p_p_semanage_context", "struct semanage_context **|semanage_context_t **", 0, 0, (void*)0, 0}; + static swig_type_info _swigt__p_p_semanage_fcontext = {"_p_p_semanage_fcontext", "struct semanage_fcontext **|semanage_fcontext_t **", 0, 0, (void*)0, 0}; + static swig_type_info _swigt__p_p_semanage_fcontext_key = {"_p_p_semanage_fcontext_key", "semanage_fcontext_key_t **|struct semanage_fcontext_key **", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_p_semanage_handle_t = {"_p_p_semanage_handle_t", "struct semanage_handle_t **", 0, 0, (void*)0, 0}; + static swig_type_info _swigt__p_p_semanage_iface = {"_p_p_semanage_iface", "semanage_iface_t **|struct semanage_iface **", 0, 0, (void*)0, 0}; + static swig_type_info _swigt__p_p_semanage_iface_key = {"_p_p_semanage_iface_key", "semanage_iface_key_t **|struct semanage_iface_key **", 0, 0, (void*)0, 0}; + static swig_type_info _swigt__p_p_semanage_module_info = {"_p_p_semanage_module_info", "struct semanage_module_info **|semanage_module_info_t **", 0, 0, (void*)0, 0}; +@@ -11850,6 +12072,7 @@ + &_swigt__p_p_semanage_context, + &_swigt__p_p_semanage_fcontext, + &_swigt__p_p_semanage_fcontext_key, ++ &_swigt__p_p_semanage_handle_t, + &_swigt__p_p_semanage_iface, + &_swigt__p_p_semanage_iface_key, + &_swigt__p_p_semanage_module_info, +@@ -11906,6 +12129,7 @@ + static swig_cast_info _swigc__p_p_semanage_context[] = { {&_swigt__p_p_semanage_context, 0, 0, 0},{0, 0, 0, 0}}; + static swig_cast_info _swigc__p_p_semanage_fcontext[] = { {&_swigt__p_p_semanage_fcontext, 0, 0, 0},{0, 0, 0, 0}}; + static swig_cast_info _swigc__p_p_semanage_fcontext_key[] = { {&_swigt__p_p_semanage_fcontext_key, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_p_semanage_handle_t[] = { {&_swigt__p_p_semanage_handle_t, 0, 0, 0},{0, 0, 0, 0}}; + static swig_cast_info _swigc__p_p_semanage_iface[] = { {&_swigt__p_p_semanage_iface, 0, 0, 0},{0, 0, 0, 0}}; + static swig_cast_info _swigc__p_p_semanage_iface_key[] = { {&_swigt__p_p_semanage_iface_key, 0, 0, 0},{0, 0, 0, 0}}; + static swig_cast_info _swigc__p_p_semanage_module_info[] = { {&_swigt__p_p_semanage_module_info, 0, 0, 0},{0, 0, 0, 0}}; +@@ -11962,6 +12186,7 @@ + _swigc__p_p_semanage_context, + _swigc__p_p_semanage_fcontext, + _swigc__p_p_semanage_fcontext_key, ++ _swigc__p_p_semanage_handle_t, + _swigc__p_p_semanage_iface, + _swigc__p_p_semanage_iface_key, + _swigc__p_p_semanage_module_info, +@@ -12269,26 +12494,58 @@ + + SWIGINTERN PyObject * + swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) { ++#if PY_VERSION_HEX >= 0x03000000 ++ return PyUnicode_InternFromString(""); ++#else + return PyString_FromString(""); ++#endif + } + + SWIGINTERN PyObject * + swig_varlink_str(swig_varlinkobject *v) { ++#if PY_VERSION_HEX >= 0x03000000 ++ PyObject *str = PyUnicode_InternFromString("("); ++ PyObject *tail; ++ PyObject *joined; ++ swig_globalvar *var; ++ for (var = v->vars; var; var=var->next) { ++ tail = PyUnicode_FromString(var->name); ++ joined = PyUnicode_Concat(str, tail); ++ Py_DecRef(str); ++ Py_DecRef(tail); ++ str = joined; ++ if (var->next) { ++ tail = PyUnicode_InternFromString(", "); ++ joined = PyUnicode_Concat(str, tail); ++ Py_DecRef(str); ++ Py_DecRef(tail); ++ str = joined; ++ } ++ } ++ tail = PyUnicode_InternFromString(")"); ++ joined = PyUnicode_Concat(str, tail); ++ Py_DecRef(str); ++ Py_DecRef(tail); ++ str = joined; ++#else + PyObject *str = PyString_FromString("("); +- swig_globalvar *var; ++ 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(")")); ++#endif + return str; + } + + SWIGINTERN int + swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) { ++ char *tmp; + PyObject *str = swig_varlink_str(v); + fprintf(fp,"Swig global variables "); +- fprintf(fp,"%s\n", PyString_AsString(str)); ++ fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str)); ++ SWIG_Python_str_DelForPy3(tmp); + Py_DECREF(str); + return 0; + } +@@ -12346,8 +12603,13 @@ + if (!type_init) { + const PyTypeObject tmp + = { ++ /* PyObject header changed in Python 3 */ ++#if PY_VERSION_HEX >= 0x03000000 ++ PyVarObject_HEAD_INIT(&PyType_Type, 0) ++#else + PyObject_HEAD_INIT(NULL) + 0, /* Number of items in variable part (ob_size) */ ++#endif + (char *)"swigvarlink", /* Type name (tp_name) */ + sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */ + 0, /* Itemsize (tp_itemsize) */ +@@ -12383,7 +12645,10 @@ + #endif + }; + varlink_type = tmp; ++ /* for Python 3 we already assigned the ob_type in PyVarObject_HEAD_INIT() */ ++#if PY_VERSION_HEX < 0x03000000 + varlink_type.ob_type = &PyType_Type; ++#endif + type_init = 1; + } + return &varlink_type; +@@ -12508,13 +12773,37 @@ + #ifdef __cplusplus + extern "C" + #endif +-SWIGEXPORT void SWIG_init(void) { +- PyObject *m, *d; ++ ++SWIGEXPORT ++#if PY_VERSION_HEX >= 0x03000000 ++PyObject* ++#else ++void ++#endif ++SWIG_init(void) { ++ PyObject *m, *d; ++#if PY_VERSION_HEX >= 0x03000000 ++ static struct PyModuleDef SWIG_module = { ++ PyModuleDef_HEAD_INIT, ++ (char *) SWIG_name, ++ NULL, ++ -1, ++ SwigMethods, ++ NULL, ++ NULL, ++ NULL, ++ NULL ++ }; ++#endif + + /* Fix SwigMethods to carry the callback ptrs when needed */ + SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial); + ++#if PY_VERSION_HEX >= 0x03000000 ++ m = PyModule_Create(&SWIG_module); ++#else + m = Py_InitModule((char *) SWIG_name, SwigMethods); ++#endif + d = PyModule_GetDict(m); + + SWIG_InitializeModule(0); +@@ -12542,5 +12831,10 @@ + SWIG_Python_SetConstant(d, "SEMANAGE_FCONTEXT_PIPE",SWIG_From_int((int)(7))); + SWIG_Python_SetConstant(d, "SEMANAGE_PROTO_IP4",SWIG_From_int((int)(0))); + SWIG_Python_SetConstant(d, "SEMANAGE_PROTO_IP6",SWIG_From_int((int)(1))); ++#if PY_VERSION_HEX >= 0x03000000 ++ return m; ++#else ++ return; ++#endif + } + diff --git a/libsemanage.spec b/libsemanage.spec index 20f54f3..5e12e4a 100644 --- a/libsemanage.spec +++ b/libsemanage.spec @@ -2,8 +2,8 @@ %define libselinuxver 2.0.0-1 Summary: SELinux binary policy manipulation library Name: libsemanage -Version: 2.0.31 -Release: 5%{?dist} +Version: 2.0.32 +Release: 1%{?dist} License: LGPLv2+ Group: System Environment/Libraries Source: http://www.nsa.gov/selinux/archives/libsemanage-%{version}.tgz @@ -91,6 +91,10 @@ rm -rf ${RPM_BUILD_ROOT} %{_libdir}/python*/site-packages/* %changelog +* Mon Jun 8 2009 Dan Walsh - 2.0.32-1 +- Update to upstream + * Ruby bindings from David Quigley. + * Thu Apr 9 2009 Dan Walsh - 2.0.31-5 - Return error on invalid file diff --git a/sources b/sources index ca06d81..cb12db1 100644 --- a/sources +++ b/sources @@ -1 +1 @@ -7231fa877020bc5fbb2008adfd5dec89 libsemanage-2.0.31.tgz +4b9e3ec00959d29e972adb42c8edad8e libsemanage-2.0.32.tgz