From 9b0bb205bf530ab38c45d0326074ecaf42e61f7d Mon Sep 17 00:00:00 2001 From: Daniel J Walsh Date: Fri, 14 Apr 2006 11:37:57 +0000 Subject: [PATCH] - Upgrade to latest from NSA Merged file context sorting code from Christopher Ashworth (Tresys Technology), based on fc_sort.c code in refpolicy. Merged python binding t_output_helper removal patch from Dan Walsh. Regenerated swig files. --- .cvsignore | 2 + libsemanage-rhat.patch | 20432 ++++++++++++++++++++++++++++++++++++++- libsemanage.spec | 22 +- sources | 2 +- 4 files changed, 20440 insertions(+), 18 deletions(-) diff --git a/.cvsignore b/.cvsignore index fc2045e..ea31987 100644 --- a/.cvsignore +++ b/.cvsignore @@ -61,3 +61,5 @@ libsemanage-1.5.29.tgz libsemanage-1.5.31.tgz libsemanage-1.6.tgz libsemanage-1.6.2.tgz +libsemanage-1.6.3.tgz +libsemanage-1.6.5.tgz diff --git a/libsemanage-rhat.patch b/libsemanage-rhat.patch index 8261a6e..dcadba5 100644 --- a/libsemanage-rhat.patch +++ b/libsemanage-rhat.patch @@ -1,12 +1,20422 @@ -diff --exclude-from=exclude -N -u -r nsalibsemanage/src/semanage_store.c libsemanage-1.6.2/src/semanage_store.c ---- nsalibsemanage/src/semanage_store.c 2006-03-10 09:48:01.000000000 -0500 -+++ libsemanage-1.6.2/src/semanage_store.c 2006-03-29 14:20:16.000000000 -0500 -@@ -1159,6 +1159,8 @@ - ERR(sh, "Could not open direct %s at %s.", lock_name, lock_file); - return -1; - } -+ fcntl(fd, F_SETFD, FD_CLOEXEC); +diff --exclude-from=exclude -N -u -r nsalibsemanage/src/semanage.py libsemanage-1.6.2/src/semanage.py +--- nsalibsemanage/src/semanage.py 2006-02-16 13:35:22.000000000 -0500 ++++ libsemanage-1.6.2/src/semanage.py 2006-04-03 19:12:41.000000000 -0400 +@@ -1,19 +1,19 @@ +-# This file was created automatically by SWIG. ++# This file was created automatically by SWIG 1.3.29. + # Don't modify this file, modify the SWIG interface instead. + # This file is compatible with both classic and new-style classes. + + import _semanage +- ++import new ++new_instancemethod = new.instancemethod + def _swig_setattr_nondynamic(self,class_type,name,value,static=1): ++ if (name == "thisown"): return self.this.own(value) + if (name == "this"): +- if isinstance(value, class_type): +- self.__dict__[name] = value.this +- if hasattr(value,"thisown"): self.__dict__["thisown"] = value.thisown +- del value.thisown ++ if type(value).__name__ == 'PySwigObject': ++ self.__dict__[name] = value + return + method = class_type.__swig_setmethods__.get(name,None) + if method: return method(self,value) +- if (not static) or hasattr(self,name) or (name == "thisown"): ++ if (not static) or hasattr(self,name): + self.__dict__[name] = value + else: + raise AttributeError("You cannot add attributes to %s" % self) +@@ -22,10 +22,16 @@ + return _swig_setattr_nondynamic(self,class_type,name,value,0) + + def _swig_getattr(self,class_type,name): ++ if (name == "thisown"): return self.this.own() + method = class_type.__swig_getmethods__.get(name,None) + if method: return method(self) + raise AttributeError,name + ++def _swig_repr(self): ++ try: strthis = "proxy of " + self.this.__repr__() ++ except: strthis = "" ++ return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) + - if (sh->timeout == 0) { - /* return immediately */ - origtime.tv_sec = 0; + import types + try: + _object = types.ObjectType +@@ -39,345 +45,179 @@ + SEMANAGE_MSG_ERR = _semanage.SEMANAGE_MSG_ERR + SEMANAGE_MSG_WARN = _semanage.SEMANAGE_MSG_WARN + SEMANAGE_MSG_INFO = _semanage.SEMANAGE_MSG_INFO +- + semanage_msg_get_level = _semanage.semanage_msg_get_level +- + semanage_msg_get_channel = _semanage.semanage_msg_get_channel +- + semanage_msg_get_fname = _semanage.semanage_msg_get_fname +- + semanage_msg_set_callback = _semanage.semanage_msg_set_callback +- + semanage_handle_create = _semanage.semanage_handle_create +- + 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 +- + semanage_select_store = _semanage.semanage_select_store +- + semanage_reload_policy = _semanage.semanage_reload_policy +- + semanage_set_reload = _semanage.semanage_set_reload +- + semanage_set_rebuild = _semanage.semanage_set_rebuild +- + semanage_set_create_store = _semanage.semanage_set_create_store +- + semanage_is_managed = _semanage.semanage_is_managed +- + semanage_connect = _semanage.semanage_connect +- + semanage_disconnect = _semanage.semanage_disconnect +- + semanage_begin_transaction = _semanage.semanage_begin_transaction +- + semanage_commit = _semanage.semanage_commit + SEMANAGE_CAN_READ = _semanage.SEMANAGE_CAN_READ + SEMANAGE_CAN_WRITE = _semanage.SEMANAGE_CAN_WRITE +- + semanage_access_check = _semanage.semanage_access_check +- + semanage_is_connected = _semanage.semanage_is_connected +- + semanage_module_install = _semanage.semanage_module_install +- + semanage_module_upgrade = _semanage.semanage_module_upgrade +- + semanage_module_install_base = _semanage.semanage_module_install_base +- + semanage_module_remove = _semanage.semanage_module_remove +- + semanage_module_list = _semanage.semanage_module_list +- + semanage_module_info_datum_destroy = _semanage.semanage_module_info_datum_destroy +- + semanage_module_list_nth = _semanage.semanage_module_list_nth +- + semanage_module_get_name = _semanage.semanage_module_get_name +- + semanage_module_get_version = _semanage.semanage_module_get_version +- + semanage_context_get_user = _semanage.semanage_context_get_user +- + semanage_context_set_user = _semanage.semanage_context_set_user +- + semanage_context_get_role = _semanage.semanage_context_get_role +- + semanage_context_set_role = _semanage.semanage_context_set_role +- + semanage_context_get_type = _semanage.semanage_context_get_type +- + semanage_context_set_type = _semanage.semanage_context_set_type +- + semanage_context_get_mls = _semanage.semanage_context_get_mls +- + semanage_context_set_mls = _semanage.semanage_context_set_mls +- + semanage_context_create = _semanage.semanage_context_create +- + semanage_context_clone = _semanage.semanage_context_clone +- + semanage_context_free = _semanage.semanage_context_free +- + semanage_context_from_string = _semanage.semanage_context_from_string +- + semanage_context_to_string = _semanage.semanage_context_to_string +- + semanage_bool_key_create = _semanage.semanage_bool_key_create +- + semanage_bool_key_extract = _semanage.semanage_bool_key_extract +- + semanage_bool_key_free = _semanage.semanage_bool_key_free +- + semanage_bool_compare = _semanage.semanage_bool_compare +- + semanage_bool_compare2 = _semanage.semanage_bool_compare2 +- + semanage_bool_get_name = _semanage.semanage_bool_get_name +- + semanage_bool_set_name = _semanage.semanage_bool_set_name +- + semanage_bool_get_value = _semanage.semanage_bool_get_value +- + semanage_bool_set_value = _semanage.semanage_bool_set_value +- + semanage_bool_create = _semanage.semanage_bool_create +- + semanage_bool_clone = _semanage.semanage_bool_clone +- + semanage_bool_free = _semanage.semanage_bool_free +- + semanage_bool_query = _semanage.semanage_bool_query +- + semanage_bool_exists = _semanage.semanage_bool_exists +- + semanage_bool_count = _semanage.semanage_bool_count +- + semanage_bool_iterate = _semanage.semanage_bool_iterate +- + semanage_bool_list = _semanage.semanage_bool_list +- + semanage_bool_modify_local = _semanage.semanage_bool_modify_local +- + semanage_bool_del_local = _semanage.semanage_bool_del_local +- + semanage_bool_query_local = _semanage.semanage_bool_query_local +- + semanage_bool_exists_local = _semanage.semanage_bool_exists_local +- + semanage_bool_count_local = _semanage.semanage_bool_count_local +- + semanage_bool_iterate_local = _semanage.semanage_bool_iterate_local +- + semanage_bool_list_local = _semanage.semanage_bool_list_local +- + semanage_bool_set_active = _semanage.semanage_bool_set_active +- + semanage_bool_query_active = _semanage.semanage_bool_query_active +- + semanage_bool_exists_active = _semanage.semanage_bool_exists_active +- + semanage_bool_count_active = _semanage.semanage_bool_count_active +- + semanage_bool_iterate_active = _semanage.semanage_bool_iterate_active +- + semanage_bool_list_active = _semanage.semanage_bool_list_active +- + semanage_iface_compare = _semanage.semanage_iface_compare +- + semanage_iface_compare2 = _semanage.semanage_iface_compare2 +- + semanage_iface_key_create = _semanage.semanage_iface_key_create +- + semanage_iface_key_extract = _semanage.semanage_iface_key_extract +- + semanage_iface_key_free = _semanage.semanage_iface_key_free +- + semanage_iface_get_name = _semanage.semanage_iface_get_name +- + semanage_iface_set_name = _semanage.semanage_iface_set_name +- + semanage_iface_get_ifcon = _semanage.semanage_iface_get_ifcon +- + semanage_iface_set_ifcon = _semanage.semanage_iface_set_ifcon +- + semanage_iface_get_msgcon = _semanage.semanage_iface_get_msgcon +- + semanage_iface_set_msgcon = _semanage.semanage_iface_set_msgcon +- + semanage_iface_create = _semanage.semanage_iface_create +- + semanage_iface_clone = _semanage.semanage_iface_clone +- + semanage_iface_free = _semanage.semanage_iface_free +- + semanage_iface_modify_local = _semanage.semanage_iface_modify_local +- + semanage_iface_del_local = _semanage.semanage_iface_del_local +- + semanage_iface_query_local = _semanage.semanage_iface_query_local +- + semanage_iface_exists_local = _semanage.semanage_iface_exists_local +- + semanage_iface_count_local = _semanage.semanage_iface_count_local +- + semanage_iface_iterate_local = _semanage.semanage_iface_iterate_local +- + semanage_iface_list_local = _semanage.semanage_iface_list_local +- + semanage_iface_query = _semanage.semanage_iface_query +- + semanage_iface_exists = _semanage.semanage_iface_exists +- + semanage_iface_count = _semanage.semanage_iface_count +- + semanage_iface_iterate = _semanage.semanage_iface_iterate +- + semanage_iface_list = _semanage.semanage_iface_list +- + semanage_user_key_create = _semanage.semanage_user_key_create +- + semanage_user_key_extract = _semanage.semanage_user_key_extract +- + semanage_user_key_free = _semanage.semanage_user_key_free +- + semanage_user_compare = _semanage.semanage_user_compare +- + semanage_user_compare2 = _semanage.semanage_user_compare2 +- + semanage_user_get_name = _semanage.semanage_user_get_name +- + semanage_user_set_name = _semanage.semanage_user_set_name +- + semanage_user_get_prefix = _semanage.semanage_user_get_prefix +- + semanage_user_set_prefix = _semanage.semanage_user_set_prefix +- + semanage_user_get_mlslevel = _semanage.semanage_user_get_mlslevel +- + semanage_user_set_mlslevel = _semanage.semanage_user_set_mlslevel +- + semanage_user_get_mlsrange = _semanage.semanage_user_get_mlsrange +- + semanage_user_set_mlsrange = _semanage.semanage_user_set_mlsrange +- + semanage_user_get_num_roles = _semanage.semanage_user_get_num_roles +- + semanage_user_add_role = _semanage.semanage_user_add_role +- + semanage_user_del_role = _semanage.semanage_user_del_role +- + semanage_user_has_role = _semanage.semanage_user_has_role +- + semanage_user_get_roles = _semanage.semanage_user_get_roles +- + semanage_user_set_roles = _semanage.semanage_user_set_roles +- + semanage_user_create = _semanage.semanage_user_create +- + semanage_user_clone = _semanage.semanage_user_clone +- + semanage_user_free = _semanage.semanage_user_free +- + semanage_user_modify_local = _semanage.semanage_user_modify_local +- + semanage_user_del_local = _semanage.semanage_user_del_local +- + semanage_user_query_local = _semanage.semanage_user_query_local +- + semanage_user_exists_local = _semanage.semanage_user_exists_local +- + semanage_user_count_local = _semanage.semanage_user_count_local +- + semanage_user_iterate_local = _semanage.semanage_user_iterate_local +- + semanage_user_list_local = _semanage.semanage_user_list_local +- + semanage_user_query = _semanage.semanage_user_query +- + semanage_user_exists = _semanage.semanage_user_exists +- + semanage_user_count = _semanage.semanage_user_count +- + semanage_user_iterate = _semanage.semanage_user_iterate +- + semanage_user_list = _semanage.semanage_user_list + SEMANAGE_PROTO_UDP = _semanage.SEMANAGE_PROTO_UDP + SEMANAGE_PROTO_TCP = _semanage.SEMANAGE_PROTO_TCP +- + semanage_port_compare = _semanage.semanage_port_compare +- + semanage_port_compare2 = _semanage.semanage_port_compare2 +- + semanage_port_key_create = _semanage.semanage_port_key_create +- + semanage_port_key_extract = _semanage.semanage_port_key_extract +- + semanage_port_key_free = _semanage.semanage_port_key_free +- + semanage_port_get_proto = _semanage.semanage_port_get_proto +- + semanage_port_set_proto = _semanage.semanage_port_set_proto +- + semanage_port_get_proto_str = _semanage.semanage_port_get_proto_str +- + semanage_port_get_low = _semanage.semanage_port_get_low +- + semanage_port_get_high = _semanage.semanage_port_get_high +- + semanage_port_set_port = _semanage.semanage_port_set_port +- + semanage_port_set_range = _semanage.semanage_port_set_range +- + semanage_port_get_con = _semanage.semanage_port_get_con +- + semanage_port_set_con = _semanage.semanage_port_set_con +- + semanage_port_create = _semanage.semanage_port_create +- + semanage_port_clone = _semanage.semanage_port_clone +- + semanage_port_free = _semanage.semanage_port_free +- + semanage_port_modify_local = _semanage.semanage_port_modify_local +- + semanage_port_del_local = _semanage.semanage_port_del_local +- + semanage_port_query_local = _semanage.semanage_port_query_local +- + semanage_port_exists_local = _semanage.semanage_port_exists_local +- + semanage_port_count_local = _semanage.semanage_port_count_local +- + semanage_port_iterate_local = _semanage.semanage_port_iterate_local +- + semanage_port_list_local = _semanage.semanage_port_list_local +- + semanage_port_query = _semanage.semanage_port_query +- + semanage_port_exists = _semanage.semanage_port_exists +- + semanage_port_count = _semanage.semanage_port_count +- + semanage_port_iterate = _semanage.semanage_port_iterate +- + semanage_port_list = _semanage.semanage_port_list +- + semanage_fcontext_compare = _semanage.semanage_fcontext_compare +- + semanage_fcontext_compare2 = _semanage.semanage_fcontext_compare2 +- + semanage_fcontext_key_create = _semanage.semanage_fcontext_key_create +- + semanage_fcontext_key_extract = _semanage.semanage_fcontext_key_extract +- + semanage_fcontext_key_free = _semanage.semanage_fcontext_key_free +- + semanage_fcontext_get_expr = _semanage.semanage_fcontext_get_expr +- + semanage_fcontext_set_expr = _semanage.semanage_fcontext_set_expr + SEMANAGE_FCONTEXT_ALL = _semanage.SEMANAGE_FCONTEXT_ALL + SEMANAGE_FCONTEXT_REG = _semanage.SEMANAGE_FCONTEXT_REG +@@ -387,164 +227,86 @@ + SEMANAGE_FCONTEXT_SOCK = _semanage.SEMANAGE_FCONTEXT_SOCK + SEMANAGE_FCONTEXT_LINK = _semanage.SEMANAGE_FCONTEXT_LINK + SEMANAGE_FCONTEXT_PIPE = _semanage.SEMANAGE_FCONTEXT_PIPE +- + semanage_fcontext_get_type = _semanage.semanage_fcontext_get_type +- + semanage_fcontext_get_type_str = _semanage.semanage_fcontext_get_type_str +- + semanage_fcontext_set_type = _semanage.semanage_fcontext_set_type +- + semanage_fcontext_get_con = _semanage.semanage_fcontext_get_con +- + semanage_fcontext_set_con = _semanage.semanage_fcontext_set_con +- + semanage_fcontext_create = _semanage.semanage_fcontext_create +- + semanage_fcontext_clone = _semanage.semanage_fcontext_clone +- + semanage_fcontext_free = _semanage.semanage_fcontext_free +- + semanage_fcontext_modify_local = _semanage.semanage_fcontext_modify_local +- + semanage_fcontext_del_local = _semanage.semanage_fcontext_del_local +- + semanage_fcontext_query_local = _semanage.semanage_fcontext_query_local +- + semanage_fcontext_exists_local = _semanage.semanage_fcontext_exists_local +- + semanage_fcontext_count_local = _semanage.semanage_fcontext_count_local +- + semanage_fcontext_iterate_local = _semanage.semanage_fcontext_iterate_local +- + semanage_fcontext_list_local = _semanage.semanage_fcontext_list_local +- + semanage_fcontext_query = _semanage.semanage_fcontext_query +- + semanage_fcontext_exists = _semanage.semanage_fcontext_exists +- + semanage_fcontext_count = _semanage.semanage_fcontext_count +- + semanage_fcontext_iterate = _semanage.semanage_fcontext_iterate +- + semanage_fcontext_list = _semanage.semanage_fcontext_list +- + semanage_seuser_key_create = _semanage.semanage_seuser_key_create +- + semanage_seuser_key_extract = _semanage.semanage_seuser_key_extract +- + semanage_seuser_key_free = _semanage.semanage_seuser_key_free +- + semanage_seuser_compare = _semanage.semanage_seuser_compare +- + semanage_seuser_compare2 = _semanage.semanage_seuser_compare2 +- + semanage_seuser_get_name = _semanage.semanage_seuser_get_name +- + semanage_seuser_set_name = _semanage.semanage_seuser_set_name +- + semanage_seuser_get_sename = _semanage.semanage_seuser_get_sename +- + semanage_seuser_set_sename = _semanage.semanage_seuser_set_sename +- + semanage_seuser_get_mlsrange = _semanage.semanage_seuser_get_mlsrange +- + semanage_seuser_set_mlsrange = _semanage.semanage_seuser_set_mlsrange +- + semanage_seuser_create = _semanage.semanage_seuser_create +- + semanage_seuser_clone = _semanage.semanage_seuser_clone +- + semanage_seuser_free = _semanage.semanage_seuser_free +- + semanage_seuser_modify_local = _semanage.semanage_seuser_modify_local +- + semanage_seuser_del_local = _semanage.semanage_seuser_del_local +- + semanage_seuser_query_local = _semanage.semanage_seuser_query_local +- + semanage_seuser_exists_local = _semanage.semanage_seuser_exists_local +- + semanage_seuser_count_local = _semanage.semanage_seuser_count_local +- + semanage_seuser_iterate_local = _semanage.semanage_seuser_iterate_local +- + semanage_seuser_list_local = _semanage.semanage_seuser_list_local +- + semanage_seuser_query = _semanage.semanage_seuser_query +- + semanage_seuser_exists = _semanage.semanage_seuser_exists +- + semanage_seuser_count = _semanage.semanage_seuser_count +- + semanage_seuser_iterate = _semanage.semanage_seuser_iterate +- + semanage_seuser_list = _semanage.semanage_seuser_list + SEMANAGE_PROTO_IP4 = _semanage.SEMANAGE_PROTO_IP4 + SEMANAGE_PROTO_IP6 = _semanage.SEMANAGE_PROTO_IP6 +- + semanage_node_compare = _semanage.semanage_node_compare +- + semanage_node_compare2 = _semanage.semanage_node_compare2 +- + semanage_node_key_create = _semanage.semanage_node_key_create +- + semanage_node_key_extract = _semanage.semanage_node_key_extract +- + semanage_node_key_free = _semanage.semanage_node_key_free +- + semanage_node_get_addr = _semanage.semanage_node_get_addr +- + semanage_node_get_addr_bytes = _semanage.semanage_node_get_addr_bytes +- + semanage_node_set_addr = _semanage.semanage_node_set_addr +- + semanage_node_set_addr_bytes = _semanage.semanage_node_set_addr_bytes +- + semanage_node_get_mask = _semanage.semanage_node_get_mask +- + semanage_node_get_mask_bytes = _semanage.semanage_node_get_mask_bytes +- + semanage_node_set_mask = _semanage.semanage_node_set_mask +- + semanage_node_set_mask_bytes = _semanage.semanage_node_set_mask_bytes +- + semanage_node_get_proto = _semanage.semanage_node_get_proto +- + semanage_node_set_proto = _semanage.semanage_node_set_proto +- + semanage_node_get_proto_str = _semanage.semanage_node_get_proto_str +- + semanage_node_get_con = _semanage.semanage_node_get_con +- + semanage_node_set_con = _semanage.semanage_node_set_con +- + semanage_node_create = _semanage.semanage_node_create +- + semanage_node_clone = _semanage.semanage_node_clone +- + semanage_node_free = _semanage.semanage_node_free +- + semanage_node_modify_local = _semanage.semanage_node_modify_local +- + semanage_node_del_local = _semanage.semanage_node_del_local +- + semanage_node_query_local = _semanage.semanage_node_query_local +- + semanage_node_exists_local = _semanage.semanage_node_exists_local +- + semanage_node_count_local = _semanage.semanage_node_count_local +- + semanage_node_iterate_local = _semanage.semanage_node_iterate_local +- + semanage_node_list_local = _semanage.semanage_node_list_local +- + semanage_node_query = _semanage.semanage_node_query +- + semanage_node_exists = _semanage.semanage_node_exists +- + semanage_node_count = _semanage.semanage_node_count +- + semanage_node_iterate = _semanage.semanage_node_iterate +- + semanage_node_list = _semanage.semanage_node_list + ++ +diff --exclude-from=exclude -N -u -r nsalibsemanage/src/semanageswig_python.i libsemanage-1.6.2/src/semanageswig_python.i +--- nsalibsemanage/src/semanageswig_python.i 2006-02-14 15:03:55.000000000 -0500 ++++ libsemanage-1.6.2/src/semanageswig_python.i 2006-04-03 19:12:38.000000000 -0400 +@@ -104,7 +104,7 @@ + } + + %typemap(argout) char** { +- $result = t_output_helper($result, SWIG_FromCharPtr(*$1)); ++ $result = SWIG_Python_AppendOutput($result, SWIG_FromCharPtr(*$1)); + free(*$1); + } + +@@ -119,14 +119,15 @@ + unsigned int* num_roles) { + + if ($result) { +- int value = SWIG_As_int($result); ++ int value; ++ SWIG_AsVal_int($result, &value); + if (value >= 0) { + PyObject* plist = NULL; + if (semanage_array2plist($1, (void**) *$3, *$4, + NULL, NULL, &plist) < 0) + $result = SWIG_From_int(STATUS_ERR); + else +- $result = t_output_helper($result, plist); ++ $result = SWIG_Python_AppendOutput($result, plist); + } + } + } +@@ -140,7 +141,7 @@ + } + + %typemap(argout) semanage_module_info_t ** { +- $result = t_output_helper($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); ++ $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); + } + + /** context typemaps **/ +@@ -152,7 +153,7 @@ + } + + %typemap(argout) semanage_context_t** { +- $result = t_output_helper($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); ++ $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); + } + + /** boolean typemaps **/ +@@ -169,14 +170,15 @@ + unsigned int* count) { + + if ($result) { +- int value = SWIG_As_int($result); ++ int value; ++ SWIG_AsVal_int($result, &value); + if (value >= 0) { + PyObject* plist = NULL; + if (semanage_array2plist($1, (void**) *$2, *$3, SWIGTYPE_p_semanage_bool, + (void (*) (void*)) &semanage_bool_free, &plist) < 0) + $result = SWIG_From_int(STATUS_ERR); + else +- $result = t_output_helper($result, plist); ++ $result = SWIG_Python_AppendOutput($result, plist); + } + } + } +@@ -186,11 +188,11 @@ + } + + %typemap(argout) semanage_bool_t ** { +- $result = t_output_helper($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); ++ $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); + } + + %typemap(argout) semanage_bool_key_t ** { +- $result = t_output_helper($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); ++ $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); + } + + %typemap(in, numinputs=0) semanage_bool_key_t **(semanage_bool_key_t *temp) { +@@ -211,14 +213,15 @@ + unsigned int* count) { + + if ($result) { +- int value = SWIG_As_int($result); ++ int value; ++ SWIG_AsVal_int($result, &value); + if (value >= 0) { + PyObject* plist = NULL; + if (semanage_array2plist($1, (void**) *$2, *$3, SWIGTYPE_p_semanage_fcontext, + (void (*) (void*)) &semanage_fcontext_free, &plist) < 0) + $result = SWIG_From_int(STATUS_ERR); + else +- $result = t_output_helper($result, plist); ++ $result = SWIG_Python_AppendOutput($result, plist); + } + } + } +@@ -228,11 +231,11 @@ + } + + %typemap(argout) semanage_fcontext_t ** { +- $result = t_output_helper($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); ++ $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); + } + + %typemap(argout) semanage_fcontext_key_t ** { +- $result = t_output_helper($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); ++ $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); + } + + %typemap(in, numinputs=0) semanage_fcontext_key_t **(semanage_fcontext_key_t *temp) { +@@ -254,14 +257,15 @@ + unsigned int* count) { + + if ($result) { +- int value = SWIG_As_int($result); ++ int value; ++ SWIG_AsVal_int($result, &value); + if (value >= 0) { + PyObject* plist = NULL; + if (semanage_array2plist($1, (void**) *$2, *$3, SWIGTYPE_p_semanage_iface, + (void (*) (void*)) &semanage_iface_free, &plist) < 0) + $result = SWIG_From_int(STATUS_ERR); + else +- $result = t_output_helper($result, plist); ++ $result = SWIG_Python_AppendOutput($result, plist); + } + } + } +@@ -271,11 +275,11 @@ + } + + %typemap(argout) semanage_iface_t ** { +- $result = t_output_helper($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); ++ $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); + } + + %typemap(argout) semanage_iface_key_t ** { +- $result = t_output_helper($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); ++ $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); + } + + %typemap(in, numinputs=0) semanage_iface_key_t **(semanage_iface_key_t *temp) { +@@ -297,14 +301,15 @@ + unsigned int* count) { + + if ($result) { +- int value = SWIG_As_int($result); ++ int value; ++ SWIG_AsVal_int($result, &value); + if (value >= 0) { + PyObject* plist = NULL; + if (semanage_array2plist($1, (void**) *$2, *$3, SWIGTYPE_p_semanage_seuser, + (void (*) (void*)) &semanage_seuser_free, &plist) < 0) + $result = SWIG_From_int(STATUS_ERR); + else +- $result = t_output_helper($result, plist); ++ $result = SWIG_Python_AppendOutput($result, plist); + } + } + } +@@ -314,11 +319,11 @@ + } + + %typemap(argout) semanage_seuser_t ** { +- $result = t_output_helper($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); ++ $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); + } + + %typemap(argout) semanage_seuser_key_t ** { +- $result = t_output_helper($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); ++ $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); + } + + %typemap(in, numinputs=0) semanage_seuser_key_t **(semanage_seuser_key_t *temp) { +@@ -339,14 +344,15 @@ + unsigned int* count) { + + if ($result) { +- int value = SWIG_As_int($result); ++ int value; ++ SWIG_AsVal_int($result, &value); + if (value >= 0) { + PyObject* plist = NULL; + if (semanage_array2plist($1, (void**) *$2, *$3, SWIGTYPE_p_semanage_user, + (void (*) (void*)) &semanage_user_free, &plist) < 0) + $result = SWIG_From_int(STATUS_ERR); + else +- $result = t_output_helper($result, plist); ++ $result = SWIG_Python_AppendOutput($result, plist); + } + } + } +@@ -356,11 +362,11 @@ + } + + %typemap(argout) semanage_user_t ** { +- $result = t_output_helper($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); ++ $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); + } + + %typemap(argout) semanage_user_key_t ** { +- $result = t_output_helper($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); ++ $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); + } + + %typemap(in, numinputs=0) semanage_user_key_t **(semanage_user_key_t *temp) { +@@ -381,14 +387,15 @@ + unsigned int* count) { + + if ($result) { +- int value = SWIG_As_int($result); ++ int value; ++ SWIG_AsVal_int($result, &value); + if (value >= 0) { + PyObject* plist = NULL; + if (semanage_array2plist($1, (void**) *$2, *$3, SWIGTYPE_p_semanage_port, + (void (*) (void*)) &semanage_port_free, &plist) < 0) + $result = SWIG_From_int(STATUS_ERR); + else +- $result = t_output_helper($result, plist); ++ $result = SWIG_Python_AppendOutput($result, plist); + } + } + } +@@ -398,11 +405,11 @@ + } + + %typemap(argout) semanage_port_t ** { +- $result = t_output_helper($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); ++ $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); + } + + %typemap(argout) semanage_port_key_t ** { +- $result = t_output_helper($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); ++ $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); + } + + %typemap(in, numinputs=0) semanage_port_key_t **(semanage_port_key_t *temp) { +@@ -423,14 +430,15 @@ + unsigned int* count) { + + if ($result) { +- int value = SWIG_As_int($result); ++ int value; ++ SWIG_AsVal_int($result, &value); + if (value >= 0) { + PyObject* plist = NULL; + if (semanage_array2plist($1, (void**) *$2, *$3, SWIGTYPE_p_semanage_node, + (void (*) (void*)) &semanage_node_free, &plist) < 0) + $result = SWIG_From_int(STATUS_ERR); + else +- $result = t_output_helper($result, plist); ++ $result = SWIG_Python_AppendOutput($result, plist); + } + } + } +@@ -440,12 +448,12 @@ + } + + %typemap(argout) semanage_node_t ** { +- $result = t_output_helper($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); ++ $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); + } + + + %typemap(argout) semanage_node_key_t ** { +- $result = t_output_helper($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); ++ $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); + } + + %typemap(in, numinputs=0) semanage_node_key_t **(semanage_node_key_t *temp) { +diff --exclude-from=exclude -N -u -r nsalibsemanage/src/semanageswig_wrap.c libsemanage-1.6.2/src/semanageswig_wrap.c +--- nsalibsemanage/src/semanageswig_wrap.c 2006-02-16 13:35:23.000000000 -0500 ++++ libsemanage-1.6.2/src/semanageswig_wrap.c 2006-04-03 19:12:41.000000000 -0400 +@@ -1,6 +1,6 @@ + /* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). +- * Version 1.3.24 ++ * Version 1.3.29 + * + * 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 +@@ -9,47 +9,126 @@ + * ----------------------------------------------------------------------------- */ + + #define SWIGPYTHON ++#define SWIG_PYTHON_DIRECTOR_NO_VTABLE ++/* ----------------------------------------------------------------------------- ++ * This section contains generic SWIG labels for method/variable ++ * declarations/attributes, and other compiler dependent labels. ++ * ----------------------------------------------------------------------------- */ ++ ++/* template workaround for compilers that cannot correctly implement the C++ standard */ ++#ifndef SWIGTEMPLATEDISAMBIGUATOR ++# if defined(__SUNPRO_CC) ++# if (__SUNPRO_CC <= 0x560) ++# define SWIGTEMPLATEDISAMBIGUATOR template ++# else ++# define SWIGTEMPLATEDISAMBIGUATOR ++# endif ++# else ++# define SWIGTEMPLATEDISAMBIGUATOR ++# endif ++#endif ++ ++/* inline attribute */ ++#ifndef SWIGINLINE ++# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) ++# define SWIGINLINE inline ++# else ++# define SWIGINLINE ++# endif ++#endif ++ ++/* attribute recognised by some compilers to avoid 'unused' warnings */ ++#ifndef SWIGUNUSED ++# if defined(__GNUC__) ++# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) ++# define SWIGUNUSED __attribute__ ((__unused__)) ++# else ++# define SWIGUNUSED ++# endif ++# elif defined(__ICC) ++# define SWIGUNUSED __attribute__ ((__unused__)) ++# else ++# define SWIGUNUSED ++# endif ++#endif ++ ++#ifndef SWIGUNUSEDPARM ++# ifdef __cplusplus ++# define SWIGUNUSEDPARM(p) ++# else ++# define SWIGUNUSEDPARM(p) p SWIGUNUSED ++# endif ++#endif ++ ++/* internal SWIG method */ ++#ifndef SWIGINTERN ++# define SWIGINTERN static SWIGUNUSED ++#endif ++ ++/* internal inline SWIG method */ ++#ifndef SWIGINTERNINLINE ++# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE ++#endif + +-#ifndef SWIG_TEMPLATE_DISAMBIGUATOR +-# if defined(__SUNPRO_CC) +-# define SWIG_TEMPLATE_DISAMBIGUATOR template +-# else +-# define SWIG_TEMPLATE_DISAMBIGUATOR ++/* exporting methods */ ++#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) ++# ifndef GCC_HASCLASSVISIBILITY ++# define GCC_HASCLASSVISIBILITY + # endif + #endif + ++#ifndef SWIGEXPORT ++# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) ++# if defined(STATIC_LINKED) ++# define SWIGEXPORT ++# else ++# define SWIGEXPORT __declspec(dllexport) ++# endif ++# else ++# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) ++# define SWIGEXPORT __attribute__ ((visibility("default"))) ++# else ++# define SWIGEXPORT ++# endif ++# endif ++#endif ++ ++/* calling conventions for Windows */ ++#ifndef SWIGSTDCALL ++# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) ++# define SWIGSTDCALL __stdcall ++# else ++# define SWIGSTDCALL ++# endif ++#endif ++ ++/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ ++#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) ++# define _CRT_SECURE_NO_DEPRECATE ++#endif ++ + ++/* Python.h has to appear first */ + #include + +-/*********************************************************************** ++/* ----------------------------------------------------------------------------- + * swigrun.swg + * +- * This file contains generic CAPI SWIG runtime support for pointer +- * type checking. +- * +- ************************************************************************/ ++ * This file contains generic CAPI SWIG runtime support for pointer ++ * type checking. ++ * ----------------------------------------------------------------------------- */ + + /* This should only be incremented when either the layout of swig_type_info changes, + or for whatever reason, the runtime changes incompatibly */ +-#define SWIG_RUNTIME_VERSION "1" ++#define SWIG_RUNTIME_VERSION "2" + + /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ + #ifdef SWIG_TYPE_TABLE +-#define SWIG_QUOTE_STRING(x) #x +-#define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) +-#define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) +-#else +-#define SWIG_TYPE_TABLE_NAME +-#endif +- +-#include +- +-#ifndef SWIGINLINE +-#if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +-# define SWIGINLINE inline ++# define SWIG_QUOTE_STRING(x) #x ++# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) ++# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) + #else +-# define SWIGINLINE +-#endif ++# define SWIG_TYPE_TABLE_NAME + #endif + + /* +@@ -60,13 +139,158 @@ + But only do this if is strictly necessary, ie, if you have problems + with your compiler or so. + */ ++ + #ifndef SWIGRUNTIME +-#define SWIGRUNTIME static ++# define SWIGRUNTIME SWIGINTERN + #endif ++ + #ifndef SWIGRUNTIMEINLINE +-#define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE ++# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE ++#endif ++ ++/* Generic buffer size */ ++#ifndef SWIG_BUFFER_SIZE ++# define SWIG_BUFFER_SIZE 1024 ++#endif ++ ++/* Flags for pointer conversions */ ++#define SWIG_POINTER_DISOWN 0x1 ++ ++/* Flags for new pointer objects */ ++#define SWIG_POINTER_OWN 0x1 ++ ++ ++/* ++ Flags/methods for returning states. ++ ++ The swig conversion methods, as ConvertPtr, return and integer ++ that tells if the conversion was successful or not. And if not, ++ an error code can be returned (see swigerrors.swg for the codes). ++ ++ Use the following macros/flags to set or process the returning ++ states. ++ ++ In old swig versions, you usually write code as: ++ ++ if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { ++ // success code ++ } else { ++ //fail code ++ } ++ ++ Now you can be more explicit as: ++ ++ int res = SWIG_ConvertPtr(obj,vptr,ty.flags); ++ if (SWIG_IsOK(res)) { ++ // success code ++ } else { ++ // fail code ++ } ++ ++ that seems to be the same, but now you can also do ++ ++ Type *ptr; ++ int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); ++ if (SWIG_IsOK(res)) { ++ // success code ++ if (SWIG_IsNewObj(res) { ++ ... ++ delete *ptr; ++ } else { ++ ... ++ } ++ } else { ++ // fail code ++ } ++ ++ I.e., now SWIG_ConvertPtr can return new objects and you can ++ identify the case and take care of the deallocation. Of course that ++ requires also to SWIG_ConvertPtr to return new result values, as ++ ++ int SWIG_ConvertPtr(obj, ptr,...) { ++ if () { ++ if () { ++ *ptr = ; ++ return SWIG_NEWOBJ; ++ } else { ++ *ptr = ; ++ return SWIG_OLDOBJ; ++ } ++ } else { ++ return SWIG_BADOBJ; ++ } ++ } ++ ++ Of course, returning the plain '0(success)/-1(fail)' still works, but you can be ++ more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the ++ swig errors code. ++ ++ Finally, if the SWIG_CASTRANK_MODE is enabled, the result code ++ allows to return the 'cast rank', for example, if you have this ++ ++ int food(double) ++ int fooi(int); ++ ++ and you call ++ ++ food(1) // cast rank '1' (1 -> 1.0) ++ fooi(1) // cast rank '0' ++ ++ just use the SWIG_AddCast()/SWIG_CheckState() ++ ++ ++ */ ++#define SWIG_OK (0) ++#define SWIG_ERROR (-1) ++#define SWIG_IsOK(r) (r >= 0) ++#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) ++ ++/* The CastRankLimit says how many bits are used for the cast rank */ ++#define SWIG_CASTRANKLIMIT (1 << 8) ++/* The NewMask denotes the object was created (using new/malloc) */ ++#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) ++/* The TmpMask is for in/out typemaps that use temporal objects */ ++#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) ++/* Simple returning values */ ++#define SWIG_BADOBJ (SWIG_ERROR) ++#define SWIG_OLDOBJ (SWIG_OK) ++#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) ++#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) ++/* Check, add and del mask methods */ ++#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) ++#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) ++#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) ++#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) ++#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) ++#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) ++ ++ ++/* Cast-Rank Mode */ ++#if defined(SWIG_CASTRANK_MODE) ++# ifndef SWIG_TypeRank ++# define SWIG_TypeRank unsigned long ++# endif ++# ifndef SWIG_MAXCASTRANK /* Default cast allowed */ ++# define SWIG_MAXCASTRANK (2) ++# endif ++# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) ++# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) ++SWIGINTERNINLINE int SWIG_AddCast(int r) { ++ return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; ++} ++SWIGINTERNINLINE int SWIG_CheckState(int r) { ++ return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; ++} ++#else /* no cast-rank mode */ ++# define SWIG_AddCast ++# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) + #endif + ++ ++ ++ ++#include ++ + #ifdef __cplusplus + extern "C" { + #endif +@@ -74,16 +298,36 @@ + typedef void *(*swig_converter_func)(void *); + typedef struct swig_type_info *(*swig_dycast_func)(void **); + ++/* Structure to store inforomation on one type */ + typedef struct swig_type_info { +- const char *name; +- swig_converter_func converter; +- const char *str; +- void *clientdata; +- swig_dycast_func dcast; +- struct swig_type_info *next; +- struct swig_type_info *prev; ++ const char *name; /* mangled name of this type */ ++ const char *str; /* human readable name of this type */ ++ swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ ++ struct swig_cast_info *cast; /* linked list of types that can cast into this type */ ++ void *clientdata; /* language specific type data */ ++ int owndata; /* flag if the structure owns the clientdata */ + } swig_type_info; + ++/* Structure to store a type and conversion function used for casting */ ++typedef struct swig_cast_info { ++ swig_type_info *type; /* pointer to type that is equivalent to this type */ ++ swig_converter_func converter; /* function to cast the void pointers */ ++ struct swig_cast_info *next; /* pointer to next cast in linked list */ ++ struct swig_cast_info *prev; /* pointer to the previous cast */ ++} swig_cast_info; ++ ++/* Structure used to store module information ++ * Each module generates one structure like this, and the runtime collects ++ * all of these structures and stores them in a circularly linked list.*/ ++typedef struct swig_module_info { ++ swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ ++ size_t size; /* Number of types in this module */ ++ struct swig_module_info *next; /* Pointer to next element in circularly linked list */ ++ swig_type_info **type_initial; /* Array of initially generated type structures */ ++ swig_cast_info **cast_initial; /* Array of initially generated casting structures */ ++ void *clientdata; /* Language specific module data */ ++} swig_module_info; ++ + /* + Compare two type names skipping the space characters, therefore + "char*" == "char *" and "Class" == "Class", etc. +@@ -97,13 +341,14 @@ + for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { + while ((*f1 == ' ') && (f1 != l1)) ++f1; + while ((*f2 == ' ') && (f2 != l2)) ++f2; +- if (*f1 != *f2) return *f1 - *f2; ++ if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; + } + return (l1 - f1) - (l2 - f2); + } + + /* + Check type equivalence in a name list like ||... ++ Return 0 if not equal, 1 if equal + */ + SWIGRUNTIME int + SWIG_TypeEquiv(const char *nb, const char *tb) { +@@ -114,96 +359,73 @@ + for (nb = ne; *ne; ++ne) { + if (*ne == '|') break; + } +- equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0; ++ equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; + if (*ne) ++ne; + } + return equiv; + } + + /* +- Register a type mapping with the type-checking ++ Check type equivalence in a name list like ||... ++ Return 0 if equal, -1 if nb < tb, 1 if nb > tb + */ +-SWIGRUNTIME swig_type_info * +-SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) { +- swig_type_info *tc, *head, *ret, *next; +- /* Check to see if this type has already been registered */ +- tc = *tl; +- while (tc) { +- /* check simple type equivalence */ +- int typeequiv = (strcmp(tc->name, ti->name) == 0); +- /* check full type equivalence, resolving typedefs */ +- if (!typeequiv) { +- /* only if tc is not a typedef (no '|' on it) */ +- if (tc->str && ti->str && !strstr(tc->str,"|")) { +- typeequiv = SWIG_TypeEquiv(ti->str,tc->str); +- } +- } +- if (typeequiv) { +- /* Already exists in the table. Just add additional types to the list */ +- if (ti->clientdata) tc->clientdata = ti->clientdata; +- head = tc; +- next = tc->next; +- goto l1; +- } +- tc = tc->prev; +- } +- head = ti; +- next = 0; +- +- /* Place in list */ +- ti->prev = *tl; +- *tl = ti; +- +- /* Build linked lists */ +- l1: +- ret = head; +- tc = ti + 1; +- /* Patch up the rest of the links */ +- while (tc->name) { +- head->next = tc; +- tc->prev = head; +- head = tc; +- tc++; ++SWIGRUNTIME int ++SWIG_TypeCompare(const char *nb, const char *tb) { ++ int equiv = 0; ++ const char* te = tb + strlen(tb); ++ const char* ne = nb; ++ while (!equiv && *ne) { ++ for (nb = ne; *ne; ++ne) { ++ if (*ne == '|') break; ++ } ++ equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; ++ if (*ne) ++ne; + } +- if (next) next->prev = head; +- head->next = next; +- +- return ret; ++ return equiv; + } + ++ ++/* think of this as a c++ template<> or a scheme macro */ ++#define SWIG_TypeCheck_Template(comparison, ty) \ ++ if (ty) { \ ++ swig_cast_info *iter = ty->cast; \ ++ while (iter) { \ ++ if (comparison) { \ ++ if (iter == ty->cast) return iter; \ ++ /* Move iter to the top of the linked list */ \ ++ iter->prev->next = iter->next; \ ++ if (iter->next) \ ++ iter->next->prev = iter->prev; \ ++ iter->next = ty->cast; \ ++ iter->prev = 0; \ ++ if (ty->cast) ty->cast->prev = iter; \ ++ ty->cast = iter; \ ++ return iter; \ ++ } \ ++ iter = iter->next; \ ++ } \ ++ } \ ++ return 0 ++ + /* + Check the typename + */ +-SWIGRUNTIME swig_type_info * ++SWIGRUNTIME swig_cast_info * + SWIG_TypeCheck(const char *c, swig_type_info *ty) { +- swig_type_info *s; +- if (!ty) return 0; /* Void pointer */ +- s = ty->next; /* First element always just a name */ +- do { +- if (strcmp(s->name,c) == 0) { +- if (s == ty->next) return s; +- /* Move s to the top of the linked list */ +- s->prev->next = s->next; +- if (s->next) { +- s->next->prev = s->prev; +- } +- /* Insert s as second element in the list */ +- s->next = ty->next; +- if (ty->next) ty->next->prev = s; +- ty->next = s; +- s->prev = ty; +- return s; +- } +- s = s->next; +- } while (s && (s != ty->next)); +- return 0; ++ SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty); ++} ++ ++/* Same as previous function, except strcmp is replaced with a pointer comparison */ ++SWIGRUNTIME swig_cast_info * ++SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) { ++ SWIG_TypeCheck_Template(iter->type == from, into); + } + + /* + Cast a pointer up an inheritance hierarchy + */ + SWIGRUNTIMEINLINE void * +-SWIG_TypeCast(swig_type_info *ty, void *ptr) { ++SWIG_TypeCast(swig_cast_info *ty, void *ptr) { + return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr); + } + +@@ -239,6 +461,7 @@ + type, separated by vertical-bar characters. We choose + to print the last name, as it is often (?) the most + specific. */ ++ if (!type) return NULL; + if (type->str != NULL) { + const char *last_name = type->str; + const char *s; +@@ -250,41 +473,108 @@ + return type->name; + } + +-/* +- Search for a swig_type_info structure +-*/ +-SWIGRUNTIME swig_type_info * +-SWIG_TypeQueryTL(swig_type_info *tl, const char *name) { +- swig_type_info *ty = tl; +- while (ty) { +- if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty; +- if (ty->name && (strcmp(name,ty->name) == 0)) return ty; +- ty = ty->prev; +- } +- return 0; +-} +- + /* + Set the clientdata field for a type + */ + SWIGRUNTIME void +-SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) { +- swig_type_info *tc, *equiv; +- if (ti->clientdata) return; ++SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { ++ swig_cast_info *cast = ti->cast; + /* if (ti->clientdata == clientdata) return; */ + ti->clientdata = clientdata; +- equiv = ti->next; +- while (equiv) { +- if (!equiv->converter) { +- tc = tl; +- while (tc) { +- if ((strcmp(tc->name, equiv->name) == 0)) +- SWIG_TypeClientDataTL(tl,tc,clientdata); +- tc = tc->prev; ++ ++ while (cast) { ++ if (!cast->converter) { ++ swig_type_info *tc = cast->type; ++ if (!tc->clientdata) { ++ SWIG_TypeClientData(tc, clientdata); + } ++ } ++ cast = cast->next; ++ } ++} ++SWIGRUNTIME void ++SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { ++ SWIG_TypeClientData(ti, clientdata); ++ ti->owndata = 1; ++} ++ ++/* ++ Search for a swig_type_info structure only by mangled name ++ Search is a O(log #types) ++ ++ We start searching at module start, and finish searching when start == end. ++ Note: if start == end at the beginning of the function, we go all the way around ++ the circular list. ++*/ ++SWIGRUNTIME swig_type_info * ++SWIG_MangledTypeQueryModule(swig_module_info *start, ++ swig_module_info *end, ++ const char *name) { ++ swig_module_info *iter = start; ++ do { ++ if (iter->size) { ++ register size_t l = 0; ++ register size_t r = iter->size - 1; ++ do { ++ /* since l+r >= 0, we can (>> 1) instead (/ 2) */ ++ register size_t i = (l + r) >> 1; ++ const char *iname = iter->types[i]->name; ++ if (iname) { ++ register int compare = strcmp(name, iname); ++ if (compare == 0) { ++ return iter->types[i]; ++ } else if (compare < 0) { ++ if (i) { ++ r = i - 1; ++ } else { ++ break; ++ } ++ } else if (compare > 0) { ++ l = i + 1; ++ } ++ } else { ++ break; /* should never happen */ ++ } ++ } while (l <= r); + } +- equiv = equiv->next; ++ iter = iter->next; ++ } while (iter != end); ++ return 0; ++} ++ ++/* ++ Search for a swig_type_info structure for either a mangled name or a human readable name. ++ It first searches the mangled names of the types, which is a O(log #types) ++ If a type is not found it then searches the human readable names, which is O(#types). ++ ++ We start searching at module start, and finish searching when start == end. ++ Note: if start == end at the beginning of the function, we go all the way around ++ the circular list. ++*/ ++SWIGRUNTIME swig_type_info * ++SWIG_TypeQueryModule(swig_module_info *start, ++ swig_module_info *end, ++ const char *name) { ++ /* STEP 1: Search the name field using binary search */ ++ swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); ++ if (ret) { ++ return ret; ++ } else { ++ /* STEP 2: If the type hasn't been found, do a complete search ++ of the str field (the human readable name) */ ++ swig_module_info *iter = start; ++ do { ++ register size_t i = 0; ++ for (; i < iter->size; ++i) { ++ if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) ++ return iter->types[i]; ++ } ++ iter = iter->next; ++ } while (iter != end); + } ++ ++ /* neither found a match */ ++ return 0; + } + + /* +@@ -292,12 +582,11 @@ + */ + SWIGRUNTIME char * + SWIG_PackData(char *c, void *ptr, size_t sz) { +- static char hex[17] = "0123456789abcdef"; +- unsigned char *u = (unsigned char *) ptr; +- const unsigned char *eu = u + sz; +- register unsigned char uu; ++ static const char hex[17] = "0123456789abcdef"; ++ register const unsigned char *u = (unsigned char *) ptr; ++ register const unsigned char *eu = u + sz; + for (; u != eu; ++u) { +- uu = *u; ++ register unsigned char uu = *u; + *(c++) = hex[(uu & 0xf0) >> 4]; + *(c++) = hex[uu & 0xf]; + } +@@ -310,10 +599,10 @@ + SWIGRUNTIME const char * + SWIG_UnpackData(const char *c, void *ptr, size_t sz) { + register unsigned char *u = (unsigned char *) ptr; +- register const unsigned char *eu = u + sz; ++ register const unsigned char *eu = u + sz; + for (; u != eu; ++u) { +- register int d = *(c++); +- register unsigned char uu = 0; ++ register char d = *(c++); ++ register unsigned char uu; + if ((d >= '0') && (d <= '9')) + uu = ((d - '0') << 4); + else if ((d >= 'a') && (d <= 'f')) +@@ -332,30 +621,6 @@ + return c; + } + +-/* +- This function will propagate the clientdata field of type to any new +- swig_type_info structures that have been added into the list of +- equivalent types. It is like calling SWIG_TypeClientData(type, +- clientdata) a second time. +-*/ +-SWIGRUNTIME void +-SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) { +- swig_type_info *equiv = type->next; +- swig_type_info *tc; +- if (!type->clientdata) return; +- while (equiv) { +- if (!equiv->converter) { +- tc = tl; +- while (tc) { +- if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata) +- SWIG_TypeClientDataTL(tl,tc, type->clientdata); +- tc = tc->prev; +- } +- } +- equiv = equiv->next; +- } +-} +- + /* + Pack 'void *' into a string buffer. + */ +@@ -415,294 +680,886 @@ + } + #endif + +-/*********************************************************************** +- * common.swg +- * +- * This file contains generic SWIG runtime support for pointer +- * type checking as well as a few commonly used macros to control +- * external linkage. +- * +- * Author : David Beazley (beazley@cs.uchicago.edu) +- * +- * Copyright (c) 1999-2000, The University of Chicago +- * +- * This file may be freely redistributed without license or fee provided +- * this copyright message remains intact. +- ************************************************************************/ ++/* Errors in SWIG */ ++#define SWIG_UnknownError -1 ++#define SWIG_IOError -2 ++#define SWIG_RuntimeError -3 ++#define SWIG_IndexError -4 ++#define SWIG_TypeError -5 ++#define SWIG_DivisionByZero -6 ++#define SWIG_OverflowError -7 ++#define SWIG_SyntaxError -8 ++#define SWIG_ValueError -9 ++#define SWIG_SystemError -10 ++#define SWIG_AttributeError -11 ++#define SWIG_MemoryError -12 ++#define SWIG_NullReferenceError -13 + + +-#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +-# if !defined(STATIC_LINKED) +-# define SWIGEXPORT(a) __declspec(dllexport) a +-# else +-# define SWIGEXPORT(a) a +-# endif +-#else +-# define SWIGEXPORT(a) a +-#endif + +-#ifdef __cplusplus +-extern "C" { ++/* Python.h has to appear first */ ++#include ++ ++/* Add PyOS_snprintf for old Pythons */ ++#if PY_VERSION_HEX < 0x02020000 ++# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM) ++# define PyOS_snprintf _snprintf ++# else ++# define PyOS_snprintf snprintf ++# endif + #endif + ++/* A crude PyString_FromFormat implementation for old Pythons */ ++#if PY_VERSION_HEX < 0x02020000 + +-/*************************************************************************/ ++#ifndef SWIG_PYBUFFER_SIZE ++# define SWIG_PYBUFFER_SIZE 1024 ++#endif + ++static PyObject * ++PyString_FromFormat(const char *fmt, ...) { ++ va_list ap; ++ char buf[SWIG_PYBUFFER_SIZE * 2]; ++ int res; ++ va_start(ap, fmt); ++ res = vsnprintf(buf, sizeof(buf), fmt, ap); ++ va_end(ap); ++ return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf); ++} ++#endif + +-/* The static type info list */ ++/* Add PyObject_Del for old Pythons */ ++#if PY_VERSION_HEX < 0x01060000 ++# define PyObject_Del(op) PyMem_DEL((op)) ++#endif ++#ifndef PyObject_DEL ++# define PyObject_DEL PyObject_Del ++#endif + +-static swig_type_info *swig_type_list = 0; +-static swig_type_info **swig_type_list_handle = &swig_type_list; +- ++/* A crude PyExc_StopIteration exception for old Pythons */ ++#if PY_VERSION_HEX < 0x02020000 ++# ifndef PyExc_StopIteration ++# define PyExc_StopIteration PyExc_RuntimeError ++# endif ++# ifndef PyObject_GenericGetAttr ++# define PyObject_GenericGetAttr 0 ++# endif ++#endif ++/* Py_NotImplemented is defined in 2.1 and up. */ ++#if PY_VERSION_HEX < 0x02010000 ++# ifndef Py_NotImplemented ++# define Py_NotImplemented PyExc_RuntimeError ++# endif ++#endif + +-/* Register a type mapping with the type-checking */ +-static swig_type_info * +-SWIG_TypeRegister(swig_type_info *ti) { +- return SWIG_TypeRegisterTL(swig_type_list_handle, ti); +-} + +-/* Search for a swig_type_info structure */ +-static swig_type_info * +-SWIG_TypeQuery(const char *name) { +- return SWIG_TypeQueryTL(*swig_type_list_handle, name); +-} ++/* A crude PyString_AsStringAndSize implementation for old Pythons */ ++#if PY_VERSION_HEX < 0x02010000 ++# ifndef PyString_AsStringAndSize ++# define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;} ++# endif ++#endif + +-/* Set the clientdata field for a type */ +-static void +-SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { +- SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata); +-} ++/* PySequence_Size for old Pythons */ ++#if PY_VERSION_HEX < 0x02000000 ++# ifndef PySequence_Size ++# define PySequence_Size PySequence_Length ++# endif ++#endif + +-/* This function will propagate the clientdata field of type to +-* any new swig_type_info structures that have been added into the list +-* of equivalent types. It is like calling +-* SWIG_TypeClientData(type, clientdata) a second time. +-*/ +-static void +-SWIG_PropagateClientData(swig_type_info *type) { +- SWIG_PropagateClientDataTL(*swig_type_list_handle, type); +-} + +-#ifdef __cplusplus ++/* PyBool_FromLong for old Pythons */ ++#if PY_VERSION_HEX < 0x02030000 ++static ++PyObject *PyBool_FromLong(long ok) ++{ ++ PyObject *result = ok ? Py_True : Py_False; ++ Py_INCREF(result); ++ return result; + } + #endif + ++ + /* ----------------------------------------------------------------------------- +- * SWIG API. Portion that goes into the runtime ++ * error manipulation + * ----------------------------------------------------------------------------- */ + +-#ifdef __cplusplus +-extern "C" { ++SWIGRUNTIME PyObject* ++SWIG_Python_ErrorType(int code) { ++ PyObject* type = 0; ++ switch(code) { ++ case SWIG_MemoryError: ++ type = PyExc_MemoryError; ++ break; ++ case SWIG_IOError: ++ type = PyExc_IOError; ++ break; ++ case SWIG_RuntimeError: ++ type = PyExc_RuntimeError; ++ break; ++ case SWIG_IndexError: ++ type = PyExc_IndexError; ++ break; ++ case SWIG_TypeError: ++ type = PyExc_TypeError; ++ break; ++ case SWIG_DivisionByZero: ++ type = PyExc_ZeroDivisionError; ++ break; ++ case SWIG_OverflowError: ++ type = PyExc_OverflowError; ++ break; ++ case SWIG_SyntaxError: ++ type = PyExc_SyntaxError; ++ break; ++ case SWIG_ValueError: ++ type = PyExc_ValueError; ++ break; ++ case SWIG_SystemError: ++ type = PyExc_SystemError; ++ break; ++ case SWIG_AttributeError: ++ type = PyExc_AttributeError; ++ break; ++ default: ++ type = PyExc_RuntimeError; ++ } ++ return type; ++} ++ ++ ++SWIGRUNTIME void ++SWIG_Python_AddErrorMsg(const char* mesg) ++{ ++ PyObject *type = 0; ++ PyObject *value = 0; ++ PyObject *traceback = 0; ++ ++ if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback); ++ if (value) { ++ PyObject *old_str = PyObject_Str(value); ++ PyErr_Clear(); ++ Py_XINCREF(type); ++ PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg); ++ Py_DECREF(old_str); ++ Py_DECREF(value); ++ } else { ++ PyErr_Format(PyExc_RuntimeError, mesg); ++ } ++} ++ ++ ++ ++#if defined(SWIG_PYTHON_NO_THREADS) ++# if defined(SWIG_PYTHON_THREADS) ++# undef SWIG_PYTHON_THREADS ++# endif ++#endif ++#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */ ++# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL) ++# if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */ ++# define SWIG_PYTHON_USE_GIL ++# endif ++# endif ++# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */ ++# ifndef SWIG_PYTHON_INITIALIZE_THREADS ++# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads() ++# endif ++# ifdef __cplusplus /* C++ code */ ++ class SWIG_Python_Thread_Block { ++ bool status; ++ PyGILState_STATE state; ++ public: ++ void end() { if (status) { PyGILState_Release(state); status = false;} } ++ SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {} ++ ~SWIG_Python_Thread_Block() { end(); } ++ }; ++ class SWIG_Python_Thread_Allow { ++ bool status; ++ PyThreadState *save; ++ public: ++ void end() { if (status) { PyEval_RestoreThread(save); status = false; }} ++ SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {} ++ ~SWIG_Python_Thread_Allow() { end(); } ++ }; ++# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block ++# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end() ++# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow ++# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end() ++# else /* C code */ ++# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure() ++# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block) ++# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread() ++# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow) ++# endif ++# else /* Old thread way, not implemented, user must provide it */ ++# if !defined(SWIG_PYTHON_INITIALIZE_THREADS) ++# define SWIG_PYTHON_INITIALIZE_THREADS ++# endif ++# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK) ++# define SWIG_PYTHON_THREAD_BEGIN_BLOCK ++# endif ++# if !defined(SWIG_PYTHON_THREAD_END_BLOCK) ++# define SWIG_PYTHON_THREAD_END_BLOCK ++# endif ++# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW) ++# define SWIG_PYTHON_THREAD_BEGIN_ALLOW ++# endif ++# if !defined(SWIG_PYTHON_THREAD_END_ALLOW) ++# define SWIG_PYTHON_THREAD_END_ALLOW ++# endif ++# endif ++#else /* No thread support */ ++# define SWIG_PYTHON_INITIALIZE_THREADS ++# define SWIG_PYTHON_THREAD_BEGIN_BLOCK ++# define SWIG_PYTHON_THREAD_END_BLOCK ++# define SWIG_PYTHON_THREAD_BEGIN_ALLOW ++# define SWIG_PYTHON_THREAD_END_ALLOW + #endif + + /* ----------------------------------------------------------------------------- +- * for internal method declarations ++ * Python API portion that goes into the runtime + * ----------------------------------------------------------------------------- */ + +-#ifndef SWIGINTERN +-#define SWIGINTERN static +-#endif +- +-#ifndef SWIGINTERNSHORT + #ifdef __cplusplus +-#define SWIGINTERNSHORT static inline +-#else /* C case */ +-#define SWIGINTERNSHORT static +-#endif /* __cplusplus */ ++extern "C" { ++#if 0 ++} /* cc-mode */ ++#endif + #endif +- +- +-/* +- Exception handling in wrappers +-*/ +-#define SWIG_fail goto fail +-#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg) +-#define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0) +-#define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1) +-#define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj) +-#define SWIG_null_ref(type) SWIG_Python_NullRef(type) +- +-/* +- Contract support +-*/ +-#define SWIG_contract_assert(expr, msg) \ +- if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else + + /* ----------------------------------------------------------------------------- + * Constant declarations + * ----------------------------------------------------------------------------- */ + + /* Constant Types */ +-#define SWIG_PY_INT 1 +-#define SWIG_PY_FLOAT 2 +-#define SWIG_PY_STRING 3 + #define SWIG_PY_POINTER 4 + #define SWIG_PY_BINARY 5 + + /* Constant information structure */ + typedef struct swig_const_info { +- int type; +- char *name; +- long lvalue; +- double dvalue; +- void *pvalue; +- swig_type_info **ptype; ++ int type; ++ char *name; ++ long lvalue; ++ double dvalue; ++ void *pvalue; ++ swig_type_info **ptype; + } swig_const_info; + +- +-/* ----------------------------------------------------------------------------- +- * Alloc. memory flags +- * ----------------------------------------------------------------------------- */ +-#define SWIG_OLDOBJ 1 +-#define SWIG_NEWOBJ SWIG_OLDOBJ + 1 +-#define SWIG_PYSTR SWIG_NEWOBJ + 1 +- + #ifdef __cplusplus ++#if 0 ++{ /* cc-mode */ ++#endif + } + #endif + + +-/*********************************************************************** ++/* ----------------------------------------------------------------------------- ++ * See the LICENSE file for information on copyright, usage and redistribution ++ * of SWIG, and the README file for authors - http://www.swig.org/release.html. ++ * + * pyrun.swg + * +- * This file contains the runtime support for Python modules +- * and includes code for managing global variables and pointer +- * type checking. ++ * This file contains the runtime support for Python modules ++ * and includes code for managing global variables and pointer ++ * type checking. + * +- * Author : David Beazley (beazley@cs.uchicago.edu) +- ************************************************************************/ ++ * ----------------------------------------------------------------------------- */ + + /* Common SWIG API */ +-#define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags) +-#define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags) +-#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) +- + +-/* Python-specific SWIG API */ +-#define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags) +-#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) ++/* for raw pointers */ ++#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) ++#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags) ++#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own) ++#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags) ++#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty) ++#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src) ++#define swig_owntype int + ++/* for raw packed data */ ++#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) ++#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) + +-/* ----------------------------------------------------------------------------- +- * Pointer declarations +- * ----------------------------------------------------------------------------- */ +-/* +- Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent +- C/C++ pointers in the python side. Very useful for debugging, but +- not always safe. +-*/ +-#if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES) +-# define SWIG_COBJECT_TYPES +-#endif ++/* for class or struct pointers */ ++#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags) ++#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags) + +-/* Flags for pointer conversion */ +-#define SWIG_POINTER_EXCEPTION 0x1 +-#define SWIG_POINTER_DISOWN 0x2 ++/* for C or C++ function pointers */ ++#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type) ++#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0) + ++/* for C++ member pointers, ie, member methods */ ++#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) ++#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) + +-#ifdef __cplusplus +-extern "C" { +-#endif + +-/* ----------------------------------------------------------------------------- +- * Create a new pointer string +- * ----------------------------------------------------------------------------- */ ++/* Runtime API */ + +-#ifndef SWIG_BUFFER_SIZE +-#define SWIG_BUFFER_SIZE 1024 +-#endif ++#define SWIG_GetModule(clientdata) SWIG_Python_GetModule() ++#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer) ++#define SWIG_NewClientData(obj) PySwigClientData_New(obj) + +-#if defined(SWIG_COBJECT_TYPES) +-#if !defined(SWIG_COBJECT_PYTHON) +-/* ----------------------------------------------------------------------------- +- * Implements a simple Swig Object type, and use it instead of PyCObject +- * ----------------------------------------------------------------------------- */ ++#define SWIG_SetErrorObj SWIG_Python_SetErrorObj ++#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg ++#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code) ++#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) ++#define SWIG_fail goto fail + +-typedef struct { +- PyObject_HEAD +- void *ptr; +- const char *desc; +-} PySwigObject; + +-/* Declarations for objects of type PySwigObject */ ++/* Runtime API implementation */ + +-SWIGRUNTIME int +-PySwigObject_print(PySwigObject *v, FILE *fp, int flags) +-{ +- char result[SWIG_BUFFER_SIZE]; +- if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) { +- fputs("", fp); +- return 0; +- } else { +- return 1; +- } +-} +- +-SWIGRUNTIME PyObject * +-PySwigObject_repr(PySwigObject *v) +-{ +- char result[SWIG_BUFFER_SIZE]; +- return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ? +- PyString_FromFormat("", result) : 0; +-} ++/* Error manipulation */ + +-SWIGRUNTIME PyObject * +-PySwigObject_str(PySwigObject *v) +-{ +- char result[SWIG_BUFFER_SIZE]; +- return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ? +- PyString_FromString(result) : 0; ++SWIGINTERN void ++SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) { ++ SWIG_PYTHON_THREAD_BEGIN_BLOCK; ++ PyErr_SetObject(errtype, obj); ++ Py_DECREF(obj); ++ SWIG_PYTHON_THREAD_END_BLOCK; + } + +-SWIGRUNTIME PyObject * +-PySwigObject_long(PySwigObject *v) +-{ +- return PyLong_FromUnsignedLong((unsigned long) v->ptr); ++SWIGINTERN void ++SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) { ++ SWIG_PYTHON_THREAD_BEGIN_BLOCK; ++ PyErr_SetString(errtype, (char *) msg); ++ SWIG_PYTHON_THREAD_END_BLOCK; + } + +-SWIGRUNTIME PyObject * +-PySwigObject_oct(PySwigObject *v) +-{ +- char buf[100]; +- unsigned long x = (unsigned long)v->ptr; +- if (x == 0) +- strcpy(buf, "0"); +- else +- PyOS_snprintf(buf, sizeof(buf), "0%lo", x); +- return PyString_FromString(buf); +-} ++#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj) + +-SWIGRUNTIME PyObject * +-PySwigObject_hex(PySwigObject *v) +-{ +- char buf[100]; +- PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr); +- return PyString_FromString(buf); ++/* Set a constant value */ ++ ++SWIGINTERN void ++SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) { ++ PyDict_SetItemString(d, (char*) name, obj); ++ Py_DECREF(obj); + } + +-SWIGRUNTIME int +-PySwigObject_compare(PySwigObject *v, PySwigObject *w) +-{ +- int c = strcmp(v->desc, w->desc); +- if (c) { +- return c; +- } else { +- void *i = v->ptr; +- void *j = w->ptr; +- return (i < j) ? -1 : (i > j) ? 1 : 0; ++/* Append a value to the result obj */ ++ ++SWIGINTERN PyObject* ++SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) { ++#if !defined(SWIG_PYTHON_OUTPUT_TUPLE) ++ if (!result) { ++ result = obj; ++ } else if (result == Py_None) { ++ Py_DECREF(result); ++ result = obj; ++ } else { ++ if (!PyList_Check(result)) { ++ PyObject *o2 = result; ++ result = PyList_New(1); ++ PyList_SetItem(result, 0, o2); ++ } ++ PyList_Append(result,obj); ++ Py_DECREF(obj); ++ } ++ return result; ++#else ++ PyObject* o2; ++ PyObject* o3; ++ if (!result) { ++ result = obj; ++ } else if (result == Py_None) { ++ Py_DECREF(result); ++ result = obj; ++ } else { ++ if (!PyTuple_Check(result)) { ++ o2 = result; ++ result = PyTuple_New(1); ++ PyTuple_SET_ITEM(result, 0, o2); ++ } ++ o3 = PyTuple_New(1); ++ PyTuple_SET_ITEM(o3, 0, obj); ++ o2 = result; ++ result = PySequence_Concat(o2, o3); ++ Py_DECREF(o2); ++ Py_DECREF(o3); ++ } ++ return result; ++#endif ++} ++ ++/* Unpack the argument tuple */ ++ ++SWIGINTERN int ++SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs) ++{ ++ if (!args) { ++ if (!min && !max) { ++ return 1; ++ } else { ++ PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", ++ name, (min == max ? "" : "at least "), min); ++ return 0; ++ } ++ } ++ if (!PyTuple_Check(args)) { ++ PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple"); ++ return 0; ++ } else { ++ register int l = PyTuple_GET_SIZE(args); ++ if (l < min) { ++ PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", ++ name, (min == max ? "" : "at least "), min, l); ++ return 0; ++ } else if (l > max) { ++ PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", ++ name, (min == max ? "" : "at most "), max, l); ++ return 0; ++ } else { ++ register int i; ++ for (i = 0; i < l; ++i) { ++ objs[i] = PyTuple_GET_ITEM(args, i); ++ } ++ for (; l < max; ++l) { ++ objs[l] = 0; ++ } ++ return i + 1; ++ } ++ } ++} ++ ++/* A functor is a function object with one single object argument */ ++#if PY_VERSION_HEX >= 0x02020000 ++#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL); ++#else ++#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj); ++#endif ++ ++/* ++ Helper for static pointer initialization for both C and C++ code, for example ++ static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...); ++*/ ++#ifdef __cplusplus ++#define SWIG_STATIC_POINTER(var) var ++#else ++#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var ++#endif ++ ++/* ----------------------------------------------------------------------------- ++ * Pointer declarations ++ * ----------------------------------------------------------------------------- */ ++ ++/* Flags for new pointer objects */ ++#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1) ++#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN) ++ ++#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1) ++ ++#ifdef __cplusplus ++extern "C" { ++#if 0 ++} /* cc-mode */ ++#endif ++#endif ++ ++/* How to access Py_None */ ++#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) ++# ifndef SWIG_PYTHON_NO_BUILD_NONE ++# ifndef SWIG_PYTHON_BUILD_NONE ++# define SWIG_PYTHON_BUILD_NONE ++# endif ++# endif ++#endif ++ ++#ifdef SWIG_PYTHON_BUILD_NONE ++# ifdef Py_None ++# undef Py_None ++# define Py_None SWIG_Py_None() ++# endif ++SWIGRUNTIMEINLINE PyObject * ++_SWIG_Py_None(void) ++{ ++ PyObject *none = Py_BuildValue(""); ++ Py_DECREF(none); ++ return none; ++} ++SWIGRUNTIME PyObject * ++SWIG_Py_None(void) ++{ ++ static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None(); ++ return none; ++} ++#endif ++ ++/* The python void return value */ ++ ++SWIGRUNTIMEINLINE PyObject * ++SWIG_Py_Void(void) ++{ ++ PyObject *none = Py_None; ++ Py_INCREF(none); ++ return none; ++} ++ ++/* PySwigClientData */ ++ ++typedef struct { ++ PyObject *klass; ++ PyObject *newraw; ++ PyObject *newargs; ++ PyObject *destroy; ++ int delargs; ++ int implicitconv; ++} PySwigClientData; ++ ++SWIGRUNTIMEINLINE int ++SWIG_Python_CheckImplicit(swig_type_info *ty) ++{ ++ PySwigClientData *data = (PySwigClientData *)ty->clientdata; ++ return data ? data->implicitconv : 0; ++} ++ ++SWIGRUNTIMEINLINE PyObject * ++SWIG_Python_ExceptionType(swig_type_info *desc) { ++ PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0; ++ PyObject *klass = data ? data->klass : 0; ++ return (klass ? klass : PyExc_RuntimeError); ++} ++ ++ ++SWIGRUNTIME PySwigClientData * ++PySwigClientData_New(PyObject* obj) ++{ ++ if (!obj) { ++ return 0; ++ } else { ++ PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData)); ++ /* the klass element */ ++ data->klass = obj; ++ Py_INCREF(data->klass); ++ /* the newraw method and newargs arguments used to create a new raw instance */ ++ if (PyClass_Check(obj)) { ++ data->newraw = 0; ++ data->newargs = obj; ++ Py_INCREF(obj); ++ } else { ++#if (PY_VERSION_HEX < 0x02020000) ++ data->newraw = 0; ++#else ++ data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__"); ++#endif ++ if (data->newraw) { ++ Py_INCREF(data->newraw); ++ data->newargs = PyTuple_New(1); ++ PyTuple_SetItem(data->newargs, 0, obj); ++ } else { ++ data->newargs = obj; ++ } ++ Py_INCREF(data->newargs); ++ } ++ /* the destroy method, aka as the C++ delete method */ ++ data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__"); ++ if (PyErr_Occurred()) { ++ PyErr_Clear(); ++ data->destroy = 0; ++ } ++ if (data->destroy) { ++ int flags; ++ Py_INCREF(data->destroy); ++ flags = PyCFunction_GET_FLAGS(data->destroy); ++#ifdef METH_O ++ data->delargs = !(flags & (METH_O)); ++#else ++ data->delargs = 0; ++#endif ++ } else { ++ data->delargs = 0; ++ } ++ data->implicitconv = 0; ++ return data; ++ } ++} ++ ++SWIGRUNTIME void ++PySwigClientData_Del(PySwigClientData* data) ++{ ++ Py_XDECREF(data->newraw); ++ Py_XDECREF(data->newargs); ++ Py_XDECREF(data->destroy); ++} ++ ++/* =============== PySwigObject =====================*/ ++ ++typedef struct { ++ PyObject_HEAD ++ void *ptr; ++ swig_type_info *ty; ++ int own; ++ PyObject *next; ++} PySwigObject; ++ ++SWIGRUNTIME PyObject * ++PySwigObject_long(PySwigObject *v) ++{ ++ return PyLong_FromVoidPtr(v->ptr); ++} ++ ++SWIGRUNTIME PyObject * ++PySwigObject_format(const char* fmt, PySwigObject *v) ++{ ++ PyObject *res = NULL; ++ PyObject *args = PyTuple_New(1); ++ if (args) { ++ if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) { ++ PyObject *ofmt = PyString_FromString(fmt); ++ if (ofmt) { ++ res = PyString_Format(ofmt,args); ++ Py_DECREF(ofmt); ++ } ++ Py_DECREF(args); ++ } ++ } ++ return res; ++} ++ ++SWIGRUNTIME PyObject * ++PySwigObject_oct(PySwigObject *v) ++{ ++ return PySwigObject_format("%o",v); ++} ++ ++SWIGRUNTIME PyObject * ++PySwigObject_hex(PySwigObject *v) ++{ ++ return PySwigObject_format("%x",v); ++} ++ ++SWIGRUNTIME PyObject * ++#ifdef METH_NOARGS ++PySwigObject_repr(PySwigObject *v) ++#else ++PySwigObject_repr(PySwigObject *v, PyObject *args) ++#endif ++{ ++ const char *name = SWIG_TypePrettyName(v->ty); ++ PyObject *hex = PySwigObject_hex(v); ++ PyObject *repr = PyString_FromFormat("", name, PyString_AsString(hex)); ++ Py_DECREF(hex); ++ if (v->next) { ++#ifdef METH_NOARGS ++ PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next); ++#else ++ PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args); ++#endif ++ PyString_ConcatAndDel(&repr,nrep); ++ } ++ return repr; ++} ++ ++SWIGRUNTIME int ++PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) ++{ ++#ifdef METH_NOARGS ++ PyObject *repr = PySwigObject_repr(v); ++#else ++ PyObject *repr = PySwigObject_repr(v, NULL); ++#endif ++ if (repr) { ++ fputs(PyString_AsString(repr), fp); ++ Py_DECREF(repr); ++ return 0; ++ } else { ++ return 1; + } + } + ++SWIGRUNTIME PyObject * ++PySwigObject_str(PySwigObject *v) ++{ ++ char result[SWIG_BUFFER_SIZE]; ++ return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ? ++ PyString_FromString(result) : 0; ++} ++ ++SWIGRUNTIME int ++PySwigObject_compare(PySwigObject *v, PySwigObject *w) ++{ ++ void *i = v->ptr; ++ void *j = w->ptr; ++ return (i < j) ? -1 : ((i > j) ? 1 : 0); ++} ++ ++SWIGRUNTIME PyTypeObject* _PySwigObject_type(void); ++ ++SWIGRUNTIME PyTypeObject* ++PySwigObject_type(void) { ++ static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type(); ++ return type; ++} ++ ++SWIGRUNTIMEINLINE int ++PySwigObject_Check(PyObject *op) { ++ return ((op)->ob_type == PySwigObject_type()) ++ || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0); ++} ++ ++SWIGRUNTIME PyObject * ++PySwigObject_New(void *ptr, swig_type_info *ty, int own); ++ + SWIGRUNTIME void +-PySwigObject_dealloc(PySwigObject *self) ++PySwigObject_dealloc(PyObject *v) ++{ ++ PySwigObject *sobj = (PySwigObject *) v; ++ PyObject *next = sobj->next; ++ if (sobj->own) { ++ swig_type_info *ty = sobj->ty; ++ PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0; ++ PyObject *destroy = data ? data->destroy : 0; ++ if (destroy) { ++ /* destroy is always a VARARGS method */ ++ PyObject *res; ++ if (data->delargs) { ++ /* we need to create a temporal object to carry the destroy operation */ ++ PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0); ++ res = SWIG_Python_CallFunctor(destroy, tmp); ++ Py_DECREF(tmp); ++ } else { ++ PyCFunction meth = PyCFunction_GET_FUNCTION(destroy); ++ PyObject *mself = PyCFunction_GET_SELF(destroy); ++ res = ((*meth)(mself, v)); ++ } ++ Py_XDECREF(res); ++ } else { ++ const char *name = SWIG_TypePrettyName(ty); ++#if !defined(SWIG_PYTHON_SILENT_MEMLEAK) ++ printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name); ++#endif ++ } ++ } ++ Py_XDECREF(next); ++ PyObject_DEL(v); ++} ++ ++SWIGRUNTIME PyObject* ++PySwigObject_append(PyObject* v, PyObject* next) ++{ ++ PySwigObject *sobj = (PySwigObject *) v; ++#ifndef METH_O ++ PyObject *tmp = 0; ++ if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL; ++ next = tmp; ++#endif ++ if (!PySwigObject_Check(next)) { ++ return NULL; ++ } ++ sobj->next = next; ++ Py_INCREF(next); ++ return SWIG_Py_Void(); ++} ++ ++SWIGRUNTIME PyObject* ++#ifdef METH_NOARGS ++PySwigObject_next(PyObject* v) ++#else ++PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) ++#endif ++{ ++ PySwigObject *sobj = (PySwigObject *) v; ++ if (sobj->next) { ++ Py_INCREF(sobj->next); ++ return sobj->next; ++ } else { ++ return SWIG_Py_Void(); ++ } ++} ++ ++SWIGINTERN PyObject* ++#ifdef METH_NOARGS ++PySwigObject_disown(PyObject *v) ++#else ++PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) ++#endif ++{ ++ PySwigObject *sobj = (PySwigObject *)v; ++ sobj->own = 0; ++ return SWIG_Py_Void(); ++} ++ ++SWIGINTERN PyObject* ++#ifdef METH_NOARGS ++PySwigObject_acquire(PyObject *v) ++#else ++PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) ++#endif ++{ ++ PySwigObject *sobj = (PySwigObject *)v; ++ sobj->own = SWIG_POINTER_OWN; ++ return SWIG_Py_Void(); ++} ++ ++SWIGINTERN PyObject* ++PySwigObject_own(PyObject *v, PyObject *args) ++{ ++ PyObject *val = 0; ++#if (PY_VERSION_HEX < 0x02020000) ++ if (!PyArg_ParseTuple(args,(char *)"|O:own",&val)) ++#else ++ if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) ++#endif ++ { ++ return NULL; ++ } ++ else ++ { ++ PySwigObject *sobj = (PySwigObject *)v; ++ PyObject *obj = PyBool_FromLong(sobj->own); ++ if (val) { ++#ifdef METH_NOARGS ++ if (PyObject_IsTrue(val)) { ++ PySwigObject_acquire(v); ++ } else { ++ PySwigObject_disown(v); ++ } ++#else ++ if (PyObject_IsTrue(val)) { ++ PySwigObject_acquire(v,args); ++ } else { ++ PySwigObject_disown(v,args); ++ } ++#endif ++ } ++ return obj; ++ } ++} ++ ++#ifdef METH_O ++static PyMethodDef ++swigobject_methods[] = { ++ {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"}, ++ {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"}, ++ {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, ++ {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"}, ++ {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"}, ++ {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"}, ++ {0, 0, 0, 0} ++}; ++#else ++static PyMethodDef ++swigobject_methods[] = { ++ {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"}, ++ {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"}, ++ {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, ++ {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"}, ++ {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"}, ++ {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"}, ++ {0, 0, 0, 0} ++}; ++#endif ++ ++#if PY_VERSION_HEX < 0x02020000 ++SWIGINTERN PyObject * ++PySwigObject_getattr(PySwigObject *sobj,char *name) + { +- PyObject_DEL(self); ++ return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name); + } ++#endif + + SWIGRUNTIME PyTypeObject* +-PySwigObject_GetType() { +- static char PySwigObject_Type__doc__[] = +- "Swig object carries a C/C++ instance pointer"; ++_PySwigObject_type(void) { ++ static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; + + static PyNumberMethods PySwigObject_as_number = { + (binaryfunc)0, /*nb_add*/ +@@ -728,89 +1585,95 @@ + (unaryfunc)0, /*nb_float*/ + (unaryfunc)PySwigObject_oct, /*nb_oct*/ + (unaryfunc)PySwigObject_hex, /*nb_hex*/ +-#if PY_VERSION_HEX >= 0x02000000 ++#if PY_VERSION_HEX >= 0x02020000 + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ ++#elif PY_VERSION_HEX >= 0x02000000 ++ 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */ + #endif + }; + +- static int type_init = 0; +- static PyTypeObject PySwigObject_Type; +- ++ static PyTypeObject pyswigobject_type; ++ static int type_init = 0; + if (!type_init) { +- PyTypeObject tmp = { +- PyObject_HEAD_INIT(&PyType_Type) +- 0, /*ob_size*/ +- "PySwigObject", /*tp_name*/ +- sizeof(PySwigObject), /*tp_basicsize*/ +- 0, /*tp_itemsize*/ +- /* methods */ +- (destructor)PySwigObject_dealloc, /*tp_dealloc*/ +- (printfunc)PySwigObject_print, /*tp_print*/ +- (getattrfunc)0, /*tp_getattr*/ +- (setattrfunc)0, /*tp_setattr*/ +- (cmpfunc)PySwigObject_compare, /*tp_compare*/ +- (reprfunc)PySwigObject_repr, /*tp_repr*/ +- &PySwigObject_as_number, /*tp_as_number*/ +- 0, /*tp_as_sequence*/ +- 0, /*tp_as_mapping*/ +- (hashfunc)0, /*tp_hash*/ +- (ternaryfunc)0, /*tp_call*/ +- (reprfunc)PySwigObject_str, /*tp_str*/ +- /* Space for future expansion */ +- 0L,0L,0L,0L, +- PySwigObject_Type__doc__, /* Documentation string */ +-#if PY_VERSION_HEX >= 0x02000000 +- 0, /* tp_traverse */ +- 0, /* tp_clear */ +-#endif +-#if PY_VERSION_HEX >= 0x02010000 +- 0, /* tp_richcompare */ +- 0, /* tp_weaklistoffset */ ++ const PyTypeObject tmp ++ = { ++ PyObject_HEAD_INIT(NULL) ++ 0, /* ob_size */ ++ (char *)"PySwigObject", /* tp_name */ ++ sizeof(PySwigObject), /* tp_basicsize */ ++ 0, /* tp_itemsize */ ++ (destructor)PySwigObject_dealloc, /* tp_dealloc */ ++ (printfunc)PySwigObject_print, /* tp_print */ ++#if PY_VERSION_HEX < 0x02020000 ++ (getattrfunc)PySwigObject_getattr, /* tp_getattr */ ++#else ++ (getattrfunc)0, /* tp_getattr */ + #endif ++ (setattrfunc)0, /* tp_setattr */ ++ (cmpfunc)PySwigObject_compare, /* tp_compare */ ++ (reprfunc)PySwigObject_repr, /* tp_repr */ ++ &PySwigObject_as_number, /* tp_as_number */ ++ 0, /* tp_as_sequence */ ++ 0, /* tp_as_mapping */ ++ (hashfunc)0, /* tp_hash */ ++ (ternaryfunc)0, /* tp_call */ ++ (reprfunc)PySwigObject_str, /* tp_str */ ++ PyObject_GenericGetAttr, /* tp_getattro */ ++ 0, /* tp_setattro */ ++ 0, /* tp_as_buffer */ ++ Py_TPFLAGS_DEFAULT, /* tp_flags */ ++ swigobject_doc, /* tp_doc */ ++ 0, /* tp_traverse */ ++ 0, /* tp_clear */ ++ 0, /* tp_richcompare */ ++ 0, /* tp_weaklistoffset */ + #if PY_VERSION_HEX >= 0x02020000 +- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ ++ 0, /* tp_iter */ ++ 0, /* tp_iternext */ ++ swigobject_methods, /* tp_methods */ ++ 0, /* tp_members */ ++ 0, /* tp_getset */ ++ 0, /* tp_base */ ++ 0, /* tp_dict */ ++ 0, /* tp_descr_get */ ++ 0, /* tp_descr_set */ ++ 0, /* tp_dictoffset */ ++ 0, /* tp_init */ ++ 0, /* tp_alloc */ ++ 0, /* tp_new */ ++ 0, /* tp_free */ ++ 0, /* tp_is_gc */ ++ 0, /* tp_bases */ ++ 0, /* tp_mro */ ++ 0, /* tp_cache */ ++ 0, /* tp_subclasses */ ++ 0, /* tp_weaklist */ + #endif + #if PY_VERSION_HEX >= 0x02030000 +- 0, /* tp_del */ ++ 0, /* tp_del */ + #endif + #ifdef COUNT_ALLOCS +- 0,0,0,0 /* tp_alloc -> tp_next */ ++ 0,0,0,0 /* tp_alloc -> tp_next */ + #endif +- }; +- +- PySwigObject_Type = tmp; ++ }; ++ pyswigobject_type = tmp; ++ pyswigobject_type.ob_type = &PyType_Type; + type_init = 1; + } +- +- return &PySwigObject_Type; ++ return &pyswigobject_type; + } + + SWIGRUNTIME PyObject * +-PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc) +-{ +- PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType()); +- if (self == NULL) return NULL; +- self->ptr = ptr; +- self->desc = desc; +- return (PyObject *)self; +-} +- +-SWIGRUNTIMEINLINE void * +-PySwigObject_AsVoidPtr(PyObject *self) +-{ +- return ((PySwigObject *)self)->ptr; +-} +- +-SWIGRUNTIMEINLINE const char * +-PySwigObject_GetDesc(PyObject *self) ++PySwigObject_New(void *ptr, swig_type_info *ty, int own) + { +- return ((PySwigObject *)self)->desc; +-} +- +-SWIGRUNTIMEINLINE int +-PySwigObject_Check(PyObject *op) { +- return ((op)->ob_type == PySwigObject_GetType()) +- || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0); ++ PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type()); ++ if (sobj) { ++ sobj->ptr = ptr; ++ sobj->ty = ty; ++ sobj->own = own; ++ sobj->next = 0; ++ } ++ return (PyObject *)sobj; + } + + /* ----------------------------------------------------------------------------- +@@ -820,12 +1683,12 @@ + typedef struct { + PyObject_HEAD + void *pack; +- const char *desc; ++ swig_type_info *ty; + size_t size; + } PySwigPacked; + + SWIGRUNTIME int +-PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags) ++PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags)) + { + char result[SWIG_BUFFER_SIZE]; + fputs("desc,fp); ++ fputs(v->ty->name,fp); + fputs(">", fp); + return 0; + } +@@ -843,9 +1706,9 @@ + { + char result[SWIG_BUFFER_SIZE]; + if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { +- return PyString_FromFormat("", result, v->desc); ++ return PyString_FromFormat("", result, v->ty->name); + } else { +- return PyString_FromFormat("", v->desc); ++ return PyString_FromFormat("", v->ty->name); + } + } + +@@ -854,426 +1717,489 @@ + { + char result[SWIG_BUFFER_SIZE]; + if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){ +- return PyString_FromFormat("%s%s", result, v->desc); ++ return PyString_FromFormat("%s%s", result, v->ty->name); + } else { +- return PyString_FromFormat("%s", v->desc); ++ return PyString_FromString(v->ty->name); + } + } + + SWIGRUNTIME int + PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w) + { +- int c = strcmp(v->desc, w->desc); +- if (c) { +- return c; +- } else { +- size_t i = v->size; +- size_t j = w->size; +- int s = (i < j) ? -1 : (i > j) ? 1 : 0; +- return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size); +- } ++ size_t i = v->size; ++ size_t j = w->size; ++ int s = (i < j) ? -1 : ((i > j) ? 1 : 0); ++ return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size); + } + +-SWIGRUNTIME void +-PySwigPacked_dealloc(PySwigPacked *self) +-{ +- free(self->pack); +- PyObject_DEL(self); +-} ++SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void); + + SWIGRUNTIME PyTypeObject* +-PySwigPacked_GetType() { +- static char PySwigPacked_Type__doc__[] = +- "Swig object carries a C/C++ instance pointer"; +- static int type_init = 0; +- +- static PyTypeObject PySwigPacked_Type; +- if (!type_init) { +- PyTypeObject tmp = { +- PyObject_HEAD_INIT(&PyType_Type) +- 0, /*ob_size*/ +- "PySwigPacked", /*tp_name*/ +- sizeof(PySwigPacked), /*tp_basicsize*/ +- 0, /*tp_itemsize*/ +- /* methods */ +- (destructor)PySwigPacked_dealloc, /*tp_dealloc*/ +- (printfunc)PySwigPacked_print, /*tp_print*/ +- (getattrfunc)0, /*tp_getattr*/ +- (setattrfunc)0, /*tp_setattr*/ +- (cmpfunc)PySwigPacked_compare, /*tp_compare*/ +- (reprfunc)PySwigPacked_repr, /*tp_repr*/ +- 0, /*tp_as_number*/ +- 0, /*tp_as_sequence*/ +- 0, /*tp_as_mapping*/ +- (hashfunc)0, /*tp_hash*/ +- (ternaryfunc)0, /*tp_call*/ +- (reprfunc)PySwigPacked_str, /*tp_str*/ +- /* Space for future expansion */ +- 0L,0L,0L,0L, +- PySwigPacked_Type__doc__, /* Documentation string */ +-#if PY_VERSION_HEX >= 0x02000000 +- 0, /* tp_traverse */ +- 0, /* tp_clear */ +-#endif +-#if PY_VERSION_HEX >= 0x02010000 +- 0, /* tp_richcompare */ +- 0, /* tp_weaklistoffset */ +-#endif +-#if PY_VERSION_HEX >= 0x02020000 +- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ +-#endif +-#if PY_VERSION_HEX >= 0x02030000 +- 0, /* tp_del */ ++PySwigPacked_type(void) { ++ static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type(); ++ return type; ++} ++ ++SWIGRUNTIMEINLINE int ++PySwigPacked_Check(PyObject *op) { ++ return ((op)->ob_type == _PySwigPacked_type()) ++ || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0); ++} ++ ++SWIGRUNTIME void ++PySwigPacked_dealloc(PyObject *v) ++{ ++ if (PySwigPacked_Check(v)) { ++ PySwigPacked *sobj = (PySwigPacked *) v; ++ free(sobj->pack); ++ } ++ PyObject_DEL(v); ++} ++ ++SWIGRUNTIME PyTypeObject* ++_PySwigPacked_type(void) { ++ static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; ++ static PyTypeObject pyswigpacked_type; ++ static int type_init = 0; ++ if (!type_init) { ++ const PyTypeObject tmp ++ = { ++ PyObject_HEAD_INIT(NULL) ++ 0, /* ob_size */ ++ (char *)"PySwigPacked", /* tp_name */ ++ sizeof(PySwigPacked), /* tp_basicsize */ ++ 0, /* tp_itemsize */ ++ (destructor)PySwigPacked_dealloc, /* tp_dealloc */ ++ (printfunc)PySwigPacked_print, /* tp_print */ ++ (getattrfunc)0, /* tp_getattr */ ++ (setattrfunc)0, /* tp_setattr */ ++ (cmpfunc)PySwigPacked_compare, /* tp_compare */ ++ (reprfunc)PySwigPacked_repr, /* tp_repr */ ++ 0, /* tp_as_number */ ++ 0, /* tp_as_sequence */ ++ 0, /* tp_as_mapping */ ++ (hashfunc)0, /* tp_hash */ ++ (ternaryfunc)0, /* tp_call */ ++ (reprfunc)PySwigPacked_str, /* tp_str */ ++ PyObject_GenericGetAttr, /* tp_getattro */ ++ 0, /* tp_setattro */ ++ 0, /* tp_as_buffer */ ++ Py_TPFLAGS_DEFAULT, /* tp_flags */ ++ swigpacked_doc, /* tp_doc */ ++ 0, /* tp_traverse */ ++ 0, /* tp_clear */ ++ 0, /* tp_richcompare */ ++ 0, /* tp_weaklistoffset */ ++#if PY_VERSION_HEX >= 0x02020000 ++ 0, /* tp_iter */ ++ 0, /* tp_iternext */ ++ 0, /* tp_methods */ ++ 0, /* tp_members */ ++ 0, /* tp_getset */ ++ 0, /* tp_base */ ++ 0, /* tp_dict */ ++ 0, /* tp_descr_get */ ++ 0, /* tp_descr_set */ ++ 0, /* tp_dictoffset */ ++ 0, /* tp_init */ ++ 0, /* tp_alloc */ ++ 0, /* tp_new */ ++ 0, /* tp_free */ ++ 0, /* tp_is_gc */ ++ 0, /* tp_bases */ ++ 0, /* tp_mro */ ++ 0, /* tp_cache */ ++ 0, /* tp_subclasses */ ++ 0, /* tp_weaklist */ ++#endif ++#if PY_VERSION_HEX >= 0x02030000 ++ 0, /* tp_del */ + #endif + #ifdef COUNT_ALLOCS +- 0,0,0,0 /* tp_alloc -> tp_next */ ++ 0,0,0,0 /* tp_alloc -> tp_next */ + #endif +- }; +- +- PySwigPacked_Type = tmp; ++ }; ++ pyswigpacked_type = tmp; ++ pyswigpacked_type.ob_type = &PyType_Type; + type_init = 1; + } +- +- +- +- return &PySwigPacked_Type; ++ return &pyswigpacked_type; + } + + SWIGRUNTIME PyObject * +-PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc) ++PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty) + { +- PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType()); +- if (self == NULL) { +- return NULL; +- } else { ++ PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type()); ++ if (sobj) { + void *pack = malloc(size); +- memcpy(pack, ptr, size); +- self->pack = pack; +- self->desc = desc; +- self->size = size; +- return (PyObject *) self; ++ if (pack) { ++ memcpy(pack, ptr, size); ++ sobj->pack = pack; ++ sobj->ty = ty; ++ sobj->size = size; ++ } else { ++ PyObject_DEL((PyObject *) sobj); ++ sobj = 0; ++ } + } ++ return (PyObject *) sobj; + } + +-SWIGRUNTIMEINLINE const char * ++SWIGRUNTIME swig_type_info * + PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size) + { +- PySwigPacked *self = (PySwigPacked *)obj; +- if (self->size != size) return 0; +- memcpy(ptr, self->pack, size); +- return self->desc; +-} +- +-SWIGRUNTIMEINLINE const char * +-PySwigPacked_GetDesc(PyObject *self) +-{ +- return ((PySwigPacked *)self)->desc; +-} +- +-SWIGRUNTIMEINLINE int +-PySwigPacked_Check(PyObject *op) { +- return ((op)->ob_type == PySwigPacked_GetType()) +- || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0); ++ if (PySwigPacked_Check(obj)) { ++ PySwigPacked *sobj = (PySwigPacked *)obj; ++ if (sobj->size != size) return 0; ++ memcpy(ptr, sobj->pack, size); ++ return sobj->ty; ++ } else { ++ return 0; ++ } + } + +-#else +-/* ----------------------------------------------------------------------------- +- * Use the old Python PyCObject instead of PySwigObject +- * ----------------------------------------------------------------------------- */ +- +-#define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj) +-#define PySwigObject_Check(obj) PyCObject_Check(obj) +-#define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj) +-#define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL) +- +-#endif +- +-#endif +- + /* ----------------------------------------------------------------------------- +- * errors manipulation ++ * pointers/data manipulation + * ----------------------------------------------------------------------------- */ + +-SWIGRUNTIME void +-SWIG_Python_TypeError(const char *type, PyObject *obj) ++SWIGRUNTIMEINLINE PyObject * ++_SWIG_This(void) + { +- if (type) { +-#if defined(SWIG_COBJECT_TYPES) +- if (PySwigObject_Check(obj)) { +- const char *otype = (const char *) PySwigObject_GetDesc(obj); +- if (otype) { +- PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received", +- type, otype); +- return; +- } +- } else +-#endif +- { +- const char *otype = (obj ? obj->ob_type->tp_name : 0); +- if (otype) { +- PyObject *str = PyObject_Str(obj); +- const char *cstr = str ? PyString_AsString(str) : 0; +- if (cstr) { +- PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", +- type, otype, cstr); +- } else { +- PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", +- type, otype); +- } +- Py_DECREF(str); +- return; +- } +- } +- PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); +- } else { +- PyErr_Format(PyExc_TypeError, "unexpected type is received"); +- } ++ return PyString_FromString("this"); + } + +-SWIGRUNTIMEINLINE void +-SWIG_Python_NullRef(const char *type) ++SWIGRUNTIME PyObject * ++SWIG_This(void) + { +- if (type) { +- PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type); +- } else { +- PyErr_Format(PyExc_TypeError, "null reference was received"); +- } ++ static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This(); ++ return swig_this; + } + +-SWIGRUNTIME int +-SWIG_Python_AddErrMesg(const char* mesg, int infront) ++/* #define SWIG_PYTHON_SLOW_GETSET_THIS */ ++ ++SWIGRUNTIME PySwigObject * ++SWIG_Python_GetSwigThis(PyObject *pyobj) + { +- if (PyErr_Occurred()) { +- PyObject *type = 0; +- PyObject *value = 0; +- PyObject *traceback = 0; +- PyErr_Fetch(&type, &value, &traceback); +- if (value) { +- PyObject *old_str = PyObject_Str(value); +- Py_XINCREF(type); +- PyErr_Clear(); +- if (infront) { +- PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str)); ++ if (PySwigObject_Check(pyobj)) { ++ return (PySwigObject *) pyobj; ++ } else { ++ PyObject *obj = 0; ++#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000)) ++ if (PyInstance_Check(pyobj)) { ++ obj = _PyInstance_Lookup(pyobj, SWIG_This()); ++ } else { ++ PyObject **dictptr = _PyObject_GetDictPtr(pyobj); ++ if (dictptr != NULL) { ++ PyObject *dict = *dictptr; ++ obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0; + } else { +- PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg); ++#ifdef PyWeakref_CheckProxy ++ if (PyWeakref_CheckProxy(pyobj)) { ++ PyObject *wobj = PyWeakref_GET_OBJECT(pyobj); ++ return wobj ? SWIG_Python_GetSwigThis(wobj) : 0; ++ } ++#endif ++ obj = PyObject_GetAttr(pyobj,SWIG_This()); ++ if (obj) { ++ Py_DECREF(obj); ++ } else { ++ if (PyErr_Occurred()) PyErr_Clear(); ++ return 0; ++ } + } +- Py_DECREF(old_str); + } +- return 1; +- } else { +- return 0; ++#else ++ obj = PyObject_GetAttr(pyobj,SWIG_This()); ++ if (obj) { ++ Py_DECREF(obj); ++ } else { ++ if (PyErr_Occurred()) PyErr_Clear(); ++ return 0; ++ } ++#endif ++ if (obj && !PySwigObject_Check(obj)) { ++ /* a PyObject is called 'this', try to get the 'real this' ++ PySwigObject from it */ ++ return SWIG_Python_GetSwigThis(obj); ++ } ++ return (PySwigObject *)obj; + } + } + ++/* Acquire a pointer value */ ++ + SWIGRUNTIME int +-SWIG_Python_ArgFail(int argnum) +-{ +- if (PyErr_Occurred()) { +- /* add information about failing argument */ +- char mesg[256]; +- sprintf(mesg, "argument number %d:", argnum); +- return SWIG_Python_AddErrMesg(mesg, 1); +- } else { +- return 0; ++SWIG_Python_AcquirePtr(PyObject *obj, int own) { ++ if (own) { ++ PySwigObject *sobj = SWIG_Python_GetSwigThis(obj); ++ if (sobj) { ++ int oldown = sobj->own; ++ sobj->own = own; ++ return oldown; ++ } + } ++ return 0; + } + +- +-/* ----------------------------------------------------------------------------- +- * pointers/data manipulation +- * ----------------------------------------------------------------------------- */ +- + /* Convert a pointer value */ ++ + SWIGRUNTIME int +-SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) { +- swig_type_info *tc; +- const char *c = 0; +- static PyObject *SWIG_this = 0; +- int newref = 0; +- PyObject *pyobj = 0; +- void *vptr; +- +- if (!obj) return 0; ++SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) { ++ if (!obj) return SWIG_ERROR; + if (obj == Py_None) { +- *ptr = 0; +- return 0; +- } +- +-#ifdef SWIG_COBJECT_TYPES +- if (!(PySwigObject_Check(obj))) { +- if (!SWIG_this) +- SWIG_this = PyString_FromString("this"); +- pyobj = obj; +- obj = PyObject_GetAttr(obj,SWIG_this); +- newref = 1; +- if (!obj) goto type_error; +- if (!PySwigObject_Check(obj)) { +- Py_DECREF(obj); +- goto type_error; ++ if (ptr) *ptr = 0; ++ return SWIG_OK; ++ } else { ++ PySwigObject *sobj = SWIG_Python_GetSwigThis(obj); ++ while (sobj) { ++ void *vptr = sobj->ptr; ++ if (ty) { ++ swig_type_info *to = sobj->ty; ++ if (to == ty) { ++ /* no type cast needed */ ++ if (ptr) *ptr = vptr; ++ break; ++ } else { ++ swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); ++ if (!tc) { ++ sobj = (PySwigObject *)sobj->next; ++ } else { ++ if (ptr) *ptr = SWIG_TypeCast(tc,vptr); ++ break; ++ } ++ } ++ } else { ++ if (ptr) *ptr = vptr; ++ break; ++ } + } +- } +- vptr = PySwigObject_AsVoidPtr(obj); +- c = (const char *) PySwigObject_GetDesc(obj); +- if (newref) { Py_DECREF(obj); } +- goto type_check; +-#else +- if (!(PyString_Check(obj))) { +- if (!SWIG_this) +- SWIG_this = PyString_FromString("this"); +- pyobj = obj; +- obj = PyObject_GetAttr(obj,SWIG_this); +- newref = 1; +- if (!obj) goto type_error; +- if (!PyString_Check(obj)) { +- Py_DECREF(obj); +- goto type_error; ++ if (sobj) { ++ if (own) *own = sobj->own; ++ if (flags & SWIG_POINTER_DISOWN) { ++ sobj->own = 0; ++ } ++ return SWIG_OK; ++ } else { ++ int res = SWIG_ERROR; ++ if (flags & SWIG_POINTER_IMPLICIT_CONV) { ++ PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0; ++ if (data && !data->implicitconv) { ++ PyObject *klass = data->klass; ++ if (klass) { ++ PyObject *impconv; ++ data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/ ++ impconv = SWIG_Python_CallFunctor(klass, obj); ++ data->implicitconv = 0; ++ if (PyErr_Occurred()) { ++ PyErr_Clear(); ++ impconv = 0; ++ } ++ if (impconv) { ++ PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv); ++ if (iobj) { ++ void *vptr; ++ res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0); ++ if (SWIG_IsOK(res)) { ++ if (ptr) { ++ *ptr = vptr; ++ /* transfer the ownership to 'ptr' */ ++ iobj->own = 0; ++ res = SWIG_AddCast(res); ++ res = SWIG_AddNewMask(res); ++ } else { ++ res = SWIG_AddCast(res); ++ } ++ } ++ } ++ Py_DECREF(impconv); ++ } ++ } ++ } ++ } ++ return res; + } +- } +- c = PyString_AS_STRING(obj); +- /* Pointer values must start with leading underscore */ +- c = SWIG_UnpackVoidPtr(c, &vptr, ty->name); +- if (newref) { Py_DECREF(obj); } +- if (!c) goto type_error; +-#endif +- +-type_check: +- +- if (ty) { +- tc = SWIG_TypeCheck(c,ty); +- if (!tc) goto type_error; +- *ptr = SWIG_TypeCast(tc,vptr); +- } else { +- *ptr = vptr; + } ++} + +- if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) { +- PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False); +- } +- return 0; ++/* Convert a function ptr value */ + +-type_error: +- PyErr_Clear(); +- if (pyobj && !obj) { +- obj = pyobj; +- if (PyCFunction_Check(obj)) { +- /* here we get the method pointer for callbacks */ +- char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); +- c = doc ? strstr(doc, "swig_ptr: ") : 0; +- if (c) { +- c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name); +- if (!c) goto type_error; +- goto type_check; +- } ++SWIGRUNTIME int ++SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) { ++ if (!PyCFunction_Check(obj)) { ++ return SWIG_ConvertPtr(obj, ptr, ty, 0); ++ } else { ++ void *vptr = 0; ++ ++ /* here we get the method pointer for callbacks */ ++ char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); ++ const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0; ++ if (desc) { ++ desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; ++ if (!desc) return SWIG_ERROR; + } +- } +- if (flags & SWIG_POINTER_EXCEPTION) { + if (ty) { +- SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); ++ swig_cast_info *tc = SWIG_TypeCheck(desc,ty); ++ if (!tc) return SWIG_ERROR; ++ *ptr = SWIG_TypeCast(tc,vptr); + } else { +- SWIG_Python_TypeError("C/C++ pointer", obj); ++ *ptr = vptr; + } ++ return SWIG_OK; + } +- return -1; + } + +-/* Convert a pointer value, signal an exception on a type mismatch */ +-SWIGRUNTIME void * +-SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) { +- void *result; +- if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { +- PyErr_Clear(); +- if (flags & SWIG_POINTER_EXCEPTION) { +- SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); +- SWIG_Python_ArgFail(argnum); ++/* Convert a packed value value */ ++ ++SWIGRUNTIME int ++SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) { ++ swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz); ++ if (!to) return SWIG_ERROR; ++ if (ty) { ++ if (to != ty) { ++ /* check type cast? */ ++ swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); ++ if (!tc) return SWIG_ERROR; + } + } +- return result; +-} ++ return SWIG_OK; ++} + +-/* Convert a packed value value */ +-SWIGRUNTIME int +-SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) { +- swig_type_info *tc; +- const char *c = 0; ++/* ----------------------------------------------------------------------------- ++ * Create a new pointer object ++ * ----------------------------------------------------------------------------- */ ++ ++/* ++ Create a new instance object, whitout calling __init__, and set the ++ 'this' attribute. ++*/ + +-#if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON) +- c = PySwigPacked_UnpackData(obj, ptr, sz); ++SWIGRUNTIME PyObject* ++SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this) ++{ ++#if (PY_VERSION_HEX >= 0x02020000) ++ PyObject *inst = 0; ++ PyObject *newraw = data->newraw; ++ if (newraw) { ++ inst = PyObject_Call(newraw, data->newargs, NULL); ++ if (inst) { ++#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) ++ PyObject **dictptr = _PyObject_GetDictPtr(inst); ++ if (dictptr != NULL) { ++ PyObject *dict = *dictptr; ++ if (dict == NULL) { ++ dict = PyDict_New(); ++ *dictptr = dict; ++ PyDict_SetItem(dict, SWIG_This(), swig_this); ++ } ++ } + #else +- if ((!obj) || (!PyString_Check(obj))) goto type_error; +- c = PyString_AS_STRING(obj); +- /* Pointer values must start with leading underscore */ +- c = SWIG_UnpackDataName(c, ptr, sz, ty->name); ++ PyObject *key = SWIG_This(); ++ PyObject_SetAttr(inst, key, swig_this); + #endif +- if (!c) goto type_error; +- if (ty) { +- tc = SWIG_TypeCheck(c,ty); +- if (!tc) goto type_error; ++ } ++ } else { ++ PyObject *dict = PyDict_New(); ++ PyDict_SetItem(dict, SWIG_This(), swig_this); ++ inst = PyInstance_NewRaw(data->newargs, dict); ++ Py_DECREF(dict); + } +- return 0; ++ return inst; ++#else ++#if (PY_VERSION_HEX >= 0x02010000) ++ PyObject *inst; ++ PyObject *dict = PyDict_New(); ++ PyDict_SetItem(dict, SWIG_This(), swig_this); ++ inst = PyInstance_NewRaw(data->newargs, dict); ++ Py_DECREF(dict); ++ return (PyObject *) inst; ++#else ++ PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type); ++ if (inst == NULL) { ++ return NULL; ++ } ++ inst->in_class = (PyClassObject *)data->newargs; ++ Py_INCREF(inst->in_class); ++ inst->in_dict = PyDict_New(); ++ if (inst->in_dict == NULL) { ++ Py_DECREF(inst); ++ return NULL; ++ } ++#ifdef Py_TPFLAGS_HAVE_WEAKREFS ++ inst->in_weakreflist = NULL; ++#endif ++#ifdef Py_TPFLAGS_GC ++ PyObject_GC_Init(inst); ++#endif ++ PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this); ++ return (PyObject *) inst; ++#endif ++#endif ++} + +-type_error: +- PyErr_Clear(); +- if (flags & SWIG_POINTER_EXCEPTION) { +- if (ty) { +- SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); ++SWIGRUNTIME void ++SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this) ++{ ++ PyObject *dict; ++#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS) ++ PyObject **dictptr = _PyObject_GetDictPtr(inst); ++ if (dictptr != NULL) { ++ dict = *dictptr; ++ if (dict == NULL) { ++ dict = PyDict_New(); ++ *dictptr = dict; ++ } ++ PyDict_SetItem(dict, SWIG_This(), swig_this); ++ return; ++ } ++#endif ++ dict = PyObject_GetAttrString(inst, "__dict__"); ++ PyDict_SetItem(dict, SWIG_This(), swig_this); ++ Py_DECREF(dict); ++} ++ ++ ++SWIGINTERN PyObject * ++SWIG_Python_InitShadowInstance(PyObject *args) { ++ PyObject *obj[2]; ++ if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) { ++ return NULL; ++ } else { ++ PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]); ++ if (sthis) { ++ PySwigObject_append((PyObject*) sthis, obj[1]); + } else { +- SWIG_Python_TypeError("C/C++ packed data", obj); ++ SWIG_Python_SetSwigThis(obj[0], obj[1]); + } ++ return SWIG_Py_Void(); + } +- return -1; +-} ++} ++ ++/* Create a new pointer object */ + +-/* Create a new array object */ + SWIGRUNTIME PyObject * +-SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) { +- PyObject *robj = 0; ++SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) { + if (!ptr) { +- Py_INCREF(Py_None); +- return Py_None; +- } +-#ifdef SWIG_COBJECT_TYPES +- robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name); +-#else +- { +- char result[SWIG_BUFFER_SIZE]; +- robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ? +- PyString_FromString(result) : 0; +- } +-#endif +- if (!robj || (robj == Py_None)) return robj; +- if (type->clientdata) { +- PyObject *inst; +- PyObject *args = Py_BuildValue((char*)"(O)", robj); +- Py_DECREF(robj); +- inst = PyObject_CallObject((PyObject *) type->clientdata, args); +- Py_DECREF(args); +- if (inst) { +- if (own) { +- PyObject_SetAttrString(inst,(char*)"thisown",Py_True); ++ return SWIG_Py_Void(); ++ } else { ++ int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0; ++ PyObject *robj = PySwigObject_New(ptr, type, own); ++ PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0; ++ if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) { ++ PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj); ++ if (inst) { ++ Py_DECREF(robj); ++ robj = inst; + } +- robj = inst; + } ++ return robj; + } +- return robj; + } + +-SWIGRUNTIME PyObject * ++/* Create a new packed object */ ++ ++SWIGRUNTIMEINLINE PyObject * + SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { +- PyObject *robj = 0; +- if (!ptr) { +- Py_INCREF(Py_None); +- return Py_None; +- } +-#if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON) +- robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name); +-#else +- { +- char result[SWIG_BUFFER_SIZE]; +- robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ? +- PyString_FromString(result) : 0; +- } +-#endif +- return robj; ++ return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void(); + } + + /* -----------------------------------------------------------------------------* +@@ -1284,8 +2210,8 @@ + void *SWIG_ReturnGlobalTypeList(void *); + #endif + +-SWIGRUNTIME swig_type_info ** +-SWIG_Python_GetTypeListHandle() { ++SWIGRUNTIME swig_module_info * ++SWIG_Python_GetModule(void) { + static void *type_pointer = (void *)0; + /* first check if module already created */ + if (!type_pointer) { +@@ -1298,89 +2224,290 @@ + PyErr_Clear(); + type_pointer = (void *)0; + } +- } + #endif +- return (swig_type_info **) type_pointer; ++ } ++ return (swig_module_info *) type_pointer; + } + +-/* +- Search for a swig_type_info structure +- */ +-SWIGRUNTIMEINLINE swig_type_info * +-SWIG_Python_GetTypeList() { +- swig_type_info **tlh = SWIG_Python_GetTypeListHandle(); +- return tlh ? *tlh : (swig_type_info*)0; ++#if PY_MAJOR_VERSION < 2 ++/* PyModule_AddObject function was introduced in Python 2.0. The following function ++ is copied out of Python/modsupport.c in python version 2.3.4 */ ++SWIGINTERN int ++PyModule_AddObject(PyObject *m, char *name, PyObject *o) ++{ ++ PyObject *dict; ++ if (!PyModule_Check(m)) { ++ PyErr_SetString(PyExc_TypeError, ++ "PyModule_AddObject() needs module as first arg"); ++ return SWIG_ERROR; ++ } ++ if (!o) { ++ PyErr_SetString(PyExc_TypeError, ++ "PyModule_AddObject() needs non-NULL value"); ++ return SWIG_ERROR; ++ } ++ ++ dict = PyModule_GetDict(m); ++ if (dict == NULL) { ++ /* Internal error -- modules must have a dict! */ ++ PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__", ++ PyModule_GetName(m)); ++ return SWIG_ERROR; ++ } ++ if (PyDict_SetItemString(dict, name, o)) ++ return SWIG_ERROR; ++ Py_DECREF(o); ++ return SWIG_OK; + } ++#endif + +-#define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList +- +-#ifdef __cplusplus ++SWIGRUNTIME void ++SWIG_Python_DestroyModule(void *vptr) ++{ ++ swig_module_info *swig_module = (swig_module_info *) vptr; ++ swig_type_info **types = swig_module->types; ++ size_t i; ++ for (i =0; i < swig_module->size; ++i) { ++ swig_type_info *ty = types[i]; ++ if (ty->owndata) { ++ PySwigClientData *data = (PySwigClientData *) ty->clientdata; ++ if (data) PySwigClientData_Del(data); ++ } ++ } ++ Py_DECREF(SWIG_This()); + } +-#endif ++ ++SWIGRUNTIME void ++SWIG_Python_SetModule(swig_module_info *swig_module) { ++ static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */ ++ ++ PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, ++ swig_empty_runtime_method_table); ++ PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule); ++ if (pointer && module) { ++ PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer); ++ } else { ++ Py_XDECREF(pointer); ++ } ++} ++ ++/* The python cached type query */ ++SWIGRUNTIME PyObject * ++SWIG_Python_TypeCache() { ++ static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New(); ++ return cache; ++} ++ ++SWIGRUNTIME swig_type_info * ++SWIG_Python_TypeQuery(const char *type) ++{ ++ PyObject *cache = SWIG_Python_TypeCache(); ++ PyObject *key = PyString_FromString(type); ++ PyObject *obj = PyDict_GetItem(cache, key); ++ swig_type_info *descriptor; ++ if (obj) { ++ descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj); ++ } else { ++ swig_module_info *swig_module = SWIG_Python_GetModule(); ++ descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); ++ if (descriptor) { ++ obj = PyCObject_FromVoidPtr(descriptor, NULL); ++ PyDict_SetItem(cache, key, obj); ++ Py_DECREF(obj); ++ } ++ } ++ Py_DECREF(key); ++ return descriptor; ++} ++ ++/* ++ For backward compatibility only ++*/ ++#define SWIG_POINTER_EXCEPTION 0 ++#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg) ++#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) ++ ++SWIGRUNTIME int ++SWIG_Python_AddErrMesg(const char* mesg, int infront) ++{ ++ if (PyErr_Occurred()) { ++ PyObject *type = 0; ++ PyObject *value = 0; ++ PyObject *traceback = 0; ++ PyErr_Fetch(&type, &value, &traceback); ++ if (value) { ++ PyObject *old_str = PyObject_Str(value); ++ Py_XINCREF(type); ++ PyErr_Clear(); ++ if (infront) { ++ PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str)); ++ } else { ++ PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg); ++ } ++ Py_DECREF(old_str); ++ } ++ return 1; ++ } else { ++ return 0; ++ } ++} ++ ++SWIGRUNTIME int ++SWIG_Python_ArgFail(int argnum) ++{ ++ if (PyErr_Occurred()) { ++ /* add information about failing argument */ ++ char mesg[256]; ++ PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum); ++ return SWIG_Python_AddErrMesg(mesg, 1); ++ } else { ++ return 0; ++ } ++} ++ ++SWIGRUNTIMEINLINE const char * ++PySwigObject_GetDesc(PyObject *self) ++{ ++ PySwigObject *v = (PySwigObject *)self; ++ swig_type_info *ty = v ? v->ty : 0; ++ return ty ? ty->str : (char*)""; ++} ++ ++SWIGRUNTIME void ++SWIG_Python_TypeError(const char *type, PyObject *obj) ++{ ++ if (type) { ++#if defined(SWIG_COBJECT_TYPES) ++ if (obj && PySwigObject_Check(obj)) { ++ const char *otype = (const char *) PySwigObject_GetDesc(obj); ++ if (otype) { ++ PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received", ++ type, otype); ++ return; ++ } ++ } else ++#endif ++ { ++ const char *otype = (obj ? obj->ob_type->tp_name : 0); ++ if (otype) { ++ PyObject *str = PyObject_Str(obj); ++ const char *cstr = str ? PyString_AsString(str) : 0; ++ if (cstr) { ++ PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", ++ type, otype, cstr); ++ } else { ++ PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", ++ type, otype); ++ } ++ Py_XDECREF(str); ++ return; ++ } ++ } ++ PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); ++ } else { ++ PyErr_Format(PyExc_TypeError, "unexpected type is received"); ++ } ++} ++ ++ ++/* Convert a pointer value, signal an exception on a type mismatch */ ++SWIGRUNTIME void * ++SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) { ++ void *result; ++ if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { ++ PyErr_Clear(); ++ if (flags & SWIG_POINTER_EXCEPTION) { ++ SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); ++ SWIG_Python_ArgFail(argnum); ++ } ++ } ++ return result; ++} ++ ++ ++#ifdef __cplusplus ++#if 0 ++{ /* cc-mode */ ++#endif ++} ++#endif ++ ++ ++ ++#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) ++ ++#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else ++ + + + /* -------- TYPES TABLE (BEGIN) -------- */ + +-#define SWIGTYPE_p_semanage_node swig_types[0] +-#define SWIGTYPE_p_p_semanage_node swig_types[1] +-#define SWIGTYPE_p_p_p_semanage_node swig_types[2] +-#define SWIGTYPE_p_f_p_q_const__struct_semanage_user_p_void__int swig_types[3] +-#define SWIGTYPE_p_f_p_q_const__struct_semanage_iface_p_void__int swig_types[4] +-#define SWIGTYPE_p_f_p_q_const__struct_semanage_bool_p_void__int swig_types[5] +-#define SWIGTYPE_p_p_p_char swig_types[6] +-#define SWIGTYPE_p_char swig_types[7] +-#define SWIGTYPE_p_p_char swig_types[8] +-#define SWIGTYPE_p_p_semanage_port_key swig_types[9] +-#define SWIGTYPE_p_semanage_port_key swig_types[10] +-#define SWIGTYPE_p_f_p_q_const__struct_semanage_port_p_void__int swig_types[11] +-#define SWIGTYPE_p_f_p_q_const__struct_semanage_seuser_p_void__int swig_types[12] +-#define SWIGTYPE_p_f_p_q_const__struct_semanage_node_p_void__int swig_types[13] +-#define SWIGTYPE_p_semanage_seuser swig_types[14] +-#define SWIGTYPE_p_p_semanage_seuser swig_types[15] +-#define SWIGTYPE_p_p_p_semanage_seuser swig_types[16] +-#define SWIGTYPE_p_semanage_node_key swig_types[17] +-#define SWIGTYPE_p_p_semanage_node_key swig_types[18] +-#define SWIGTYPE_p_p_p_semanage_bool swig_types[19] +-#define SWIGTYPE_p_p_semanage_bool swig_types[20] +-#define SWIGTYPE_p_semanage_bool swig_types[21] +-#define SWIGTYPE_p_p_p_semanage_user swig_types[22] +-#define SWIGTYPE_p_p_semanage_user swig_types[23] +-#define SWIGTYPE_p_semanage_user swig_types[24] +-#define SWIGTYPE_size_t swig_types[25] +-#define SWIGTYPE_p_size_t swig_types[26] +-#define SWIGTYPE_p_p_semanage_user_key swig_types[27] +-#define SWIGTYPE_p_semanage_user_key swig_types[28] +-#define SWIGTYPE_p_semanage_seuser_key swig_types[29] +-#define SWIGTYPE_p_p_semanage_seuser_key swig_types[30] +-#define SWIGTYPE_p_p_p_semanage_iface swig_types[31] +-#define SWIGTYPE_p_p_semanage_iface swig_types[32] +-#define SWIGTYPE_p_semanage_iface swig_types[33] +-#define SWIGTYPE_p_semanage_bool_key swig_types[34] +-#define SWIGTYPE_p_p_semanage_bool_key swig_types[35] +-#define SWIGTYPE_p_semanage_fcontext_key swig_types[36] +-#define SWIGTYPE_p_p_semanage_fcontext_key swig_types[37] +-#define SWIGTYPE_p_f_p_q_const__struct_semanage_fcontext_p_void__int swig_types[38] +-#define SWIGTYPE_p_unsigned_int swig_types[39] +-#define SWIGTYPE_p_semanage_context swig_types[40] +-#define SWIGTYPE_p_p_semanage_context swig_types[41] +-#define SWIGTYPE_p_semanage_fcontext swig_types[42] +-#define SWIGTYPE_p_p_semanage_fcontext swig_types[43] +-#define SWIGTYPE_p_p_p_semanage_fcontext swig_types[44] +-#define SWIGTYPE_p_semanage_module_info swig_types[45] +-#define SWIGTYPE_p_p_semanage_module_info swig_types[46] +-#define SWIGTYPE_p_p_semanage_iface_key swig_types[47] +-#define SWIGTYPE_p_semanage_iface_key swig_types[48] +-#define SWIGTYPE_p_f_p_void_p_struct_semanage_handle_p_q_const__char_v_______void swig_types[49] +-#define SWIGTYPE_ptrdiff_t swig_types[50] +-#define SWIGTYPE_p_semanage_port swig_types[51] +-#define SWIGTYPE_p_p_semanage_port swig_types[52] +-#define SWIGTYPE_p_p_p_semanage_port swig_types[53] +-#define SWIGTYPE_p_int swig_types[54] +-#define SWIGTYPE_p_semanage_handle swig_types[55] +-static swig_type_info *swig_types[57]; ++#define SWIGTYPE_p_char swig_types[0] ++#define SWIGTYPE_p_f_p_q_const__struct_semanage_bool_p_void__int swig_types[1] ++#define SWIGTYPE_p_f_p_q_const__struct_semanage_fcontext_p_void__int swig_types[2] ++#define SWIGTYPE_p_f_p_q_const__struct_semanage_iface_p_void__int swig_types[3] ++#define SWIGTYPE_p_f_p_q_const__struct_semanage_node_p_void__int swig_types[4] ++#define SWIGTYPE_p_f_p_q_const__struct_semanage_port_p_void__int swig_types[5] ++#define SWIGTYPE_p_f_p_q_const__struct_semanage_seuser_p_void__int swig_types[6] ++#define SWIGTYPE_p_f_p_q_const__struct_semanage_user_p_void__int swig_types[7] ++#define SWIGTYPE_p_f_p_void_p_struct_semanage_handle_p_q_const__char_v_______void swig_types[8] ++#define SWIGTYPE_p_int swig_types[9] ++#define SWIGTYPE_p_p_char swig_types[10] ++#define SWIGTYPE_p_p_p_char swig_types[11] ++#define SWIGTYPE_p_p_p_semanage_bool swig_types[12] ++#define SWIGTYPE_p_p_p_semanage_fcontext swig_types[13] ++#define SWIGTYPE_p_p_p_semanage_iface swig_types[14] ++#define SWIGTYPE_p_p_p_semanage_node swig_types[15] ++#define SWIGTYPE_p_p_p_semanage_port swig_types[16] ++#define SWIGTYPE_p_p_p_semanage_seuser swig_types[17] ++#define SWIGTYPE_p_p_p_semanage_user swig_types[18] ++#define SWIGTYPE_p_p_semanage_bool swig_types[19] ++#define SWIGTYPE_p_p_semanage_bool_key swig_types[20] ++#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 SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) ++#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) + + /* -------- TYPES TABLE (END) -------- */ + ++#if (PY_VERSION_HEX <= 0x02000000) ++# if !defined(SWIG_PYTHON_CLASSIC) ++# error "This python version requires to use swig with the '-classic' option" ++# endif ++#endif + + /*----------------------------------------------- + @(target):= _semanage.so +@@ -1389,6 +2516,13 @@ + + #define SWIG_name "_semanage" + ++#define SWIGVERSION 0x010329 ++ ++ ++#define SWIG_as_voidptr(a) (void *)((const void *)(a)) ++#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a)) ++ ++ + #include + #include + +@@ -1396,532 +2530,324 @@ + #define STATUS_ERR -1 + + +- /*@/usr/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/ +-#define SWIG_From_int PyInt_FromLong +-/*@@*/ ++ #define SWIG_From_long PyInt_FromLong + +-int semanage_msg_get_level(semanage_handle_t *); +-char const *semanage_msg_get_channel(semanage_handle_t *); + +-SWIGINTERN PyObject * +-SWIG_FromCharPtr(const char* cptr) +-{ +- if (cptr) { +- size_t size = strlen(cptr); ++SWIGINTERNINLINE PyObject * ++SWIG_From_int (int value) ++{ ++ return SWIG_From_long (value); ++} ++ ++ ++SWIGINTERN swig_type_info* ++SWIG_pchar_descriptor() ++{ ++ static int init = 0; ++ static swig_type_info* info = 0; ++ if (!init) { ++ info = SWIG_TypeQuery("_p_char"); ++ init = 1; ++ } ++ return info; ++} ++ ++ ++SWIGINTERNINLINE PyObject * ++SWIG_FromCharPtrAndSize(const char* carray, size_t size) ++{ ++ if (carray) { + if (size > INT_MAX) { +- return SWIG_NewPointerObj((char*)(cptr), +- SWIG_TypeQuery("char *"), 0); ++ swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); ++ return pchar_descriptor ? ++ SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void(); + } else { +- if (size != 0) { +- return PyString_FromStringAndSize(cptr, size); +- } else { +- return PyString_FromString(cptr); +- } ++ return PyString_FromStringAndSize(carray, (int)(size)); + } ++ } else { ++ return SWIG_Py_Void(); + } +- Py_INCREF(Py_None); +- return Py_None; + } + +-char const *semanage_msg_get_fname(semanage_handle_t *); +-void semanage_msg_set_callback(semanage_handle_t *,void (*)(void *,semanage_handle_t *,char const *,...),void *); + +-/* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */ ++SWIGINTERNINLINE PyObject * ++SWIG_FromCharPtr(const char *cptr) ++{ ++ return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0)); ++} ++ ++ + SWIGINTERN int +-SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize) ++SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) + { +- static swig_type_info* pchar_info = 0; +- char* vptr = 0; +- if (!pchar_info) pchar_info = SWIG_TypeQuery("char *"); +- if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) { +- if (cptr) *cptr = vptr; +- if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0; +- return SWIG_OLDOBJ; +- } else { +- PyErr_Clear(); +- if (PyString_Check(obj)) { +- if (cptr) { +- *cptr = PyString_AS_STRING(obj); +- if (psize) { +- *psize = PyString_GET_SIZE(obj) + 1; ++ if (PyString_Check(obj)) { ++ char *cstr; int len; ++ PyString_AsStringAndSize(obj, &cstr, &len); ++ if (cptr) { ++ if (alloc) { ++ /* ++ In python the user should not be able to modify the inner ++ string representation. To warranty that, if you define ++ SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string ++ buffer is always returned. ++ ++ The default behavior is just to return the pointer value, ++ so, be careful. ++ */ ++#if defined(SWIG_PYTHON_SAFE_CSTRINGS) ++ if (*alloc != SWIG_OLDOBJ) ++#else ++ if (*alloc == SWIG_NEWOBJ) ++#endif ++ { ++ *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1)); ++ *alloc = SWIG_NEWOBJ; ++ } ++ else { ++ *cptr = cstr; ++ *alloc = SWIG_OLDOBJ; + } ++ } else { ++ *cptr = PyString_AsString(obj); ++ } ++ } ++ if (psize) *psize = len + 1; ++ return SWIG_OK; ++ } else { ++ swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); ++ if (pchar_descriptor) { ++ void* vptr = 0; ++ if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) { ++ if (cptr) *cptr = (char *) vptr; ++ if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0; ++ if (alloc) *alloc = SWIG_OLDOBJ; ++ return SWIG_OK; + } +- return SWIG_PYSTR; + } + } +- if (cptr) { +- SWIG_type_error("char *", obj); +- } +- return 0; ++ return SWIG_TypeError; + } + + +-SWIGINTERNSHORT int +-SWIG_AsCharPtr(PyObject *obj, char **val) +-{ +- if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) { +- return 1; +- } +- if (val) { +- PyErr_Clear(); +- SWIG_type_error("char *", obj); +- } +- return 0; +-} ++ + + + #include ++#ifndef LLONG_MIN ++# define LLONG_MIN LONG_LONG_MIN ++#endif ++#ifndef LLONG_MAX ++# define LLONG_MAX LONG_LONG_MAX ++#endif ++#ifndef ULLONG_MAX ++# define ULLONG_MAX ULONG_LONG_MAX ++#endif + + + SWIGINTERN int +- SWIG_CheckLongInRange(long value, long min_value, long max_value, +- const char *errmsg) ++SWIG_AsVal_double (PyObject *obj, double *val) + { +- if (value < min_value) { +- if (errmsg) { +- PyErr_Format(PyExc_OverflowError, +- "value %ld is less than '%s' minimum %ld", +- value, errmsg, min_value); +- } +- return 0; +- } else if (value > max_value) { +- if (errmsg) { +- PyErr_Format(PyExc_OverflowError, +- "value %ld is greater than '%s' maximum %ld", +- value, errmsg, max_value); ++ int res = SWIG_TypeError; ++ if (PyFloat_Check(obj)) { ++ if (val) *val = PyFloat_AsDouble(obj); ++ return SWIG_OK; ++ } else if (PyInt_Check(obj)) { ++ if (val) *val = PyInt_AsLong(obj); ++ return SWIG_OK; ++ } else if (PyLong_Check(obj)) { ++ double v = PyLong_AsDouble(obj); ++ if (!PyErr_Occurred()) { ++ if (val) *val = v; ++ return SWIG_OK; ++ } else { ++ PyErr_Clear(); + } +- return 0; + } +- return 1; ++#ifdef SWIG_PYTHON_CAST_MODE ++ { ++ int dispatch = 0; ++ double d = PyFloat_AsDouble(obj); ++ if (!PyErr_Occurred()) { ++ if (val) *val = d; ++ return SWIG_AddCast(SWIG_OK); ++ } else { ++ PyErr_Clear(); ++ } ++ if (!dispatch) { ++ long v = PyLong_AsLong(obj); ++ if (!PyErr_Occurred()) { ++ if (val) *val = v; ++ return SWIG_AddCast(SWIG_AddCast(SWIG_OK)); ++ } else { ++ PyErr_Clear(); ++ } ++ } ++ } ++#endif ++ return res; ++} ++ ++ ++#include ++ ++ ++#include ++ ++ ++SWIGINTERNINLINE int ++SWIG_CanCastAsInteger(double *d, double min, double max) { ++ double x = *d; ++ if ((min <= x && x <= max)) { ++ double fx = floor(x); ++ double cx = ceil(x); ++ double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ ++ if ((errno == EDOM) || (errno == ERANGE)) { ++ errno = 0; ++ } else { ++ double summ, reps, diff; ++ if (rd < x) { ++ diff = x - rd; ++ } else if (rd > x) { ++ diff = rd - x; ++ } else { ++ return 1; ++ } ++ summ = rd + x; ++ reps = diff/summ; ++ if (reps < 8*DBL_EPSILON) { ++ *d = rd; ++ return 1; ++ } ++ } ++ } ++ return 0; + } + + + SWIGINTERN int +- SWIG_AsVal_long(PyObject * obj, long* val) ++SWIG_AsVal_long (PyObject *obj, long* val) + { + if (PyInt_Check(obj)) { +- if (val) *val = PyInt_AS_LONG(obj); +- return 1; +- } +- if (PyLong_Check(obj)) { ++ if (val) *val = PyInt_AsLong(obj); ++ return SWIG_OK; ++ } else if (PyLong_Check(obj)) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; +- return 1; ++ return SWIG_OK; + } else { +- if (!val) PyErr_Clear(); +- return 0; ++ PyErr_Clear(); + } + } +- if (val) { +- SWIG_type_error("long", obj); +- } +- return 0; +- } +- +- +-#if INT_MAX != LONG_MAX +-SWIGINTERN int +- SWIG_AsVal_int(PyObject *obj, int *val) +-{ +- const char* errmsg = val ? "int" : (char*)0; +- long v; +- if (SWIG_AsVal_long(obj, &v)) { +- if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) { +- if (val) *val = (int)(v); +- return 1; ++#ifdef SWIG_PYTHON_CAST_MODE ++ { ++ int dispatch = 0; ++ long v = PyInt_AsLong(obj); ++ if (!PyErr_Occurred()) { ++ if (val) *val = v; ++ return SWIG_AddCast(SWIG_OK); + } else { +- return 0; ++ PyErr_Clear(); ++ } ++ if (!dispatch) { ++ double d; ++ int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); ++ if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { ++ if (val) *val = (long)(d); ++ return res; ++ } + } +- } else { +- PyErr_Clear(); +- } +- if (val) { +- SWIG_type_error(errmsg, obj); + } +- return 0; +-} +-#else +-SWIGINTERNSHORT int +- SWIG_AsVal_int(PyObject *obj, int *val) +-{ +- return SWIG_AsVal_long(obj,(long*)val); +-} + #endif +- +- +-SWIGINTERNSHORT int +-SWIG_As_int(PyObject* obj) +-{ +- int v; +- if (!SWIG_AsVal_int(obj, &v)) { +- /* +- this is needed to make valgrind/purify happier. +- */ +- memset((void*)&v, 0, sizeof(int)); +- } +- return v; ++ return SWIG_TypeError; + } + +- +-SWIGINTERNSHORT int +-SWIG_Check_int(PyObject* obj) ++ ++SWIGINTERN int ++SWIG_AsVal_int (PyObject * obj, int *val) + { +- return SWIG_AsVal_int(obj, (int*)0); ++ long v; ++ int res = SWIG_AsVal_long (obj, &v); ++ if (SWIG_IsOK(res)) { ++ if ((v < INT_MIN || v > INT_MAX)) { ++ return SWIG_OverflowError; ++ } else { ++ if (val) *val = (int)(v); ++ } ++ } ++ return res; + } + + + SWIGINTERN int +- SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val) ++SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) + { + if (PyInt_Check(obj)) { +- long v = PyInt_AS_LONG(obj); ++ long v = PyInt_AsLong(obj); + if (v >= 0) { + if (val) *val = v; +- return 1; +- } ++ return SWIG_OK; ++ } else { ++ return SWIG_OverflowError; ++ } ++ } else if (PyLong_Check(obj)) { ++ unsigned long v = PyLong_AsUnsignedLong(obj); ++ if (!PyErr_Occurred()) { ++ if (val) *val = v; ++ return SWIG_OK; ++ } else { ++ PyErr_Clear(); ++ } + } +- if (PyLong_Check(obj)) { ++#ifdef SWIG_PYTHON_CAST_MODE ++ { ++ int dispatch = 0; + unsigned long v = PyLong_AsUnsignedLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; +- return 1; ++ return SWIG_AddCast(SWIG_OK); + } else { +- if (!val) PyErr_Clear(); +- return 0; ++ PyErr_Clear(); ++ } ++ if (!dispatch) { ++ double d; ++ int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); ++ if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) { ++ if (val) *val = (unsigned long)(d); ++ return res; ++ } + } +- } +- if (val) { +- SWIG_type_error("unsigned long", obj); + } +- return 0; ++#endif ++ return SWIG_TypeError; + } + + +-SWIGINTERNSHORT unsigned long +-SWIG_As_unsigned_SS_long(PyObject* obj) ++SWIGINTERNINLINE int ++SWIG_AsVal_size_t (PyObject * obj, size_t *val) + { + unsigned long v; +- if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) { +- /* +- this is needed to make valgrind/purify happier. +- */ +- memset((void*)&v, 0, sizeof(unsigned long)); +- } +- return v; +-} +- +- +-SWIGINTERNSHORT int +-SWIG_Check_unsigned_SS_long(PyObject* obj) +-{ +- return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0); ++ int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0); ++ if (SWIG_IsOK(res) && val) *val = (size_t)(v); ++ return res; + } + + +-SWIGINTERN PyObject* +-t_output_helper(PyObject* target, PyObject* o) { +- if (!target) { +- target = o; +- } else if (target == Py_None) { +- Py_DECREF(target); +- target = o; +- } else { +- if (!PyList_Check(target)) { +- PyObject *o2 = target; +- target = PyList_New(1); +- PyList_SetItem(target, 0, o2); +- } +- PyList_Append(target,o); +- } +- return target; +-} +- +- +-char const *semanage_context_get_user(semanage_context_t const *); +-int semanage_context_set_user(semanage_handle_t *,semanage_context_t *,char const *); +-char const *semanage_context_get_role(semanage_context_t const *); +-int semanage_context_set_role(semanage_handle_t *,semanage_context_t *,char const *); +-char const *semanage_context_get_type(semanage_context_t const *); +-int semanage_context_set_type(semanage_handle_t *,semanage_context_t *,char const *); +-char const *semanage_context_get_mls(semanage_context_t const *); +-int semanage_context_set_mls(semanage_handle_t *,semanage_context_t *,char const *); +-int semanage_context_create(semanage_handle_t *,semanage_context_t **); +-int semanage_context_clone(semanage_handle_t *,semanage_context_t const *,semanage_context_t **); +-void semanage_context_free(semanage_context_t *); +-int semanage_context_from_string(semanage_handle_t *,char const *,semanage_context_t **); +-int semanage_context_to_string(semanage_handle_t *,semanage_context_t const *,char **); +-int semanage_bool_key_create(semanage_handle_t *,char const *,semanage_bool_key_t **); +-int semanage_bool_key_extract(semanage_handle_t *,semanage_bool_t const *,semanage_bool_key_t **); +-void semanage_bool_key_free(semanage_bool_key_t *); +-int semanage_bool_compare(semanage_bool_t const *,semanage_bool_key_t const *); +-int semanage_bool_compare2(semanage_bool_t const *,semanage_bool_t const *); +-char const *semanage_bool_get_name(semanage_bool_t const *); +-int semanage_bool_set_name(semanage_handle_t *,semanage_bool_t *,char const *); +-int semanage_bool_get_value(semanage_bool_t const *); +-void semanage_bool_set_value(semanage_bool_t *,int); +-int semanage_bool_create(semanage_handle_t *,semanage_bool_t **); +-int semanage_bool_clone(semanage_handle_t *,semanage_bool_t const *,semanage_bool_t **); +-void semanage_bool_free(semanage_bool_t *); +-int semanage_bool_query(semanage_handle_t *,semanage_bool_key_t const *,semanage_bool_t **); +-int semanage_bool_exists(semanage_handle_t *,semanage_bool_key_t const *,int *); +-int semanage_bool_count(semanage_handle_t *,unsigned int *); +-int semanage_bool_iterate(semanage_handle_t *,int (*)(semanage_bool_t const *,void *),void *); +-int semanage_bool_list(semanage_handle_t *,semanage_bool_t ***,unsigned int *); +-int semanage_bool_modify_local(semanage_handle_t *,semanage_bool_key_t const *,semanage_bool_t const *); +-int semanage_bool_del_local(semanage_handle_t *,semanage_bool_key_t const *); +-int semanage_bool_query_local(semanage_handle_t *,semanage_bool_key_t const *,semanage_bool_t **); +-int semanage_bool_exists_local(semanage_handle_t *,semanage_bool_key_t const *,int *); +-int semanage_bool_count_local(semanage_handle_t *,unsigned int *); +-int semanage_bool_iterate_local(semanage_handle_t *,int (*)(semanage_bool_t const *,void *),void *); +-int semanage_bool_list_local(semanage_handle_t *,semanage_bool_t ***,unsigned int *); +-int semanage_bool_set_active(semanage_handle_t *,semanage_bool_key_t const *,semanage_bool_t const *); +-int semanage_bool_query_active(semanage_handle_t *,semanage_bool_key_t const *,semanage_bool_t **); +-int semanage_bool_exists_active(semanage_handle_t *,semanage_bool_key_t const *,int *); +-int semanage_bool_count_active(semanage_handle_t *,unsigned int *); +-int semanage_bool_iterate_active(semanage_handle_t *,int (*)(semanage_bool_t const *,void *),void *); +-int semanage_bool_list_active(semanage_handle_t *,semanage_bool_t ***,unsigned int *); +-int semanage_iface_compare(semanage_iface_t const *,semanage_iface_key_t const *); +-int semanage_iface_compare2(semanage_iface_t const *,semanage_iface_t const *); +-int semanage_iface_key_create(semanage_handle_t *,char const *,semanage_iface_key_t **); +-int semanage_iface_key_extract(semanage_handle_t *,semanage_iface_t const *,semanage_iface_key_t **); +-void semanage_iface_key_free(semanage_iface_key_t *); +-char const *semanage_iface_get_name(semanage_iface_t const *); +-int semanage_iface_set_name(semanage_handle_t *,semanage_iface_t *,char const *); +-semanage_context_t *semanage_iface_get_ifcon(semanage_iface_t const *); +-int semanage_iface_set_ifcon(semanage_handle_t *,semanage_iface_t *,semanage_context_t *); +-semanage_context_t *semanage_iface_get_msgcon(semanage_iface_t const *); +-int semanage_iface_set_msgcon(semanage_handle_t *,semanage_iface_t *,semanage_context_t *); +-int semanage_iface_create(semanage_handle_t *,semanage_iface_t **); +-int semanage_iface_clone(semanage_handle_t *,semanage_iface_t const *,semanage_iface_t **); +-void semanage_iface_free(semanage_iface_t *); +-int semanage_iface_modify_local(semanage_handle_t *,semanage_iface_key_t const *,semanage_iface_t const *); +-int semanage_iface_del_local(semanage_handle_t *,semanage_iface_key_t const *); +-int semanage_iface_query_local(semanage_handle_t *,semanage_iface_key_t const *,semanage_iface_t **); +-int semanage_iface_exists_local(semanage_handle_t *,semanage_iface_key_t const *,int *); +-int semanage_iface_count_local(semanage_handle_t *,unsigned int *); +-int semanage_iface_iterate_local(semanage_handle_t *,int (*)(semanage_iface_t const *,void *),void *); +-int semanage_iface_list_local(semanage_handle_t *,semanage_iface_t ***,unsigned int *); +-int semanage_iface_query(semanage_handle_t *,semanage_iface_key_t const *,semanage_iface_t **); +-int semanage_iface_exists(semanage_handle_t *,semanage_iface_key_t const *,int *); +-int semanage_iface_count(semanage_handle_t *,unsigned int *); +-int semanage_iface_iterate(semanage_handle_t *,int (*)(semanage_iface_t const *,void *),void *); +-int semanage_iface_list(semanage_handle_t *,semanage_iface_t ***,unsigned int *); +-int semanage_user_key_create(semanage_handle_t *,char const *,semanage_user_key_t **); +-int semanage_user_key_extract(semanage_handle_t *,semanage_user_t const *,semanage_user_key_t **); +-void semanage_user_key_free(semanage_user_key_t *); +-int semanage_user_compare(semanage_user_t const *,semanage_user_key_t const *); +-int semanage_user_compare2(semanage_user_t const *,semanage_user_t const *); +-char const *semanage_user_get_name(semanage_user_t const *); +-int semanage_user_set_name(semanage_handle_t *,semanage_user_t *,char const *); +-char const *semanage_user_get_prefix(semanage_user_t const *); +-int semanage_user_set_prefix(semanage_handle_t *,semanage_user_t *,char const *); +-char const *semanage_user_get_mlslevel(semanage_user_t const *); +-int semanage_user_set_mlslevel(semanage_handle_t *,semanage_user_t *,char const *); +-char const *semanage_user_get_mlsrange(semanage_user_t const *); +-int semanage_user_set_mlsrange(semanage_handle_t *,semanage_user_t *,char const *); +-int semanage_user_get_num_roles(semanage_user_t const *); +-int semanage_user_add_role(semanage_handle_t *,semanage_user_t *,char const *); +-void semanage_user_del_role(semanage_user_t *,char const *); +-int semanage_user_has_role(semanage_user_t const *,char const *); +-int semanage_user_get_roles(semanage_handle_t *,semanage_user_t const *,char const ***,unsigned int *); +-int semanage_user_set_roles(semanage_handle_t *,semanage_user_t *,char const **,unsigned int); +- +-SWIGINTERNSHORT int +- SWIG_CheckUnsignedLongInRange(unsigned long value, +- unsigned long max_value, +- const char *errmsg) +-{ +- if (value > max_value) { +- if (errmsg) { +- PyErr_Format(PyExc_OverflowError, +- "value %lu is greater than '%s' minimum %lu", +- value, errmsg, max_value); +- } +- return 0; +- } +- return 1; +- } +- +- +-#if UINT_MAX != ULONG_MAX + SWIGINTERN int +- SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val) +-{ +- const char* errmsg = val ? "unsigned int" : (char*)0; ++SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val) ++{ + unsigned long v; +- if (SWIG_AsVal_unsigned_SS_long(obj, &v)) { +- if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) { ++ int res = SWIG_AsVal_unsigned_SS_long (obj, &v); ++ if (SWIG_IsOK(res)) { ++ if ((v > UINT_MAX)) { ++ return SWIG_OverflowError; ++ } else { + if (val) *val = (unsigned int)(v); +- return 1; + } +- } else { +- PyErr_Clear(); +- } +- if (val) { +- SWIG_type_error(errmsg, obj); +- } +- return 0; +-} +-#else +-SWIGINTERNSHORT unsigned int +- SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val) +-{ +- return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val); ++ } ++ return res; + } +-#endif +- + +-SWIGINTERNSHORT unsigned int +-SWIG_As_unsigned_SS_int(PyObject* obj) +-{ +- unsigned int v; +- if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) { +- /* +- this is needed to make valgrind/purify happier. +- */ +- memset((void*)&v, 0, sizeof(unsigned int)); +- } +- return v; +-} +- +- +-SWIGINTERNSHORT int +-SWIG_Check_unsigned_SS_int(PyObject* obj) +-{ +- return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0); +-} +- +-int semanage_user_create(semanage_handle_t *,semanage_user_t **); +-int semanage_user_clone(semanage_handle_t *,semanage_user_t const *,semanage_user_t **); +-void semanage_user_free(semanage_user_t *); +-int semanage_user_modify_local(semanage_handle_t *,semanage_user_key_t const *,semanage_user_t const *); +-int semanage_user_del_local(semanage_handle_t *,semanage_user_key_t const *); +-int semanage_user_query_local(semanage_handle_t *,semanage_user_key_t const *,semanage_user_t **); +-int semanage_user_exists_local(semanage_handle_t *,semanage_user_key_t const *,int *); +-int semanage_user_count_local(semanage_handle_t *,unsigned int *); +-int semanage_user_iterate_local(semanage_handle_t *,int (*)(semanage_user_t const *,void *),void *); +-int semanage_user_list_local(semanage_handle_t *,semanage_user_t ***,unsigned int *); +-int semanage_user_query(semanage_handle_t *,semanage_user_key_t const *,semanage_user_t **); +-int semanage_user_exists(semanage_handle_t *,semanage_user_key_t const *,int *); +-int semanage_user_count(semanage_handle_t *,unsigned int *); +-int semanage_user_iterate(semanage_handle_t *,int (*)(semanage_user_t const *,void *),void *); +-int semanage_user_list(semanage_handle_t *,semanage_user_t ***,unsigned int *); +-int semanage_port_compare(semanage_port_t const *,semanage_port_key_t const *); +-int semanage_port_compare2(semanage_port_t const *,semanage_port_t const *); +-int semanage_port_key_create(semanage_handle_t *,int,int,int,semanage_port_key_t **); +-int semanage_port_key_extract(semanage_handle_t *,semanage_port_t const *,semanage_port_key_t **); +-void semanage_port_key_free(semanage_port_key_t *); +-int semanage_port_get_proto(semanage_port_t const *); +-void semanage_port_set_proto(semanage_port_t *,int); +-char const *semanage_port_get_proto_str(int); +-int semanage_port_get_low(semanage_port_t const *); +-int semanage_port_get_high(semanage_port_t const *); +-void semanage_port_set_port(semanage_port_t *,int); +-void semanage_port_set_range(semanage_port_t *,int,int); +-semanage_context_t *semanage_port_get_con(semanage_port_t const *); +-int semanage_port_set_con(semanage_handle_t *,semanage_port_t *,semanage_context_t *); +-int semanage_port_create(semanage_handle_t *,semanage_port_t **); +-int semanage_port_clone(semanage_handle_t *,semanage_port_t const *,semanage_port_t **); +-void semanage_port_free(semanage_port_t *); +-int semanage_port_modify_local(semanage_handle_t *,semanage_port_key_t const *,semanage_port_t const *); +-int semanage_port_del_local(semanage_handle_t *,semanage_port_key_t const *); +-int semanage_port_query_local(semanage_handle_t *,semanage_port_key_t const *,semanage_port_t **); +-int semanage_port_exists_local(semanage_handle_t *,semanage_port_key_t const *,int *); +-int semanage_port_count_local(semanage_handle_t *,unsigned int *); +-int semanage_port_iterate_local(semanage_handle_t *,int (*)(semanage_port_t const *,void *),void *); +-int semanage_port_list_local(semanage_handle_t *,semanage_port_t ***,unsigned int *); +-int semanage_port_query(semanage_handle_t *,semanage_port_key_t const *,semanage_port_t **); +-int semanage_port_exists(semanage_handle_t *,semanage_port_key_t const *,int *); +-int semanage_port_count(semanage_handle_t *,unsigned int *); +-int semanage_port_iterate(semanage_handle_t *,int (*)(semanage_port_t const *,void *),void *); +-int semanage_port_list(semanage_handle_t *,semanage_port_t ***,unsigned int *); +-int semanage_fcontext_compare(semanage_fcontext_t const *,semanage_fcontext_key_t const *); +-int semanage_fcontext_compare2(semanage_fcontext_t const *,semanage_fcontext_t const *); +-int semanage_fcontext_key_create(semanage_handle_t *,char const *,int,semanage_fcontext_key_t **); +-int semanage_fcontext_key_extract(semanage_handle_t *,semanage_fcontext_t const *,semanage_fcontext_key_t **); +-void semanage_fcontext_key_free(semanage_fcontext_key_t *); +-char const *semanage_fcontext_get_expr(semanage_fcontext_t const *); +-int semanage_fcontext_set_expr(semanage_handle_t *,semanage_fcontext_t *,char const *); +-int semanage_fcontext_get_type(semanage_fcontext_t const *); +-char const *semanage_fcontext_get_type_str(int); +-void semanage_fcontext_set_type(semanage_fcontext_t *,int); +-semanage_context_t *semanage_fcontext_get_con(semanage_fcontext_t const *); +-int semanage_fcontext_set_con(semanage_handle_t *,semanage_fcontext_t *,semanage_context_t *); +-int semanage_fcontext_create(semanage_handle_t *,semanage_fcontext_t **); +-int semanage_fcontext_clone(semanage_handle_t *,semanage_fcontext_t const *,semanage_fcontext_t **); +-void semanage_fcontext_free(semanage_fcontext_t *); +-int semanage_fcontext_modify_local(semanage_handle_t *,semanage_fcontext_key_t const *,semanage_fcontext_t const *); +-int semanage_fcontext_del_local(semanage_handle_t *,semanage_fcontext_key_t const *); +-int semanage_fcontext_query_local(semanage_handle_t *,semanage_fcontext_key_t const *,semanage_fcontext_t **); +-int semanage_fcontext_exists_local(semanage_handle_t *,semanage_fcontext_key_t const *,int *); +-int semanage_fcontext_count_local(semanage_handle_t *,unsigned int *); +-int semanage_fcontext_iterate_local(semanage_handle_t *,int (*)(semanage_fcontext_t const *,void *),void *); +-int semanage_fcontext_list_local(semanage_handle_t *,semanage_fcontext_t ***,unsigned int *); +-int semanage_fcontext_query(semanage_handle_t *,semanage_fcontext_key_t const *,semanage_fcontext_t **); +-int semanage_fcontext_exists(semanage_handle_t *,semanage_fcontext_key_t const *,int *); +-int semanage_fcontext_count(semanage_handle_t *,unsigned int *); +-int semanage_fcontext_iterate(semanage_handle_t *,int (*)(semanage_fcontext_t const *,void *),void *); +-int semanage_fcontext_list(semanage_handle_t *,semanage_fcontext_t ***,unsigned int *); +-int semanage_seuser_key_create(semanage_handle_t *,char const *,semanage_seuser_key_t **); +-int semanage_seuser_key_extract(semanage_handle_t *,semanage_seuser_t const *,semanage_seuser_key_t **); +-void semanage_seuser_key_free(semanage_seuser_key_t *); +-int semanage_seuser_compare(semanage_seuser_t const *,semanage_seuser_key_t const *); +-int semanage_seuser_compare2(semanage_seuser_t const *,semanage_seuser_t const *); +-char const *semanage_seuser_get_name(semanage_seuser_t const *); +-int semanage_seuser_set_name(semanage_handle_t *,semanage_seuser_t *,char const *); +-char const *semanage_seuser_get_sename(semanage_seuser_t const *); +-int semanage_seuser_set_sename(semanage_handle_t *,semanage_seuser_t *,char const *); +-char const *semanage_seuser_get_mlsrange(semanage_seuser_t const *); +-int semanage_seuser_set_mlsrange(semanage_handle_t *,semanage_seuser_t *,char const *); +-int semanage_seuser_create(semanage_handle_t *,semanage_seuser_t **); +-int semanage_seuser_clone(semanage_handle_t *,semanage_seuser_t const *,semanage_seuser_t **); +-void semanage_seuser_free(semanage_seuser_t *); +-int semanage_seuser_modify_local(semanage_handle_t *,semanage_seuser_key_t const *,semanage_seuser_t const *); +-int semanage_seuser_del_local(semanage_handle_t *,semanage_seuser_key_t const *); +-int semanage_seuser_query_local(semanage_handle_t *,semanage_seuser_key_t const *,semanage_seuser_t **); +-int semanage_seuser_exists_local(semanage_handle_t *,semanage_seuser_key_t const *,int *); +-int semanage_seuser_count_local(semanage_handle_t *,unsigned int *); +-int semanage_seuser_iterate_local(semanage_handle_t *,int (*)(semanage_seuser_t const *,void *),void *); +-int semanage_seuser_list_local(semanage_handle_t *,semanage_seuser_t ***,unsigned int *); +-int semanage_seuser_query(semanage_handle_t *,semanage_seuser_key_t const *,semanage_seuser_t **); +-int semanage_seuser_exists(semanage_handle_t *,semanage_seuser_key_t const *,int *); +-int semanage_seuser_count(semanage_handle_t *,unsigned int *); +-int semanage_seuser_iterate(semanage_handle_t *,int (*)(semanage_seuser_t const *,void *),void *); +-int semanage_seuser_list(semanage_handle_t *,semanage_seuser_t ***,unsigned int *); +-int semanage_node_compare(semanage_node_t const *,semanage_node_key_t const *); +-int semanage_node_compare2(semanage_node_t const *,semanage_node_t const *); +-int semanage_node_key_create(semanage_handle_t *,char const *,char const *,int,semanage_node_key_t **); +-int semanage_node_key_extract(semanage_handle_t *,semanage_node_t const *,semanage_node_key_t **); +-void semanage_node_key_free(semanage_node_key_t *); +-int semanage_node_get_addr(semanage_handle_t *,semanage_node_t const *,char **); +-int semanage_node_get_addr_bytes(semanage_handle_t *,semanage_node_t const *,char **,size_t *); +-int semanage_node_set_addr(semanage_handle_t *,semanage_node_t *,int,char const *); +-int semanage_node_set_addr_bytes(semanage_handle_t *,semanage_node_t *,char const *,size_t); +-int semanage_node_get_mask(semanage_handle_t *,semanage_node_t const *,char **); +-int semanage_node_get_mask_bytes(semanage_handle_t *,semanage_node_t const *,char **,size_t *); +-int semanage_node_set_mask(semanage_handle_t *,semanage_node_t *,int,char const *); +-int semanage_node_set_mask_bytes(semanage_handle_t *,semanage_node_t *,char const *,size_t); +-int semanage_node_get_proto(semanage_node_t const *); +-void semanage_node_set_proto(semanage_node_t *,int); +-char const *semanage_node_get_proto_str(int); +-semanage_context_t *semanage_node_get_con(semanage_node_t const *); +-int semanage_node_set_con(semanage_handle_t *,semanage_node_t *,semanage_context_t *); +-int semanage_node_create(semanage_handle_t *,semanage_node_t **); +-int semanage_node_clone(semanage_handle_t *,semanage_node_t const *,semanage_node_t **); +-void semanage_node_free(semanage_node_t *); +-int semanage_node_modify_local(semanage_handle_t *,semanage_node_key_t const *,semanage_node_t const *); +-int semanage_node_del_local(semanage_handle_t *,semanage_node_key_t const *); +-int semanage_node_query_local(semanage_handle_t *,semanage_node_key_t const *,semanage_node_t **); +-int semanage_node_exists_local(semanage_handle_t *,semanage_node_key_t const *,int *); +-int semanage_node_count_local(semanage_handle_t *,unsigned int *); +-int semanage_node_iterate_local(semanage_handle_t *,int (*)(semanage_node_t const *,void *),void *); +-int semanage_node_list_local(semanage_handle_t *,semanage_node_t ***,unsigned int *); +-int semanage_node_query(semanage_handle_t *,semanage_node_key_t const *,semanage_node_t **); +-int semanage_node_exists(semanage_handle_t *,semanage_node_key_t const *,int *); +-int semanage_node_count(semanage_handle_t *,unsigned int *); +-int semanage_node_iterate(semanage_handle_t *,int (*)(semanage_node_t const *,void *),void *); +-int semanage_node_list(semanage_handle_t *,semanage_node_t ***,unsigned int *); + #ifdef __cplusplus + extern "C" { + #endif +@@ -1987,6710 +2913,8418 @@ + return STATUS_ERR; + } + +-static PyObject *_wrap_semanage_msg_get_level(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_msg_get_level",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_msg_get_level(arg1); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_msg_get_level",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_msg_get_level" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_msg_get_level(arg1); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_msg_get_channel(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- char *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_msg_get_channel",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (char *)semanage_msg_get_channel(arg1); +- +- resultobj = SWIG_FromCharPtr(result); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_msg_get_channel",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_msg_get_channel" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (char *)semanage_msg_get_channel(arg1); ++ resultobj = SWIG_FromCharPtr(result); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_msg_get_fname(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- char *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_msg_get_fname",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (char *)semanage_msg_get_fname(arg1); +- +- resultobj = SWIG_FromCharPtr(result); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_msg_get_fname",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_msg_get_fname" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (char *)semanage_msg_get_fname(arg1); ++ resultobj = SWIG_FromCharPtr(result); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_msg_set_callback(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- void (*arg2)(void *,semanage_handle_t *,char const *,...) = (void (*)(void *,semanage_handle_t *,char const *,...)) 0 ; +- void *arg3 = (void *) 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_msg_set_callback",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_void_p_struct_semanage_handle_p_q_const__char_v_______void, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- { +- if ((SWIG_ConvertPtr(obj2,(void **)(&arg3),0,SWIG_POINTER_EXCEPTION|0))== -1) { +- SWIG_arg_fail(3);SWIG_fail; +- } ++SWIGINTERN PyObject *_wrap_semanage_msg_set_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ void (*arg2)(void *,semanage_handle_t *,char const *,...) = (void (*)(void *,semanage_handle_t *,char const *,...)) 0 ; ++ void *arg3 = (void *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ int res3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_msg_set_callback",&obj0,&obj1,&obj2)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_msg_set_callback" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_struct_semanage_handle_p_q_const__char_v_______void); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "semanage_msg_set_callback" "', argument " "2"" of type '" "void (*)(void *,semanage_handle_t *,char const *,...)""'"); + } +- semanage_msg_set_callback(arg1,arg2,arg3); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++ } ++ res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_msg_set_callback" "', argument " "3"" of type '" "void *""'"); ++ } ++ semanage_msg_set_callback(arg1,arg2,arg3); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_handle_create(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *result; +- +- if(!PyArg_ParseTuple(args,(char *)":semanage_handle_create")) goto fail; +- result = (semanage_handle_t *)semanage_handle_create(); +- +- resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_semanage_handle, 0); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_handle_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_handle_t *result = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)":semanage_handle_create")) SWIG_fail; ++ result = (semanage_handle_t *)semanage_handle_create(); ++ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_handle_destroy(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_handle_destroy",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- semanage_handle_destroy(arg1); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_handle_destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_handle_destroy",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_handle_destroy" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ semanage_handle_destroy(arg1); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_select_store(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- char *arg2 = (char *) 0 ; +- enum semanage_connect_type arg3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_select_store",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { +- SWIG_arg_fail(2);SWIG_fail; +- } +- { +- arg3 = (enum semanage_connect_type)(SWIG_As_int(obj2)); +- if (SWIG_arg_fail(3)) SWIG_fail; +- } +- semanage_select_store(arg1,arg2,(enum semanage_connect_type )arg3); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_select_store(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ char *arg2 = (char *) 0 ; ++ enum semanage_connect_type arg3 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ int res2 ; ++ char *buf2 = 0 ; ++ int alloc2 = 0 ; ++ int val3 ; ++ int ecode3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_select_store",&obj0,&obj1,&obj2)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_select_store" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_select_store" "', argument " "2"" of type '" "char *""'"); ++ } ++ arg2 = buf2; ++ ecode3 = SWIG_AsVal_int(obj2, &val3); ++ if (!SWIG_IsOK(ecode3)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "semanage_select_store" "', argument " "3"" of type '" "enum semanage_connect_type""'"); ++ } ++ arg3 = (enum semanage_connect_type)(val3); ++ semanage_select_store(arg1,arg2,arg3); ++ resultobj = SWIG_Py_Void(); ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return resultobj; ++fail: ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_reload_policy(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_reload_policy",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_reload_policy(arg1); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_reload_policy",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_reload_policy" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_reload_policy(arg1); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_set_reload(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int arg2 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_set_reload",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- { +- arg2 = (int)(SWIG_As_int(obj1)); +- if (SWIG_arg_fail(2)) SWIG_fail; +- } +- semanage_set_reload(arg1,arg2); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_set_reload(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ int arg2 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ int val2 ; ++ int ecode2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_set_reload",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_set_reload" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ ecode2 = SWIG_AsVal_int(obj1, &val2); ++ if (!SWIG_IsOK(ecode2)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "semanage_set_reload" "', argument " "2"" of type '" "int""'"); ++ } ++ arg2 = (int)(val2); ++ semanage_set_reload(arg1,arg2); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_set_rebuild(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int arg2 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_set_rebuild",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- { +- arg2 = (int)(SWIG_As_int(obj1)); +- if (SWIG_arg_fail(2)) SWIG_fail; +- } +- semanage_set_rebuild(arg1,arg2); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_set_rebuild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ int arg2 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ int val2 ; ++ int ecode2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_set_rebuild",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_set_rebuild" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ ecode2 = SWIG_AsVal_int(obj1, &val2); ++ if (!SWIG_IsOK(ecode2)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "semanage_set_rebuild" "', argument " "2"" of type '" "int""'"); ++ } ++ arg2 = (int)(val2); ++ semanage_set_rebuild(arg1,arg2); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_set_create_store(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int arg2 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_set_create_store",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- { +- arg2 = (int)(SWIG_As_int(obj1)); +- if (SWIG_arg_fail(2)) SWIG_fail; +- } +- semanage_set_create_store(arg1,arg2); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_set_create_store(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ int arg2 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ int val2 ; ++ int ecode2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_set_create_store",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_set_create_store" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ ecode2 = SWIG_AsVal_int(obj1, &val2); ++ if (!SWIG_IsOK(ecode2)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "semanage_set_create_store" "', argument " "2"" of type '" "int""'"); ++ } ++ arg2 = (int)(val2); ++ semanage_set_create_store(arg1,arg2); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_is_managed(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_is_managed",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_is_managed(arg1); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_is_managed",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_is_managed" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_is_managed(arg1); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_connect(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_connect",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_connect(arg1); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_connect",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_connect" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_connect(arg1); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_disconnect(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_disconnect",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_disconnect(arg1); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_disconnect",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_disconnect" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_disconnect(arg1); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_begin_transaction(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_begin_transaction",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_begin_transaction(arg1); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_begin_transaction",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_begin_transaction" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_begin_transaction(arg1); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_commit(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_commit",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_commit(arg1); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_commit",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_commit" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_commit(arg1); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_access_check(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_access_check",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_access_check(arg1); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_access_check",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_access_check" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_access_check(arg1); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_is_connected(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_is_connected",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_is_connected(arg1); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_is_connected",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_is_connected" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_is_connected(arg1); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_module_install(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- char *arg2 = (char *) 0 ; +- size_t arg3 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_module_install",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { +- SWIG_arg_fail(2);SWIG_fail; +- } +- { +- arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2)); +- if (SWIG_arg_fail(3)) SWIG_fail; +- } +- result = (int)semanage_module_install(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_module_install(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ char *buf2 = 0 ; ++ int alloc2 = 0 ; ++ size_t val3 ; ++ int ecode3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_module_install" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_module_install" "', argument " "2"" of type '" "char *""'"); ++ } ++ arg2 = buf2; ++ ecode3 = SWIG_AsVal_size_t(obj2, &val3); ++ if (!SWIG_IsOK(ecode3)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "semanage_module_install" "', argument " "3"" of type '" "size_t""'"); ++ } ++ arg3 = (size_t)(val3); ++ result = (int)semanage_module_install(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return resultobj; ++fail: ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_module_upgrade(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- char *arg2 = (char *) 0 ; +- size_t arg3 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_module_upgrade",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { +- SWIG_arg_fail(2);SWIG_fail; +- } +- { +- arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2)); +- if (SWIG_arg_fail(3)) SWIG_fail; +- } +- result = (int)semanage_module_upgrade(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_module_upgrade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ char *buf2 = 0 ; ++ int alloc2 = 0 ; ++ size_t val3 ; ++ int ecode3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_module_upgrade" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_module_upgrade" "', argument " "2"" of type '" "char *""'"); ++ } ++ arg2 = buf2; ++ ecode3 = SWIG_AsVal_size_t(obj2, &val3); ++ if (!SWIG_IsOK(ecode3)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "semanage_module_upgrade" "', argument " "3"" of type '" "size_t""'"); ++ } ++ arg3 = (size_t)(val3); ++ result = (int)semanage_module_upgrade(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return resultobj; ++fail: ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_module_install_base(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- char *arg2 = (char *) 0 ; +- size_t arg3 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_module_install_base",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { +- SWIG_arg_fail(2);SWIG_fail; +- } +- { +- arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2)); +- if (SWIG_arg_fail(3)) SWIG_fail; +- } +- result = (int)semanage_module_install_base(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_module_install_base(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ char *buf2 = 0 ; ++ int alloc2 = 0 ; ++ size_t val3 ; ++ int ecode3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_module_install_base" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_module_install_base" "', argument " "2"" of type '" "char *""'"); ++ } ++ arg2 = buf2; ++ ecode3 = SWIG_AsVal_size_t(obj2, &val3); ++ if (!SWIG_IsOK(ecode3)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "semanage_module_install_base" "', argument " "3"" of type '" "size_t""'"); ++ } ++ arg3 = (size_t)(val3); ++ result = (int)semanage_module_install_base(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return resultobj; ++fail: ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_module_remove(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- char *arg2 = (char *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_module_remove",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { +- SWIG_arg_fail(2);SWIG_fail; +- } +- result = (int)semanage_module_remove(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_module_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ char *buf2 = 0 ; ++ int alloc2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_module_remove",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_module_remove" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_module_remove" "', argument " "2"" of type '" "char *""'"); ++ } ++ arg2 = buf2; ++ result = (int)semanage_module_remove(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return resultobj; ++fail: ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_module_list(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_module_info_t **arg2 = (semanage_module_info_t **) 0 ; +- int *arg3 = (int *) 0 ; +- int result; +- semanage_module_info_t *temp2 ; +- int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; +- } +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_module_list",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_module_list(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_semanage_module_info, 0)); +- } +- resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_module_list(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_module_list",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_module_list" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_module_list(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_semanage_module_info, 0)); ++ } ++ if (SWIG_IsTmpObj(res3)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_module_info_datum_destroy(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_module_info_t *arg1 = (semanage_module_info_t *) 0 ; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_module_info_datum_destroy",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_module_info, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- semanage_module_info_datum_destroy(arg1); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_module_info_datum_destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_module_info_t *arg1 = (semanage_module_info_t *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_module_info_datum_destroy",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_module_info, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_module_info_datum_destroy" "', argument " "1"" of type '" "semanage_module_info_t *""'"); ++ } ++ arg1 = (semanage_module_info_t *)(argp1); ++ semanage_module_info_datum_destroy(arg1); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_module_list_nth(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_module_info_t *arg1 = (semanage_module_info_t *) 0 ; +- int arg2 ; +- semanage_module_info_t *result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_module_list_nth",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_module_info, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- { +- arg2 = (int)(SWIG_As_int(obj1)); +- if (SWIG_arg_fail(2)) SWIG_fail; +- } +- result = (semanage_module_info_t *)semanage_module_list_nth(arg1,arg2); +- +- resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_semanage_module_info, 0); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_module_list_nth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_module_list_nth" "', argument " "1"" of type '" "semanage_module_info_t *""'"); ++ } ++ arg1 = (semanage_module_info_t *)(argp1); ++ ecode2 = SWIG_AsVal_int(obj1, &val2); ++ if (!SWIG_IsOK(ecode2)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "semanage_module_list_nth" "', argument " "2"" of type '" "int""'"); ++ } ++ arg2 = (int)(val2); ++ result = (semanage_module_info_t *)semanage_module_list_nth(arg1,arg2); ++ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_semanage_module_info, 0 | 0 ); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_module_get_name(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_module_info_t *arg1 = (semanage_module_info_t *) 0 ; +- char *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_module_get_name",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_module_info, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (char *)semanage_module_get_name(arg1); +- +- resultobj = SWIG_FromCharPtr(result); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_module_get_name" "', argument " "1"" of type '" "semanage_module_info_t *""'"); ++ } ++ arg1 = (semanage_module_info_t *)(argp1); ++ result = (char *)semanage_module_get_name(arg1); ++ resultobj = SWIG_FromCharPtr(result); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_module_get_version(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_module_info_t *arg1 = (semanage_module_info_t *) 0 ; +- char *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_module_get_version",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_module_info, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (char *)semanage_module_get_version(arg1); +- +- resultobj = SWIG_FromCharPtr(result); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_module_get_version" "', argument " "1"" of type '" "semanage_module_info_t *""'"); ++ } ++ arg1 = (semanage_module_info_t *)(argp1); ++ result = (char *)semanage_module_get_version(arg1); ++ resultobj = SWIG_FromCharPtr(result); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_context_get_user(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_context_t *arg1 = (semanage_context_t *) 0 ; +- char *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_context_get_user",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (char *)semanage_context_get_user((semanage_context_t const *)arg1); +- +- resultobj = SWIG_FromCharPtr(result); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_context_get_user",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_context, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_context_get_user" "', argument " "1"" of type '" "semanage_context_t const *""'"); ++ } ++ arg1 = (semanage_context_t *)(argp1); ++ result = (char *)semanage_context_get_user((struct semanage_context const *)arg1); ++ resultobj = SWIG_FromCharPtr(result); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_context_set_user(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_context_t *arg2 = (semanage_context_t *) 0 ; +- char *arg3 = (char *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_context_set_user",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- result = (int)semanage_context_set_user(arg1,arg2,(char const *)arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_context_set_user(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int res3 ; ++ char *buf3 = 0 ; ++ int alloc3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_context_set_user" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_context, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_context_set_user" "', argument " "2"" of type '" "semanage_context_t *""'"); ++ } ++ arg2 = (semanage_context_t *)(argp2); ++ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_context_set_user" "', argument " "3"" of type '" "char const *""'"); ++ } ++ arg3 = buf3; ++ result = (int)semanage_context_set_user(arg1,arg2,(char const *)arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return resultobj; ++fail: ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_context_get_role(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_context_t *arg1 = (semanage_context_t *) 0 ; +- char *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_context_get_role",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (char *)semanage_context_get_role((semanage_context_t const *)arg1); +- +- resultobj = SWIG_FromCharPtr(result); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_context_get_role",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_context, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_context_get_role" "', argument " "1"" of type '" "semanage_context_t const *""'"); ++ } ++ arg1 = (semanage_context_t *)(argp1); ++ result = (char *)semanage_context_get_role((struct semanage_context const *)arg1); ++ resultobj = SWIG_FromCharPtr(result); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_context_set_role(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_context_t *arg2 = (semanage_context_t *) 0 ; +- char *arg3 = (char *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_context_set_role",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- result = (int)semanage_context_set_role(arg1,arg2,(char const *)arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_context_set_role(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int res3 ; ++ char *buf3 = 0 ; ++ int alloc3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_context_set_role" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_context, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_context_set_role" "', argument " "2"" of type '" "semanage_context_t *""'"); ++ } ++ arg2 = (semanage_context_t *)(argp2); ++ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_context_set_role" "', argument " "3"" of type '" "char const *""'"); ++ } ++ arg3 = buf3; ++ result = (int)semanage_context_set_role(arg1,arg2,(char const *)arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return resultobj; ++fail: ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_context_get_type(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_context_t *arg1 = (semanage_context_t *) 0 ; +- char *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_context_get_type",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (char *)semanage_context_get_type((semanage_context_t const *)arg1); +- +- resultobj = SWIG_FromCharPtr(result); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_context_get_type",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_context, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_context_get_type" "', argument " "1"" of type '" "semanage_context_t const *""'"); ++ } ++ arg1 = (semanage_context_t *)(argp1); ++ result = (char *)semanage_context_get_type((struct semanage_context const *)arg1); ++ resultobj = SWIG_FromCharPtr(result); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_context_set_type(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_context_t *arg2 = (semanage_context_t *) 0 ; +- char *arg3 = (char *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_context_set_type",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- result = (int)semanage_context_set_type(arg1,arg2,(char const *)arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_context_set_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int res3 ; ++ char *buf3 = 0 ; ++ int alloc3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_context_set_type" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_context, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_context_set_type" "', argument " "2"" of type '" "semanage_context_t *""'"); ++ } ++ arg2 = (semanage_context_t *)(argp2); ++ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_context_set_type" "', argument " "3"" of type '" "char const *""'"); ++ } ++ arg3 = buf3; ++ result = (int)semanage_context_set_type(arg1,arg2,(char const *)arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return resultobj; ++fail: ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_context_get_mls(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_context_t *arg1 = (semanage_context_t *) 0 ; +- char *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_context_get_mls",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (char *)semanage_context_get_mls((semanage_context_t const *)arg1); +- +- resultobj = SWIG_FromCharPtr(result); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_context_get_mls",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_context, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_context_get_mls" "', argument " "1"" of type '" "semanage_context_t const *""'"); ++ } ++ arg1 = (semanage_context_t *)(argp1); ++ result = (char *)semanage_context_get_mls((struct semanage_context const *)arg1); ++ resultobj = SWIG_FromCharPtr(result); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_context_set_mls(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_context_t *arg2 = (semanage_context_t *) 0 ; +- char *arg3 = (char *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_context_set_mls",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- result = (int)semanage_context_set_mls(arg1,arg2,(char const *)arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_context_set_mls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int res3 ; ++ char *buf3 = 0 ; ++ int alloc3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_context_set_mls" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_context, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_context_set_mls" "', argument " "2"" of type '" "semanage_context_t *""'"); ++ } ++ arg2 = (semanage_context_t *)(argp2); ++ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_context_set_mls" "', argument " "3"" of type '" "char const *""'"); ++ } ++ arg3 = buf3; ++ result = (int)semanage_context_set_mls(arg1,arg2,(char const *)arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return resultobj; ++fail: ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_context_create(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_context_t **arg2 = (semanage_context_t **) 0 ; +- int result; +- semanage_context_t *temp2 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; +- } +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_context_create",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_context_create(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_semanage_context, 0)); +- } +- return resultobj; +- fail: +- return NULL; +-} +- ++SWIGINTERN PyObject *_wrap_semanage_context_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_context_create",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_context_create" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_context_create(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_semanage_context, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; ++} + +-static PyObject *_wrap_semanage_context_clone(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_context_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_context_clone",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_context_clone(arg1,(semanage_context_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_context, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++ ++SWIGINTERN PyObject *_wrap_semanage_context_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_context_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_context_clone",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_context_clone" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_context, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_context_clone" "', argument " "2"" of type '" "semanage_context_t const *""'"); ++ } ++ arg2 = (semanage_context_t *)(argp2); ++ result = (int)semanage_context_clone(arg1,(struct semanage_context const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_context, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_context_free(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_context_t *arg1 = (semanage_context_t *) 0 ; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_context_free",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- semanage_context_free(arg1); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_context_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_context_t *arg1 = (semanage_context_t *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_context_free",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_context, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_context_free" "', argument " "1"" of type '" "semanage_context_t *""'"); ++ } ++ arg1 = (semanage_context_t *)(argp1); ++ semanage_context_free(arg1); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_context_from_string(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- char *arg2 = (char *) 0 ; +- semanage_context_t **arg3 = (semanage_context_t **) 0 ; +- int result; +- semanage_context_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_context_from_string",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { +- SWIG_arg_fail(2);SWIG_fail; +- } +- result = (int)semanage_context_from_string(arg1,(char const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_context, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_context_from_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ char *buf2 = 0 ; ++ int alloc2 = 0 ; ++ semanage_context_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_context_from_string",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_context_from_string" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_context_from_string" "', argument " "2"" of type '" "char const *""'"); ++ } ++ arg2 = buf2; ++ result = (int)semanage_context_from_string(arg1,(char const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_context, 0)); ++ } ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return resultobj; ++fail: ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_context_to_string(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_context_t *arg2 = (semanage_context_t *) 0 ; +- char **arg3 = (char **) 0 ; +- int result; +- char *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_context_to_string",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_context_to_string(arg1,(semanage_context_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_FromCharPtr(*arg3)); +- free(*arg3); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_context_to_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ char *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_context_to_string",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_context_to_string" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_context, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_context_to_string" "', argument " "2"" of type '" "semanage_context_t const *""'"); ++ } ++ arg2 = (semanage_context_t *)(argp2); ++ result = (int)semanage_context_to_string(arg1,(struct semanage_context const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg3)); ++ free(*arg3); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_key_create(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- char *arg2 = (char *) 0 ; +- semanage_bool_key_t **arg3 = (semanage_bool_key_t **) 0 ; +- int result; +- semanage_bool_key_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_key_create",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { +- SWIG_arg_fail(2);SWIG_fail; +- } +- result = (int)semanage_bool_key_create(arg1,(char const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_bool_key, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_key_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ char *buf2 = 0 ; ++ int alloc2 = 0 ; ++ semanage_bool_key_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_key_create",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_key_create" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_bool_key_create" "', argument " "2"" of type '" "char const *""'"); ++ } ++ arg2 = buf2; ++ result = (int)semanage_bool_key_create(arg1,(char const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_bool_key, 0)); ++ } ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return resultobj; ++fail: ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_key_extract(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_bool_key_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_key_extract",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_bool, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_bool_key_extract(arg1,(semanage_bool_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_bool_key, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_key_extract(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_bool_key_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_key_extract",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_key_extract" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_bool, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_bool_key_extract" "', argument " "2"" of type '" "semanage_bool_t const *""'"); ++ } ++ arg2 = (semanage_bool_t *)(argp2); ++ result = (int)semanage_bool_key_extract(arg1,(struct semanage_bool const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_bool_key, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_key_free(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_bool_key_t *arg1 = (semanage_bool_key_t *) 0 ; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_bool_key_free",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_bool_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- semanage_bool_key_free(arg1); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_key_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_bool_key_t *arg1 = (semanage_bool_key_t *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_bool_key_free",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_bool_key, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_key_free" "', argument " "1"" of type '" "semanage_bool_key_t *""'"); ++ } ++ arg1 = (semanage_bool_key_t *)(argp1); ++ semanage_bool_key_free(arg1); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_compare(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_bool_t *arg1 = (semanage_bool_t *) 0 ; +- semanage_bool_key_t *arg2 = (semanage_bool_key_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_compare",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_bool, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_bool_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_bool_compare((semanage_bool_t const *)arg1,(semanage_bool_key_t const *)arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_compare(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_compare",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_bool, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_compare" "', argument " "1"" of type '" "semanage_bool_t const *""'"); ++ } ++ arg1 = (semanage_bool_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_bool_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_bool_compare" "', argument " "2"" of type '" "semanage_bool_key_t const *""'"); ++ } ++ arg2 = (semanage_bool_key_t *)(argp2); ++ result = (int)semanage_bool_compare((struct semanage_bool const *)arg1,(struct semanage_bool_key const *)arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_compare2(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_bool_t *arg1 = (semanage_bool_t *) 0 ; +- semanage_bool_t *arg2 = (semanage_bool_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_compare2",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_bool, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_bool, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_bool_compare2((semanage_bool_t const *)arg1,(semanage_bool_t const *)arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_compare2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_compare2",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_bool, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_compare2" "', argument " "1"" of type '" "semanage_bool_t const *""'"); ++ } ++ arg1 = (semanage_bool_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_bool, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_bool_compare2" "', argument " "2"" of type '" "semanage_bool_t const *""'"); ++ } ++ arg2 = (semanage_bool_t *)(argp2); ++ result = (int)semanage_bool_compare2((struct semanage_bool const *)arg1,(struct semanage_bool const *)arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_get_name(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_bool_t *arg1 = (semanage_bool_t *) 0 ; +- char *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_bool_get_name",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_bool, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (char *)semanage_bool_get_name((semanage_bool_t const *)arg1); +- +- resultobj = SWIG_FromCharPtr(result); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_bool_get_name",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_bool, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_get_name" "', argument " "1"" of type '" "semanage_bool_t const *""'"); ++ } ++ arg1 = (semanage_bool_t *)(argp1); ++ result = (char *)semanage_bool_get_name((struct semanage_bool const *)arg1); ++ resultobj = SWIG_FromCharPtr(result); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_set_name(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_bool_t *arg2 = (semanage_bool_t *) 0 ; +- char *arg3 = (char *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_bool_set_name",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_bool, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- result = (int)semanage_bool_set_name(arg1,arg2,(char const *)arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_set_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int res3 ; ++ char *buf3 = 0 ; ++ int alloc3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_set_name" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_bool, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_bool_set_name" "', argument " "2"" of type '" "semanage_bool_t *""'"); ++ } ++ arg2 = (semanage_bool_t *)(argp2); ++ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_bool_set_name" "', argument " "3"" of type '" "char const *""'"); ++ } ++ arg3 = buf3; ++ result = (int)semanage_bool_set_name(arg1,arg2,(char const *)arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return resultobj; ++fail: ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_get_value(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_bool_t *arg1 = (semanage_bool_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_bool_get_value",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_bool, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_bool_get_value((semanage_bool_t const *)arg1); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_bool_get_value",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_bool, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_get_value" "', argument " "1"" of type '" "semanage_bool_t const *""'"); ++ } ++ arg1 = (semanage_bool_t *)(argp1); ++ result = (int)semanage_bool_get_value((struct semanage_bool const *)arg1); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_set_value(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_bool_t *arg1 = (semanage_bool_t *) 0 ; +- int arg2 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_set_value",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_bool, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- { +- arg2 = (int)(SWIG_As_int(obj1)); +- if (SWIG_arg_fail(2)) SWIG_fail; +- } +- semanage_bool_set_value(arg1,arg2); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_set_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_bool_t *arg1 = (semanage_bool_t *) 0 ; ++ int arg2 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ int val2 ; ++ int ecode2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_set_value",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_bool, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_set_value" "', argument " "1"" of type '" "semanage_bool_t *""'"); ++ } ++ arg1 = (semanage_bool_t *)(argp1); ++ ecode2 = SWIG_AsVal_int(obj1, &val2); ++ if (!SWIG_IsOK(ecode2)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "semanage_bool_set_value" "', argument " "2"" of type '" "int""'"); ++ } ++ arg2 = (int)(val2); ++ semanage_bool_set_value(arg1,arg2); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_create(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_bool_t **arg2 = (semanage_bool_t **) 0 ; +- int result; +- semanage_bool_t *temp2 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; +- } +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_bool_create",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_bool_create(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_semanage_bool, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_bool_create",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_create" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_bool_create(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_semanage_bool, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_clone(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_bool_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_clone",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_bool, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_bool_clone(arg1,(semanage_bool_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_bool, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_bool_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_clone",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_clone" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_bool, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_bool_clone" "', argument " "2"" of type '" "semanage_bool_t const *""'"); ++ } ++ arg2 = (semanage_bool_t *)(argp2); ++ result = (int)semanage_bool_clone(arg1,(struct semanage_bool const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_bool, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_free(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_bool_t *arg1 = (semanage_bool_t *) 0 ; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_bool_free",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_bool, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- semanage_bool_free(arg1); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_bool_t *arg1 = (semanage_bool_t *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_bool_free",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_bool, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_free" "', argument " "1"" of type '" "semanage_bool_t *""'"); ++ } ++ arg1 = (semanage_bool_t *)(argp1); ++ semanage_bool_free(arg1); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_query(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_bool_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_query",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_bool_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_bool_query(arg1,(semanage_bool_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_bool, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_query(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_bool_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_query",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_query" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_bool_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_bool_query" "', argument " "2"" of type '" "semanage_bool_key_t const *""'"); ++ } ++ arg2 = (semanage_bool_key_t *)(argp2); ++ result = (int)semanage_bool_query(arg1,(struct semanage_bool_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_bool, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_exists(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_bool_key_t *arg2 = (semanage_bool_key_t *) 0 ; +- int *arg3 = (int *) 0 ; +- int result; +- int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_exists",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_bool_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_bool_exists(arg1,(semanage_bool_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_exists",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_exists" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_bool_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_bool_exists" "', argument " "2"" of type '" "semanage_bool_key_t const *""'"); ++ } ++ arg2 = (semanage_bool_key_t *)(argp2); ++ result = (int)semanage_bool_exists(arg1,(struct semanage_bool_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res3)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_count(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- unsigned int *arg2 = (unsigned int *) 0 ; +- int result; +- unsigned int temp2 ; +- int res2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; res2 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_bool_count",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_bool_count(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ arg2 = &temp2; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_bool_count",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_count" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_bool_count(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res2)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_iterate(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_bool_iterate",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_q_const__struct_semanage_bool_p_void__int, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- { +- if ((SWIG_ConvertPtr(obj2,(void **)(&arg3),0,SWIG_POINTER_EXCEPTION|0))== -1) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- } +- result = (int)semanage_bool_iterate(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_iterate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_iterate" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__struct_semanage_bool_p_void__int); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "semanage_bool_iterate" "', argument " "2"" of type '" "int (*)(semanage_bool_t const *,void *)""'"); ++ } ++ } ++ res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_bool_iterate" "', argument " "3"" of type '" "void *""'"); ++ } ++ result = (int)semanage_bool_iterate(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_list(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_bool_t ***arg2 = (semanage_bool_t ***) 0 ; +- unsigned int *arg3 = (unsigned int *) 0 ; +- int result; +- semanage_bool_t **temp2 ; +- unsigned int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; +- } +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_bool_list",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_bool_list(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- if (resultobj) { +- int value = SWIG_As_int(resultobj); +- if (value >= 0) { +- PyObject* plist = NULL; +- if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_bool, +- (void (*) (void*)) &semanage_bool_free, &plist) < 0) +- resultobj = SWIG_From_int(STATUS_ERR); +- else +- resultobj = t_output_helper(resultobj, plist); +- } +- } ++SWIGINTERN PyObject *_wrap_semanage_bool_list(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ unsigned int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_bool_list",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_list" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_bool_list(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ if (resultobj) { ++ int value; ++ SWIG_AsVal_int(resultobj, &value); ++ if (value >= 0) { ++ PyObject* plist = NULL; ++ if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_bool, ++ (void (*) (void*)) &semanage_bool_free, &plist) < 0) ++ resultobj = SWIG_From_int(STATUS_ERR); ++ else ++ resultobj = SWIG_Python_AppendOutput(resultobj, plist); ++ } + } +- return resultobj; +- fail: +- return NULL; ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_modify_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_bool_modify_local",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_bool_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_semanage_bool, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_bool_modify_local(arg1,(semanage_bool_key_t const *)arg2,(semanage_bool_t const *)arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_modify_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ void *argp3 = 0 ; ++ int res3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_modify_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_bool_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_bool_modify_local" "', argument " "2"" of type '" "semanage_bool_key_t const *""'"); ++ } ++ arg2 = (semanage_bool_key_t *)(argp2); ++ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_semanage_bool, 0 | 0 ); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_bool_modify_local" "', argument " "3"" of type '" "semanage_bool_t const *""'"); ++ } ++ arg3 = (semanage_bool_t *)(argp3); ++ result = (int)semanage_bool_modify_local(arg1,(struct semanage_bool_key const *)arg2,(struct semanage_bool const *)arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_del_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_bool_key_t *arg2 = (semanage_bool_key_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_del_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_bool_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_bool_del_local(arg1,(semanage_bool_key_t const *)arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_del_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_del_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_bool_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_bool_del_local" "', argument " "2"" of type '" "semanage_bool_key_t const *""'"); ++ } ++ arg2 = (semanage_bool_key_t *)(argp2); ++ result = (int)semanage_bool_del_local(arg1,(struct semanage_bool_key const *)arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_query_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_bool_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_query_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_bool_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_bool_query_local(arg1,(semanage_bool_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_bool, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_query_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_bool_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_query_local",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_query_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_bool_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_bool_query_local" "', argument " "2"" of type '" "semanage_bool_key_t const *""'"); ++ } ++ arg2 = (semanage_bool_key_t *)(argp2); ++ result = (int)semanage_bool_query_local(arg1,(struct semanage_bool_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_bool, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_exists_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_bool_key_t *arg2 = (semanage_bool_key_t *) 0 ; +- int *arg3 = (int *) 0 ; +- int result; +- int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_exists_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_bool_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_bool_exists_local(arg1,(semanage_bool_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_exists_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_exists_local",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_exists_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_bool_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_bool_exists_local" "', argument " "2"" of type '" "semanage_bool_key_t const *""'"); ++ } ++ arg2 = (semanage_bool_key_t *)(argp2); ++ result = (int)semanage_bool_exists_local(arg1,(struct semanage_bool_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res3)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_count_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- unsigned int *arg2 = (unsigned int *) 0 ; +- int result; +- unsigned int temp2 ; +- int res2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; res2 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_bool_count_local",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_bool_count_local(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_count_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ arg2 = &temp2; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_bool_count_local",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_count_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_bool_count_local(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res2)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_iterate_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_bool_iterate_local",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_q_const__struct_semanage_bool_p_void__int, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- { +- if ((SWIG_ConvertPtr(obj2,(void **)(&arg3),0,SWIG_POINTER_EXCEPTION|0))== -1) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- } +- result = (int)semanage_bool_iterate_local(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_iterate_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_iterate_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__struct_semanage_bool_p_void__int); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "semanage_bool_iterate_local" "', argument " "2"" of type '" "int (*)(semanage_bool_t const *,void *)""'"); ++ } ++ } ++ res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_bool_iterate_local" "', argument " "3"" of type '" "void *""'"); ++ } ++ result = (int)semanage_bool_iterate_local(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_list_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_bool_t ***arg2 = (semanage_bool_t ***) 0 ; +- unsigned int *arg3 = (unsigned int *) 0 ; +- int result; +- semanage_bool_t **temp2 ; +- unsigned int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; +- } +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_bool_list_local",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_bool_list_local(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- if (resultobj) { +- int value = SWIG_As_int(resultobj); +- if (value >= 0) { +- PyObject* plist = NULL; +- if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_bool, +- (void (*) (void*)) &semanage_bool_free, &plist) < 0) +- resultobj = SWIG_From_int(STATUS_ERR); +- else +- resultobj = t_output_helper(resultobj, plist); +- } +- } ++SWIGINTERN PyObject *_wrap_semanage_bool_list_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ unsigned int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_bool_list_local",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_list_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_bool_list_local(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ if (resultobj) { ++ int value; ++ SWIG_AsVal_int(resultobj, &value); ++ if (value >= 0) { ++ PyObject* plist = NULL; ++ if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_bool, ++ (void (*) (void*)) &semanage_bool_free, &plist) < 0) ++ resultobj = SWIG_From_int(STATUS_ERR); ++ else ++ resultobj = SWIG_Python_AppendOutput(resultobj, plist); ++ } + } +- return resultobj; +- fail: +- return NULL; ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_set_active(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_bool_set_active",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_bool_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_semanage_bool, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_bool_set_active(arg1,(semanage_bool_key_t const *)arg2,(semanage_bool_t const *)arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_set_active(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ void *argp3 = 0 ; ++ int res3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_set_active" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_bool_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_bool_set_active" "', argument " "2"" of type '" "semanage_bool_key_t const *""'"); ++ } ++ arg2 = (semanage_bool_key_t *)(argp2); ++ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_semanage_bool, 0 | 0 ); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_bool_set_active" "', argument " "3"" of type '" "semanage_bool_t const *""'"); ++ } ++ arg3 = (semanage_bool_t *)(argp3); ++ result = (int)semanage_bool_set_active(arg1,(struct semanage_bool_key const *)arg2,(struct semanage_bool const *)arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_query_active(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_bool_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_query_active",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_bool_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_bool_query_active(arg1,(semanage_bool_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_bool, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_query_active(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_bool_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_query_active",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_query_active" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_bool_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_bool_query_active" "', argument " "2"" of type '" "semanage_bool_key_t const *""'"); ++ } ++ arg2 = (semanage_bool_key_t *)(argp2); ++ result = (int)semanage_bool_query_active(arg1,(struct semanage_bool_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_bool, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_exists_active(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_bool_key_t *arg2 = (semanage_bool_key_t *) 0 ; +- int *arg3 = (int *) 0 ; +- int result; +- int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_exists_active",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_bool_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_bool_exists_active(arg1,(semanage_bool_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_exists_active(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_exists_active",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_exists_active" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_bool_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_bool_exists_active" "', argument " "2"" of type '" "semanage_bool_key_t const *""'"); ++ } ++ arg2 = (semanage_bool_key_t *)(argp2); ++ result = (int)semanage_bool_exists_active(arg1,(struct semanage_bool_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res3)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_count_active(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- unsigned int *arg2 = (unsigned int *) 0 ; +- int result; +- unsigned int temp2 ; +- int res2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; res2 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_bool_count_active",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_bool_count_active(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_count_active(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ arg2 = &temp2; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_bool_count_active",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_count_active" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_bool_count_active(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res2)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_iterate_active(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_bool_iterate_active",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_q_const__struct_semanage_bool_p_void__int, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- { +- if ((SWIG_ConvertPtr(obj2,(void **)(&arg3),0,SWIG_POINTER_EXCEPTION|0))== -1) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- } +- result = (int)semanage_bool_iterate_active(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_bool_iterate_active(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_iterate_active" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__struct_semanage_bool_p_void__int); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "semanage_bool_iterate_active" "', argument " "2"" of type '" "int (*)(semanage_bool_t const *,void *)""'"); ++ } ++ } ++ res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_bool_iterate_active" "', argument " "3"" of type '" "void *""'"); ++ } ++ result = (int)semanage_bool_iterate_active(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_bool_list_active(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_bool_t ***arg2 = (semanage_bool_t ***) 0 ; +- unsigned int *arg3 = (unsigned int *) 0 ; +- int result; +- semanage_bool_t **temp2 ; +- unsigned int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; +- } +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_bool_list_active",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_bool_list_active(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- if (resultobj) { +- int value = SWIG_As_int(resultobj); +- if (value >= 0) { +- PyObject* plist = NULL; +- if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_bool, +- (void (*) (void*)) &semanage_bool_free, &plist) < 0) +- resultobj = SWIG_From_int(STATUS_ERR); +- else +- resultobj = t_output_helper(resultobj, plist); +- } +- } ++SWIGINTERN PyObject *_wrap_semanage_bool_list_active(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ unsigned int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_bool_list_active",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_bool_list_active" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_bool_list_active(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ if (resultobj) { ++ int value; ++ SWIG_AsVal_int(resultobj, &value); ++ if (value >= 0) { ++ PyObject* plist = NULL; ++ if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_bool, ++ (void (*) (void*)) &semanage_bool_free, &plist) < 0) ++ resultobj = SWIG_From_int(STATUS_ERR); ++ else ++ resultobj = SWIG_Python_AppendOutput(resultobj, plist); ++ } + } +- return resultobj; +- fail: +- return NULL; ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_compare(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; +- semanage_iface_key_t *arg2 = (semanage_iface_key_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_compare",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_iface_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_iface_compare((semanage_iface_t const *)arg1,(semanage_iface_key_t const *)arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_iface_compare(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_compare",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_iface, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_compare" "', argument " "1"" of type '" "semanage_iface_t const *""'"); ++ } ++ arg1 = (semanage_iface_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_iface_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_iface_compare" "', argument " "2"" of type '" "semanage_iface_key_t const *""'"); ++ } ++ arg2 = (semanage_iface_key_t *)(argp2); ++ result = (int)semanage_iface_compare((struct semanage_iface const *)arg1,(struct semanage_iface_key const *)arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_compare2(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; +- semanage_iface_t *arg2 = (semanage_iface_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_compare2",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_iface_compare2((semanage_iface_t const *)arg1,(semanage_iface_t const *)arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_iface_compare2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_compare2",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_iface, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_compare2" "', argument " "1"" of type '" "semanage_iface_t const *""'"); ++ } ++ arg1 = (semanage_iface_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_iface, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_iface_compare2" "', argument " "2"" of type '" "semanage_iface_t const *""'"); ++ } ++ arg2 = (semanage_iface_t *)(argp2); ++ result = (int)semanage_iface_compare2((struct semanage_iface const *)arg1,(struct semanage_iface const *)arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_key_create(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- char *arg2 = (char *) 0 ; +- semanage_iface_key_t **arg3 = (semanage_iface_key_t **) 0 ; +- int result; +- semanage_iface_key_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_key_create",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { +- SWIG_arg_fail(2);SWIG_fail; +- } +- result = (int)semanage_iface_key_create(arg1,(char const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_iface_key, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_iface_key_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ char *buf2 = 0 ; ++ int alloc2 = 0 ; ++ semanage_iface_key_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_key_create",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_key_create" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_iface_key_create" "', argument " "2"" of type '" "char const *""'"); ++ } ++ arg2 = buf2; ++ result = (int)semanage_iface_key_create(arg1,(char const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_iface_key, 0)); ++ } ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return resultobj; ++fail: ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_key_extract(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_iface_key_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_key_extract",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_iface_key_extract(arg1,(semanage_iface_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_iface_key, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_iface_key_extract(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_iface_key_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_key_extract",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_key_extract" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_iface, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_iface_key_extract" "', argument " "2"" of type '" "semanage_iface_t const *""'"); ++ } ++ arg2 = (semanage_iface_t *)(argp2); ++ result = (int)semanage_iface_key_extract(arg1,(struct semanage_iface const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_iface_key, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_key_free(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_iface_key_t *arg1 = (semanage_iface_key_t *) 0 ; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_iface_key_free",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_iface_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- semanage_iface_key_free(arg1); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_iface_key_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_iface_key_t *arg1 = (semanage_iface_key_t *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_iface_key_free",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_iface_key, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_key_free" "', argument " "1"" of type '" "semanage_iface_key_t *""'"); ++ } ++ arg1 = (semanage_iface_key_t *)(argp1); ++ semanage_iface_key_free(arg1); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_get_name(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; +- char *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_iface_get_name",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (char *)semanage_iface_get_name((semanage_iface_t const *)arg1); +- +- resultobj = SWIG_FromCharPtr(result); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_iface_get_name",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_iface, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_get_name" "', argument " "1"" of type '" "semanage_iface_t const *""'"); ++ } ++ arg1 = (semanage_iface_t *)(argp1); ++ result = (char *)semanage_iface_get_name((struct semanage_iface const *)arg1); ++ resultobj = SWIG_FromCharPtr(result); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_set_name(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_iface_t *arg2 = (semanage_iface_t *) 0 ; +- char *arg3 = (char *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_set_name",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- result = (int)semanage_iface_set_name(arg1,arg2,(char const *)arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_iface_set_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int res3 ; ++ char *buf3 = 0 ; ++ int alloc3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_set_name" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_iface, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_iface_set_name" "', argument " "2"" of type '" "semanage_iface_t *""'"); ++ } ++ arg2 = (semanage_iface_t *)(argp2); ++ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_iface_set_name" "', argument " "3"" of type '" "char const *""'"); ++ } ++ arg3 = buf3; ++ result = (int)semanage_iface_set_name(arg1,arg2,(char const *)arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return resultobj; ++fail: ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_get_ifcon(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; +- semanage_context_t *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_iface_get_ifcon",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (semanage_context_t *)semanage_iface_get_ifcon((semanage_iface_t const *)arg1); +- +- resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_semanage_context, 0); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_iface_get_ifcon",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_iface, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_get_ifcon" "', argument " "1"" of type '" "semanage_iface_t const *""'"); ++ } ++ arg1 = (semanage_iface_t *)(argp1); ++ result = (semanage_context_t *)semanage_iface_get_ifcon((struct semanage_iface const *)arg1); ++ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_semanage_context, 0 | 0 ); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_set_ifcon(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_set_ifcon",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_iface_set_ifcon(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_iface_set_ifcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ void *argp3 = 0 ; ++ int res3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_set_ifcon" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_iface, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_iface_set_ifcon" "', argument " "2"" of type '" "semanage_iface_t *""'"); ++ } ++ arg2 = (semanage_iface_t *)(argp2); ++ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_semanage_context, 0 | 0 ); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_iface_set_ifcon" "', argument " "3"" of type '" "semanage_context_t *""'"); ++ } ++ arg3 = (semanage_context_t *)(argp3); ++ result = (int)semanage_iface_set_ifcon(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_get_msgcon(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; +- semanage_context_t *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_iface_get_msgcon",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (semanage_context_t *)semanage_iface_get_msgcon((semanage_iface_t const *)arg1); +- +- resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_semanage_context, 0); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_iface_get_msgcon",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_iface, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_get_msgcon" "', argument " "1"" of type '" "semanage_iface_t const *""'"); ++ } ++ arg1 = (semanage_iface_t *)(argp1); ++ result = (semanage_context_t *)semanage_iface_get_msgcon((struct semanage_iface const *)arg1); ++ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_semanage_context, 0 | 0 ); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_set_msgcon(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_set_msgcon",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_iface_set_msgcon(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_iface_set_msgcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ void *argp3 = 0 ; ++ int res3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_set_msgcon" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_iface, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_iface_set_msgcon" "', argument " "2"" of type '" "semanage_iface_t *""'"); ++ } ++ arg2 = (semanage_iface_t *)(argp2); ++ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_semanage_context, 0 | 0 ); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_iface_set_msgcon" "', argument " "3"" of type '" "semanage_context_t *""'"); ++ } ++ arg3 = (semanage_context_t *)(argp3); ++ result = (int)semanage_iface_set_msgcon(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_create(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_iface_t **arg2 = (semanage_iface_t **) 0 ; +- int result; +- semanage_iface_t *temp2 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; +- } +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_iface_create",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_iface_create(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_semanage_iface, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_iface_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_iface_create",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_create" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_iface_create(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_semanage_iface, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_clone(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_iface_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_clone",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_iface_clone(arg1,(semanage_iface_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_iface, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_iface_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_iface_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_clone",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_clone" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_iface, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_iface_clone" "', argument " "2"" of type '" "semanage_iface_t const *""'"); ++ } ++ arg2 = (semanage_iface_t *)(argp2); ++ result = (int)semanage_iface_clone(arg1,(struct semanage_iface const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_iface, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_free(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_iface_free",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- semanage_iface_free(arg1); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_iface_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_iface_free",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_iface, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_free" "', argument " "1"" of type '" "semanage_iface_t *""'"); ++ } ++ arg1 = (semanage_iface_t *)(argp1); ++ semanage_iface_free(arg1); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_modify_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_modify_local",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_iface_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_iface_modify_local(arg1,(semanage_iface_key_t const *)arg2,(semanage_iface_t const *)arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_iface_modify_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ void *argp3 = 0 ; ++ int res3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_modify_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_iface_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_iface_modify_local" "', argument " "2"" of type '" "semanage_iface_key_t const *""'"); ++ } ++ arg2 = (semanage_iface_key_t *)(argp2); ++ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_semanage_iface, 0 | 0 ); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_iface_modify_local" "', argument " "3"" of type '" "semanage_iface_t const *""'"); ++ } ++ arg3 = (semanage_iface_t *)(argp3); ++ result = (int)semanage_iface_modify_local(arg1,(struct semanage_iface_key const *)arg2,(struct semanage_iface const *)arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_del_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_iface_key_t *arg2 = (semanage_iface_key_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_del_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_iface_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_iface_del_local(arg1,(semanage_iface_key_t const *)arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_iface_del_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_del_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_iface_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_iface_del_local" "', argument " "2"" of type '" "semanage_iface_key_t const *""'"); ++ } ++ arg2 = (semanage_iface_key_t *)(argp2); ++ result = (int)semanage_iface_del_local(arg1,(struct semanage_iface_key const *)arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_query_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_iface_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_query_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_iface_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_iface_query_local(arg1,(semanage_iface_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_iface, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_iface_query_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_iface_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_query_local",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_query_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_iface_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_iface_query_local" "', argument " "2"" of type '" "semanage_iface_key_t const *""'"); ++ } ++ arg2 = (semanage_iface_key_t *)(argp2); ++ result = (int)semanage_iface_query_local(arg1,(struct semanage_iface_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_iface, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_exists_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_iface_key_t *arg2 = (semanage_iface_key_t *) 0 ; +- int *arg3 = (int *) 0 ; +- int result; +- int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_exists_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_iface_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_iface_exists_local(arg1,(semanage_iface_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_iface_exists_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_exists_local",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_exists_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_iface_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_iface_exists_local" "', argument " "2"" of type '" "semanage_iface_key_t const *""'"); ++ } ++ arg2 = (semanage_iface_key_t *)(argp2); ++ result = (int)semanage_iface_exists_local(arg1,(struct semanage_iface_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res3)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_count_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- unsigned int *arg2 = (unsigned int *) 0 ; +- int result; +- unsigned int temp2 ; +- int res2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; res2 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_iface_count_local",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_iface_count_local(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_iface_count_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ arg2 = &temp2; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_iface_count_local",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_count_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_iface_count_local(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res2)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_iterate_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_iterate_local",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_q_const__struct_semanage_iface_p_void__int, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- { +- if ((SWIG_ConvertPtr(obj2,(void **)(&arg3),0,SWIG_POINTER_EXCEPTION|0))== -1) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- } +- result = (int)semanage_iface_iterate_local(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_iface_iterate_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_iterate_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__struct_semanage_iface_p_void__int); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "semanage_iface_iterate_local" "', argument " "2"" of type '" "int (*)(semanage_iface_t const *,void *)""'"); ++ } ++ } ++ res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_iface_iterate_local" "', argument " "3"" of type '" "void *""'"); ++ } ++ result = (int)semanage_iface_iterate_local(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_list_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_iface_t ***arg2 = (semanage_iface_t ***) 0 ; +- unsigned int *arg3 = (unsigned int *) 0 ; +- int result; +- semanage_iface_t **temp2 ; +- unsigned int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; ++SWIGINTERN PyObject *_wrap_semanage_iface_list_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ unsigned int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_iface_list_local",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_list_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_iface_list_local(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ if (resultobj) { ++ int value; ++ SWIG_AsVal_int(resultobj, &value); ++ if (value >= 0) { ++ PyObject* plist = NULL; ++ if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_iface, ++ (void (*) (void*)) &semanage_iface_free, &plist) < 0) ++ resultobj = SWIG_From_int(STATUS_ERR); ++ else ++ resultobj = SWIG_Python_AppendOutput(resultobj, plist); ++ } + } +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_iface_list_local",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_iface_list_local(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- if (resultobj) { +- int value = SWIG_As_int(resultobj); +- if (value >= 0) { +- PyObject* plist = NULL; +- if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_iface, +- (void (*) (void*)) &semanage_iface_free, &plist) < 0) +- resultobj = SWIG_From_int(STATUS_ERR); +- else +- resultobj = t_output_helper(resultobj, plist); +- } +- } +- } +- return resultobj; +- fail: +- return NULL; ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_query(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_iface_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_query",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_iface_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_iface_query(arg1,(semanage_iface_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_iface, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_iface_query(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_iface_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_query",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_query" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_iface_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_iface_query" "', argument " "2"" of type '" "semanage_iface_key_t const *""'"); ++ } ++ arg2 = (semanage_iface_key_t *)(argp2); ++ result = (int)semanage_iface_query(arg1,(struct semanage_iface_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_iface, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_exists(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_iface_key_t *arg2 = (semanage_iface_key_t *) 0 ; +- int *arg3 = (int *) 0 ; +- int result; +- int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_exists",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_iface_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_iface_exists(arg1,(semanage_iface_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_iface_exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_exists",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_exists" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_iface_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_iface_exists" "', argument " "2"" of type '" "semanage_iface_key_t const *""'"); ++ } ++ arg2 = (semanage_iface_key_t *)(argp2); ++ result = (int)semanage_iface_exists(arg1,(struct semanage_iface_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res3)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_count(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- unsigned int *arg2 = (unsigned int *) 0 ; +- int result; +- unsigned int temp2 ; +- int res2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; res2 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_iface_count",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_iface_count(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_iface_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ arg2 = &temp2; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_iface_count",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_count" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_iface_count(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res2)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_iterate(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_iterate",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_q_const__struct_semanage_iface_p_void__int, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- { +- if ((SWIG_ConvertPtr(obj2,(void **)(&arg3),0,SWIG_POINTER_EXCEPTION|0))== -1) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- } +- result = (int)semanage_iface_iterate(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_iface_iterate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_iterate" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__struct_semanage_iface_p_void__int); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "semanage_iface_iterate" "', argument " "2"" of type '" "int (*)(semanage_iface_t const *,void *)""'"); ++ } ++ } ++ res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_iface_iterate" "', argument " "3"" of type '" "void *""'"); ++ } ++ result = (int)semanage_iface_iterate(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_iface_list(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_iface_t ***arg2 = (semanage_iface_t ***) 0 ; +- unsigned int *arg3 = (unsigned int *) 0 ; +- int result; +- semanage_iface_t **temp2 ; +- unsigned int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; +- } +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_iface_list",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_iface_list(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- if (resultobj) { +- int value = SWIG_As_int(resultobj); +- if (value >= 0) { +- PyObject* plist = NULL; +- if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_iface, +- (void (*) (void*)) &semanage_iface_free, &plist) < 0) +- resultobj = SWIG_From_int(STATUS_ERR); +- else +- resultobj = t_output_helper(resultobj, plist); +- } +- } ++SWIGINTERN PyObject *_wrap_semanage_iface_list(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ unsigned int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_iface_list",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_iface_list" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_iface_list(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ if (resultobj) { ++ int value; ++ SWIG_AsVal_int(resultobj, &value); ++ if (value >= 0) { ++ PyObject* plist = NULL; ++ if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_iface, ++ (void (*) (void*)) &semanage_iface_free, &plist) < 0) ++ resultobj = SWIG_From_int(STATUS_ERR); ++ else ++ resultobj = SWIG_Python_AppendOutput(resultobj, plist); ++ } + } +- return resultobj; +- fail: +- return NULL; ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_key_create(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- char *arg2 = (char *) 0 ; +- semanage_user_key_t **arg3 = (semanage_user_key_t **) 0 ; +- int result; +- semanage_user_key_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_user_key_create",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { +- SWIG_arg_fail(2);SWIG_fail; +- } +- result = (int)semanage_user_key_create(arg1,(char const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_user_key, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_key_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ char *buf2 = 0 ; ++ int alloc2 = 0 ; ++ semanage_user_key_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_user_key_create",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_key_create" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_user_key_create" "', argument " "2"" of type '" "char const *""'"); ++ } ++ arg2 = buf2; ++ result = (int)semanage_user_key_create(arg1,(char const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_user_key, 0)); ++ } ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return resultobj; ++fail: ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_key_extract(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_user_key_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_user_key_extract",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_user_key_extract(arg1,(semanage_user_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_user_key, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_key_extract(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_user_key_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_user_key_extract",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_key_extract" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_user, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_user_key_extract" "', argument " "2"" of type '" "semanage_user_t const *""'"); ++ } ++ arg2 = (semanage_user_t *)(argp2); ++ result = (int)semanage_user_key_extract(arg1,(struct semanage_user const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_user_key, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_key_free(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_user_key_t *arg1 = (semanage_user_key_t *) 0 ; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_user_key_free",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_user_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- semanage_user_key_free(arg1); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_key_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_user_key_t *arg1 = (semanage_user_key_t *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_user_key_free",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_user_key, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_key_free" "', argument " "1"" of type '" "semanage_user_key_t *""'"); ++ } ++ arg1 = (semanage_user_key_t *)(argp1); ++ semanage_user_key_free(arg1); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_compare(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_user_t *arg1 = (semanage_user_t *) 0 ; +- semanage_user_key_t *arg2 = (semanage_user_key_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_user_compare",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_user_compare((semanage_user_t const *)arg1,(semanage_user_key_t const *)arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_compare(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_user_compare",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_user, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_compare" "', argument " "1"" of type '" "semanage_user_t const *""'"); ++ } ++ arg1 = (semanage_user_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_user_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_user_compare" "', argument " "2"" of type '" "semanage_user_key_t const *""'"); ++ } ++ arg2 = (semanage_user_key_t *)(argp2); ++ result = (int)semanage_user_compare((struct semanage_user const *)arg1,(struct semanage_user_key const *)arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_compare2(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_user_t *arg1 = (semanage_user_t *) 0 ; +- semanage_user_t *arg2 = (semanage_user_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_user_compare2",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_user_compare2((semanage_user_t const *)arg1,(semanage_user_t const *)arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_compare2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_user_compare2",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_user, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_compare2" "', argument " "1"" of type '" "semanage_user_t const *""'"); ++ } ++ arg1 = (semanage_user_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_user, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_user_compare2" "', argument " "2"" of type '" "semanage_user_t const *""'"); ++ } ++ arg2 = (semanage_user_t *)(argp2); ++ result = (int)semanage_user_compare2((struct semanage_user const *)arg1,(struct semanage_user const *)arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_get_name(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_user_t *arg1 = (semanage_user_t *) 0 ; +- char *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_user_get_name",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (char *)semanage_user_get_name((semanage_user_t const *)arg1); +- +- resultobj = SWIG_FromCharPtr(result); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_user_get_name",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_user, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_get_name" "', argument " "1"" of type '" "semanage_user_t const *""'"); ++ } ++ arg1 = (semanage_user_t *)(argp1); ++ result = (char *)semanage_user_get_name((struct semanage_user const *)arg1); ++ resultobj = SWIG_FromCharPtr(result); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_set_name(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_user_t *arg2 = (semanage_user_t *) 0 ; +- char *arg3 = (char *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_set_name",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- result = (int)semanage_user_set_name(arg1,arg2,(char const *)arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_set_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int res3 ; ++ char *buf3 = 0 ; ++ int alloc3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_set_name" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_user, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_user_set_name" "', argument " "2"" of type '" "semanage_user_t *""'"); ++ } ++ arg2 = (semanage_user_t *)(argp2); ++ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_user_set_name" "', argument " "3"" of type '" "char const *""'"); ++ } ++ arg3 = buf3; ++ result = (int)semanage_user_set_name(arg1,arg2,(char const *)arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return resultobj; ++fail: ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_get_prefix(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_user_t *arg1 = (semanage_user_t *) 0 ; +- char *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_user_get_prefix",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (char *)semanage_user_get_prefix((semanage_user_t const *)arg1); +- +- resultobj = SWIG_FromCharPtr(result); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_user_get_prefix",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_user, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_get_prefix" "', argument " "1"" of type '" "semanage_user_t const *""'"); ++ } ++ arg1 = (semanage_user_t *)(argp1); ++ result = (char *)semanage_user_get_prefix((struct semanage_user const *)arg1); ++ resultobj = SWIG_FromCharPtr(result); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_set_prefix(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_user_t *arg2 = (semanage_user_t *) 0 ; +- char *arg3 = (char *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_set_prefix",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- result = (int)semanage_user_set_prefix(arg1,arg2,(char const *)arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_set_prefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int res3 ; ++ char *buf3 = 0 ; ++ int alloc3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_set_prefix" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_user, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_user_set_prefix" "', argument " "2"" of type '" "semanage_user_t *""'"); ++ } ++ arg2 = (semanage_user_t *)(argp2); ++ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_user_set_prefix" "', argument " "3"" of type '" "char const *""'"); ++ } ++ arg3 = buf3; ++ result = (int)semanage_user_set_prefix(arg1,arg2,(char const *)arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return resultobj; ++fail: ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_get_mlslevel(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_user_t *arg1 = (semanage_user_t *) 0 ; +- char *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_user_get_mlslevel",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (char *)semanage_user_get_mlslevel((semanage_user_t const *)arg1); +- +- resultobj = SWIG_FromCharPtr(result); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_user_get_mlslevel",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_user, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_get_mlslevel" "', argument " "1"" of type '" "semanage_user_t const *""'"); ++ } ++ arg1 = (semanage_user_t *)(argp1); ++ result = (char *)semanage_user_get_mlslevel((struct semanage_user const *)arg1); ++ resultobj = SWIG_FromCharPtr(result); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_set_mlslevel(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_user_t *arg2 = (semanage_user_t *) 0 ; +- char *arg3 = (char *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_set_mlslevel",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- result = (int)semanage_user_set_mlslevel(arg1,arg2,(char const *)arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_set_mlslevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int res3 ; ++ char *buf3 = 0 ; ++ int alloc3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_set_mlslevel" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_user, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_user_set_mlslevel" "', argument " "2"" of type '" "semanage_user_t *""'"); ++ } ++ arg2 = (semanage_user_t *)(argp2); ++ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_user_set_mlslevel" "', argument " "3"" of type '" "char const *""'"); ++ } ++ arg3 = buf3; ++ result = (int)semanage_user_set_mlslevel(arg1,arg2,(char const *)arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return resultobj; ++fail: ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_get_mlsrange(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_user_t *arg1 = (semanage_user_t *) 0 ; +- char *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_user_get_mlsrange",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (char *)semanage_user_get_mlsrange((semanage_user_t const *)arg1); +- +- resultobj = SWIG_FromCharPtr(result); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_user_get_mlsrange",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_user, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_get_mlsrange" "', argument " "1"" of type '" "semanage_user_t const *""'"); ++ } ++ arg1 = (semanage_user_t *)(argp1); ++ result = (char *)semanage_user_get_mlsrange((struct semanage_user const *)arg1); ++ resultobj = SWIG_FromCharPtr(result); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_set_mlsrange(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_user_t *arg2 = (semanage_user_t *) 0 ; +- char *arg3 = (char *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_set_mlsrange",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- result = (int)semanage_user_set_mlsrange(arg1,arg2,(char const *)arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_set_mlsrange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int res3 ; ++ char *buf3 = 0 ; ++ int alloc3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_set_mlsrange" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_user, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_user_set_mlsrange" "', argument " "2"" of type '" "semanage_user_t *""'"); ++ } ++ arg2 = (semanage_user_t *)(argp2); ++ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_user_set_mlsrange" "', argument " "3"" of type '" "char const *""'"); ++ } ++ arg3 = buf3; ++ result = (int)semanage_user_set_mlsrange(arg1,arg2,(char const *)arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return resultobj; ++fail: ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_get_num_roles(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_user_t *arg1 = (semanage_user_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_user_get_num_roles",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_user_get_num_roles((semanage_user_t const *)arg1); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_get_num_roles" "', argument " "1"" of type '" "semanage_user_t const *""'"); ++ } ++ arg1 = (semanage_user_t *)(argp1); ++ result = (int)semanage_user_get_num_roles((struct semanage_user const *)arg1); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_add_role(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_user_t *arg2 = (semanage_user_t *) 0 ; +- char *arg3 = (char *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_add_role",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- result = (int)semanage_user_add_role(arg1,arg2,(char const *)arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_add_role(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int res3 ; ++ char *buf3 = 0 ; ++ int alloc3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_add_role" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_user, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_user_add_role" "', argument " "2"" of type '" "semanage_user_t *""'"); ++ } ++ arg2 = (semanage_user_t *)(argp2); ++ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_user_add_role" "', argument " "3"" of type '" "char const *""'"); ++ } ++ arg3 = buf3; ++ result = (int)semanage_user_add_role(arg1,arg2,(char const *)arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return resultobj; ++fail: ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_del_role(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_user_t *arg1 = (semanage_user_t *) 0 ; +- char *arg2 = (char *) 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_user_del_role",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { +- SWIG_arg_fail(2);SWIG_fail; +- } +- semanage_user_del_role(arg1,(char const *)arg2); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_del_role(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_user_t *arg1 = (semanage_user_t *) 0 ; ++ char *arg2 = (char *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ int res2 ; ++ char *buf2 = 0 ; ++ int alloc2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_user_del_role",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_user, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_del_role" "', argument " "1"" of type '" "semanage_user_t *""'"); ++ } ++ arg1 = (semanage_user_t *)(argp1); ++ res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_user_del_role" "', argument " "2"" of type '" "char const *""'"); ++ } ++ arg2 = buf2; ++ semanage_user_del_role(arg1,(char const *)arg2); ++ resultobj = SWIG_Py_Void(); ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return resultobj; ++fail: ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_has_role(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_user_t *arg1 = (semanage_user_t *) 0 ; +- char *arg2 = (char *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_user_has_role",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { +- SWIG_arg_fail(2);SWIG_fail; +- } +- result = (int)semanage_user_has_role((semanage_user_t const *)arg1,(char const *)arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_has_role(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ char *buf2 = 0 ; ++ int alloc2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_has_role" "', argument " "1"" of type '" "semanage_user_t const *""'"); ++ } ++ arg1 = (semanage_user_t *)(argp1); ++ res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_user_has_role" "', argument " "2"" of type '" "char const *""'"); ++ } ++ arg2 = buf2; ++ result = (int)semanage_user_has_role((struct semanage_user const *)arg1,(char const *)arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return resultobj; ++fail: ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_get_roles(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_user_t *arg2 = (semanage_user_t *) 0 ; +- char ***arg3 = (char ***) 0 ; +- unsigned int *arg4 = (unsigned int *) 0 ; +- int result; +- char **temp3 ; +- unsigned int temp4 ; +- int res4 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- arg4 = &temp4; res4 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_user_get_roles",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_user_get_roles(arg1,(semanage_user_t const *)arg2,(char const ***)arg3,arg4); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- if (resultobj) { +- int value = SWIG_As_int(resultobj); +- if (value >= 0) { +- PyObject* plist = NULL; +- if (semanage_array2plist(arg1, (void**) *arg3, *arg4, +- NULL, NULL, &plist) < 0) +- resultobj = SWIG_From_int(STATUS_ERR); +- else +- resultobj = t_output_helper(resultobj, plist); +- } +- } ++SWIGINTERN PyObject *_wrap_semanage_user_get_roles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ 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 ; ++ int res2 = 0 ; ++ char **temp3 ; ++ unsigned int temp4 ; ++ int res4 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ arg4 = &temp4; ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_user_get_roles",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_get_roles" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_user, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_user_get_roles" "', argument " "2"" of type '" "semanage_user_t const *""'"); ++ } ++ arg2 = (semanage_user_t *)(argp2); ++ result = (int)semanage_user_get_roles(arg1,(struct semanage_user const *)arg2,(char const ***)arg3,arg4); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ if (resultobj) { ++ int value; ++ SWIG_AsVal_int(resultobj, &value); ++ if (value >= 0) { ++ PyObject* plist = NULL; ++ if (semanage_array2plist(arg1, (void**) *arg3, *arg4, ++ NULL, NULL, &plist) < 0) ++ resultobj = SWIG_From_int(STATUS_ERR); ++ else ++ resultobj = SWIG_Python_AppendOutput(resultobj, plist); ++ } + } +- return resultobj; +- fail: +- return NULL; ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_set_roles(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_user_t *arg2 = (semanage_user_t *) 0 ; +- char **arg3 = (char **) 0 ; +- unsigned int arg4 ; +- int result; +- char *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_set_roles",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- { +- arg4 = (unsigned int)(SWIG_As_unsigned_SS_int(obj2)); +- if (SWIG_arg_fail(4)) SWIG_fail; +- } +- result = (int)semanage_user_set_roles(arg1,arg2,(char const **)arg3,arg4); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_FromCharPtr(*arg3)); +- free(*arg3); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_set_roles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ 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 ; ++ int res2 = 0 ; ++ char *temp3 ; ++ unsigned int val4 ; ++ int ecode4 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_set_roles",&obj0,&obj1,&obj2)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_set_roles" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_user, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_user_set_roles" "', argument " "2"" of type '" "semanage_user_t *""'"); ++ } ++ arg2 = (semanage_user_t *)(argp2); ++ ecode4 = SWIG_AsVal_unsigned_SS_int(obj2, &val4); ++ if (!SWIG_IsOK(ecode4)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "semanage_user_set_roles" "', argument " "4"" of type '" "unsigned int""'"); ++ } ++ arg4 = (unsigned int)(val4); ++ result = (int)semanage_user_set_roles(arg1,arg2,(char const **)arg3,arg4); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg3)); ++ free(*arg3); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_create(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_user_t **arg2 = (semanage_user_t **) 0 ; +- int result; +- semanage_user_t *temp2 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; +- } +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_user_create",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_user_create(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_semanage_user, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_user_create",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_create" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_user_create(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_semanage_user, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_clone(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_user_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_user_clone",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_user_clone(arg1,(semanage_user_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_user, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_user_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_user_clone",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_clone" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_user, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_user_clone" "', argument " "2"" of type '" "semanage_user_t const *""'"); ++ } ++ arg2 = (semanage_user_t *)(argp2); ++ result = (int)semanage_user_clone(arg1,(struct semanage_user const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_user, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_free(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_user_t *arg1 = (semanage_user_t *) 0 ; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_user_free",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- semanage_user_free(arg1); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_user_t *arg1 = (semanage_user_t *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_user_free",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_user, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_free" "', argument " "1"" of type '" "semanage_user_t *""'"); ++ } ++ arg1 = (semanage_user_t *)(argp1); ++ semanage_user_free(arg1); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_modify_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_modify_local",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_user_modify_local(arg1,(semanage_user_key_t const *)arg2,(semanage_user_t const *)arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_modify_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ void *argp3 = 0 ; ++ int res3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_modify_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_user_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_user_modify_local" "', argument " "2"" of type '" "semanage_user_key_t const *""'"); ++ } ++ arg2 = (semanage_user_key_t *)(argp2); ++ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_semanage_user, 0 | 0 ); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_user_modify_local" "', argument " "3"" of type '" "semanage_user_t const *""'"); ++ } ++ arg3 = (semanage_user_t *)(argp3); ++ result = (int)semanage_user_modify_local(arg1,(struct semanage_user_key const *)arg2,(struct semanage_user const *)arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_del_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_user_key_t *arg2 = (semanage_user_key_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_user_del_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_user_del_local(arg1,(semanage_user_key_t const *)arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_del_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_del_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_user_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_user_del_local" "', argument " "2"" of type '" "semanage_user_key_t const *""'"); ++ } ++ arg2 = (semanage_user_key_t *)(argp2); ++ result = (int)semanage_user_del_local(arg1,(struct semanage_user_key const *)arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_query_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_user_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_user_query_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_user_query_local(arg1,(semanage_user_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_user, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_query_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_user_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_user_query_local",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_query_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_user_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_user_query_local" "', argument " "2"" of type '" "semanage_user_key_t const *""'"); ++ } ++ arg2 = (semanage_user_key_t *)(argp2); ++ result = (int)semanage_user_query_local(arg1,(struct semanage_user_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_user, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_exists_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_user_key_t *arg2 = (semanage_user_key_t *) 0 ; +- int *arg3 = (int *) 0 ; +- int result; +- int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_user_exists_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_user_exists_local(arg1,(semanage_user_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_exists_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_user_exists_local",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_exists_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_user_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_user_exists_local" "', argument " "2"" of type '" "semanage_user_key_t const *""'"); ++ } ++ arg2 = (semanage_user_key_t *)(argp2); ++ result = (int)semanage_user_exists_local(arg1,(struct semanage_user_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res3)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_count_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- unsigned int *arg2 = (unsigned int *) 0 ; +- int result; +- unsigned int temp2 ; +- int res2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; res2 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_user_count_local",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_user_count_local(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_count_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ arg2 = &temp2; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_user_count_local",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_count_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_user_count_local(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res2)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_iterate_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_iterate_local",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_q_const__struct_semanage_user_p_void__int, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- { +- if ((SWIG_ConvertPtr(obj2,(void **)(&arg3),0,SWIG_POINTER_EXCEPTION|0))== -1) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- } +- result = (int)semanage_user_iterate_local(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_iterate_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_iterate_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__struct_semanage_user_p_void__int); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "semanage_user_iterate_local" "', argument " "2"" of type '" "int (*)(semanage_user_t const *,void *)""'"); ++ } ++ } ++ res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_user_iterate_local" "', argument " "3"" of type '" "void *""'"); ++ } ++ result = (int)semanage_user_iterate_local(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_list_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_user_t ***arg2 = (semanage_user_t ***) 0 ; +- unsigned int *arg3 = (unsigned int *) 0 ; +- int result; +- semanage_user_t **temp2 ; +- unsigned int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; +- } +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_user_list_local",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_user_list_local(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- if (resultobj) { +- int value = SWIG_As_int(resultobj); +- if (value >= 0) { +- PyObject* plist = NULL; +- if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_user, +- (void (*) (void*)) &semanage_user_free, &plist) < 0) +- resultobj = SWIG_From_int(STATUS_ERR); +- else +- resultobj = t_output_helper(resultobj, plist); +- } +- } ++SWIGINTERN PyObject *_wrap_semanage_user_list_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ unsigned int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_user_list_local",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_list_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_user_list_local(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ if (resultobj) { ++ int value; ++ SWIG_AsVal_int(resultobj, &value); ++ if (value >= 0) { ++ PyObject* plist = NULL; ++ if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_user, ++ (void (*) (void*)) &semanage_user_free, &plist) < 0) ++ resultobj = SWIG_From_int(STATUS_ERR); ++ else ++ resultobj = SWIG_Python_AppendOutput(resultobj, plist); ++ } + } +- return resultobj; +- fail: +- return NULL; ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_query(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_user_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_user_query",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_user_query(arg1,(semanage_user_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_user, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_query(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_user_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_user_query",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_query" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_user_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_user_query" "', argument " "2"" of type '" "semanage_user_key_t const *""'"); ++ } ++ arg2 = (semanage_user_key_t *)(argp2); ++ result = (int)semanage_user_query(arg1,(struct semanage_user_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_user, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_exists(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_user_key_t *arg2 = (semanage_user_key_t *) 0 ; +- int *arg3 = (int *) 0 ; +- int result; +- int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_user_exists",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_user_exists(arg1,(semanage_user_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_user_exists",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_exists" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_user_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_user_exists" "', argument " "2"" of type '" "semanage_user_key_t const *""'"); ++ } ++ arg2 = (semanage_user_key_t *)(argp2); ++ result = (int)semanage_user_exists(arg1,(struct semanage_user_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res3)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_count(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- unsigned int *arg2 = (unsigned int *) 0 ; +- int result; +- unsigned int temp2 ; +- int res2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; res2 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_user_count",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_user_count(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ arg2 = &temp2; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_user_count",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_count" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_user_count(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res2)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_iterate(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_iterate",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_q_const__struct_semanage_user_p_void__int, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- { +- if ((SWIG_ConvertPtr(obj2,(void **)(&arg3),0,SWIG_POINTER_EXCEPTION|0))== -1) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- } +- result = (int)semanage_user_iterate(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_user_iterate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_iterate" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__struct_semanage_user_p_void__int); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "semanage_user_iterate" "', argument " "2"" of type '" "int (*)(semanage_user_t const *,void *)""'"); ++ } ++ } ++ res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_user_iterate" "', argument " "3"" of type '" "void *""'"); ++ } ++ result = (int)semanage_user_iterate(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_user_list(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_user_t ***arg2 = (semanage_user_t ***) 0 ; +- unsigned int *arg3 = (unsigned int *) 0 ; +- int result; +- semanage_user_t **temp2 ; +- unsigned int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; +- } +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_user_list",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_user_list(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- if (resultobj) { +- int value = SWIG_As_int(resultobj); +- if (value >= 0) { +- PyObject* plist = NULL; +- if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_user, +- (void (*) (void*)) &semanage_user_free, &plist) < 0) +- resultobj = SWIG_From_int(STATUS_ERR); +- else +- resultobj = t_output_helper(resultobj, plist); +- } +- } ++SWIGINTERN PyObject *_wrap_semanage_user_list(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ unsigned int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_user_list",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_user_list" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_user_list(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ if (resultobj) { ++ int value; ++ SWIG_AsVal_int(resultobj, &value); ++ if (value >= 0) { ++ PyObject* plist = NULL; ++ if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_user, ++ (void (*) (void*)) &semanage_user_free, &plist) < 0) ++ resultobj = SWIG_From_int(STATUS_ERR); ++ else ++ resultobj = SWIG_Python_AppendOutput(resultobj, plist); ++ } + } +- return resultobj; +- fail: +- return NULL; ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_compare(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_port_t *arg1 = (semanage_port_t *) 0 ; +- semanage_port_key_t *arg2 = (semanage_port_key_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_port_compare",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_port, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_port_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_port_compare((semanage_port_t const *)arg1,(semanage_port_key_t const *)arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_port_compare(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_port_compare",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_port, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_compare" "', argument " "1"" of type '" "semanage_port_t const *""'"); ++ } ++ arg1 = (semanage_port_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_port_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_port_compare" "', argument " "2"" of type '" "semanage_port_key_t const *""'"); ++ } ++ arg2 = (semanage_port_key_t *)(argp2); ++ result = (int)semanage_port_compare((struct semanage_port const *)arg1,(struct semanage_port_key const *)arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_compare2(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_port_t *arg1 = (semanage_port_t *) 0 ; +- semanage_port_t *arg2 = (semanage_port_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_port_compare2",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_port, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_port, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_port_compare2((semanage_port_t const *)arg1,(semanage_port_t const *)arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_port_compare2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_port_compare2",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_port, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_compare2" "', argument " "1"" of type '" "semanage_port_t const *""'"); ++ } ++ arg1 = (semanage_port_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_port, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_port_compare2" "', argument " "2"" of type '" "semanage_port_t const *""'"); ++ } ++ arg2 = (semanage_port_t *)(argp2); ++ result = (int)semanage_port_compare2((struct semanage_port const *)arg1,(struct semanage_port const *)arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_key_create(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int arg2 ; +- int arg3 ; +- int arg4 ; +- semanage_port_key_t **arg5 = (semanage_port_key_t **) 0 ; +- int result; +- semanage_port_key_t *temp5 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- PyObject * obj3 = 0 ; +- +- { +- arg5 = &temp5; +- } +- if(!PyArg_ParseTuple(args,(char *)"OOOO:semanage_port_key_create",&obj0,&obj1,&obj2,&obj3)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- { +- arg2 = (int)(SWIG_As_int(obj1)); +- if (SWIG_arg_fail(2)) SWIG_fail; +- } +- { +- arg3 = (int)(SWIG_As_int(obj2)); +- if (SWIG_arg_fail(3)) SWIG_fail; +- } +- { +- arg4 = (int)(SWIG_As_int(obj3)); +- if (SWIG_arg_fail(4)) SWIG_fail; +- } +- result = (int)semanage_port_key_create(arg1,arg2,arg3,arg4,arg5); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg5, SWIGTYPE_p_semanage_port_key, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_port_key_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ int arg2 ; ++ int arg3 ; ++ int arg4 ; ++ semanage_port_key_t **arg5 = (semanage_port_key_t **) 0 ; ++ int result; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ int val2 ; ++ int ecode2 = 0 ; ++ int val3 ; ++ int ecode3 = 0 ; ++ int val4 ; ++ int ecode4 = 0 ; ++ semanage_port_key_t *temp5 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ PyObject * obj3 = 0 ; ++ ++ { ++ arg5 = &temp5; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OOOO:semanage_port_key_create",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_key_create" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ ecode2 = SWIG_AsVal_int(obj1, &val2); ++ if (!SWIG_IsOK(ecode2)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "semanage_port_key_create" "', argument " "2"" of type '" "int""'"); ++ } ++ arg2 = (int)(val2); ++ ecode3 = SWIG_AsVal_int(obj2, &val3); ++ if (!SWIG_IsOK(ecode3)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "semanage_port_key_create" "', argument " "3"" of type '" "int""'"); ++ } ++ arg3 = (int)(val3); ++ ecode4 = SWIG_AsVal_int(obj3, &val4); ++ if (!SWIG_IsOK(ecode4)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "semanage_port_key_create" "', argument " "4"" of type '" "int""'"); ++ } ++ arg4 = (int)(val4); ++ result = (int)semanage_port_key_create(arg1,arg2,arg3,arg4,arg5); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg5, SWIGTYPE_p_semanage_port_key, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_key_extract(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_port_key_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_port_key_extract",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_port, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_port_key_extract(arg1,(semanage_port_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_port_key, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_port_key_extract(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_port_key_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_port_key_extract",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_key_extract" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_port, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_port_key_extract" "', argument " "2"" of type '" "semanage_port_t const *""'"); ++ } ++ arg2 = (semanage_port_t *)(argp2); ++ result = (int)semanage_port_key_extract(arg1,(struct semanage_port const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_port_key, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_key_free(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_port_key_t *arg1 = (semanage_port_key_t *) 0 ; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_port_key_free",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_port_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- semanage_port_key_free(arg1); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_port_key_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_port_key_t *arg1 = (semanage_port_key_t *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_port_key_free",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_port_key, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_key_free" "', argument " "1"" of type '" "semanage_port_key_t *""'"); ++ } ++ arg1 = (semanage_port_key_t *)(argp1); ++ semanage_port_key_free(arg1); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_get_proto(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_port_t *arg1 = (semanage_port_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_port_get_proto",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_port, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_port_get_proto((semanage_port_t const *)arg1); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_port_get_proto",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_port, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_get_proto" "', argument " "1"" of type '" "semanage_port_t const *""'"); ++ } ++ arg1 = (semanage_port_t *)(argp1); ++ result = (int)semanage_port_get_proto((struct semanage_port const *)arg1); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_set_proto(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_port_t *arg1 = (semanage_port_t *) 0 ; +- int arg2 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_port_set_proto",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_port, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- { +- arg2 = (int)(SWIG_As_int(obj1)); +- if (SWIG_arg_fail(2)) SWIG_fail; +- } +- semanage_port_set_proto(arg1,arg2); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_port_set_proto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_port_t *arg1 = (semanage_port_t *) 0 ; ++ int arg2 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ int val2 ; ++ int ecode2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_port_set_proto",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_port, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_set_proto" "', argument " "1"" of type '" "semanage_port_t *""'"); ++ } ++ arg1 = (semanage_port_t *)(argp1); ++ ecode2 = SWIG_AsVal_int(obj1, &val2); ++ if (!SWIG_IsOK(ecode2)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "semanage_port_set_proto" "', argument " "2"" of type '" "int""'"); ++ } ++ arg2 = (int)(val2); ++ semanage_port_set_proto(arg1,arg2); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_get_proto_str(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- int arg1 ; +- char *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_port_get_proto_str",&obj0)) goto fail; +- { +- arg1 = (int)(SWIG_As_int(obj0)); +- if (SWIG_arg_fail(1)) SWIG_fail; +- } +- result = (char *)semanage_port_get_proto_str(arg1); +- +- resultobj = SWIG_FromCharPtr(result); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_port_get_proto_str",&obj0)) SWIG_fail; ++ ecode1 = SWIG_AsVal_int(obj0, &val1); ++ if (!SWIG_IsOK(ecode1)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "semanage_port_get_proto_str" "', argument " "1"" of type '" "int""'"); ++ } ++ arg1 = (int)(val1); ++ result = (char *)semanage_port_get_proto_str(arg1); ++ resultobj = SWIG_FromCharPtr(result); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_get_low(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_port_t *arg1 = (semanage_port_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_port_get_low",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_port, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_port_get_low((semanage_port_t const *)arg1); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_port_get_low",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_port, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_get_low" "', argument " "1"" of type '" "semanage_port_t const *""'"); ++ } ++ arg1 = (semanage_port_t *)(argp1); ++ result = (int)semanage_port_get_low((struct semanage_port const *)arg1); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_get_high(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_port_t *arg1 = (semanage_port_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_port_get_high",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_port, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_port_get_high((semanage_port_t const *)arg1); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_port_get_high",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_port, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_get_high" "', argument " "1"" of type '" "semanage_port_t const *""'"); ++ } ++ arg1 = (semanage_port_t *)(argp1); ++ result = (int)semanage_port_get_high((struct semanage_port const *)arg1); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_set_port(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_port_t *arg1 = (semanage_port_t *) 0 ; +- int arg2 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_port_set_port",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_port, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- { +- arg2 = (int)(SWIG_As_int(obj1)); +- if (SWIG_arg_fail(2)) SWIG_fail; +- } +- semanage_port_set_port(arg1,arg2); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_port_set_port(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_port_t *arg1 = (semanage_port_t *) 0 ; ++ int arg2 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ int val2 ; ++ int ecode2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_port_set_port",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_port, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_set_port" "', argument " "1"" of type '" "semanage_port_t *""'"); ++ } ++ arg1 = (semanage_port_t *)(argp1); ++ ecode2 = SWIG_AsVal_int(obj1, &val2); ++ if (!SWIG_IsOK(ecode2)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "semanage_port_set_port" "', argument " "2"" of type '" "int""'"); ++ } ++ arg2 = (int)(val2); ++ semanage_port_set_port(arg1,arg2); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_set_range(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_port_t *arg1 = (semanage_port_t *) 0 ; +- int arg2 ; +- int arg3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_port_set_range",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_port, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- { +- arg2 = (int)(SWIG_As_int(obj1)); +- if (SWIG_arg_fail(2)) SWIG_fail; +- } +- { +- arg3 = (int)(SWIG_As_int(obj2)); +- if (SWIG_arg_fail(3)) SWIG_fail; +- } +- semanage_port_set_range(arg1,arg2,arg3); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_port_set_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_port_t *arg1 = (semanage_port_t *) 0 ; ++ int arg2 ; ++ int arg3 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ int val2 ; ++ int ecode2 = 0 ; ++ int val3 ; ++ int ecode3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_port_set_range",&obj0,&obj1,&obj2)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_port, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_set_range" "', argument " "1"" of type '" "semanage_port_t *""'"); ++ } ++ arg1 = (semanage_port_t *)(argp1); ++ ecode2 = SWIG_AsVal_int(obj1, &val2); ++ if (!SWIG_IsOK(ecode2)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "semanage_port_set_range" "', argument " "2"" of type '" "int""'"); ++ } ++ arg2 = (int)(val2); ++ ecode3 = SWIG_AsVal_int(obj2, &val3); ++ if (!SWIG_IsOK(ecode3)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "semanage_port_set_range" "', argument " "3"" of type '" "int""'"); ++ } ++ arg3 = (int)(val3); ++ semanage_port_set_range(arg1,arg2,arg3); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_get_con(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_port_t *arg1 = (semanage_port_t *) 0 ; +- semanage_context_t *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_port_get_con",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_port, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (semanage_context_t *)semanage_port_get_con((semanage_port_t const *)arg1); +- +- resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_semanage_context, 0); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_port_get_con",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_port, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_get_con" "', argument " "1"" of type '" "semanage_port_t const *""'"); ++ } ++ arg1 = (semanage_port_t *)(argp1); ++ result = (semanage_context_t *)semanage_port_get_con((struct semanage_port const *)arg1); ++ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_semanage_context, 0 | 0 ); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_set_con(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_port_set_con",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_port, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_port_set_con(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_port_set_con(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ void *argp3 = 0 ; ++ int res3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_set_con" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_port, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_port_set_con" "', argument " "2"" of type '" "semanage_port_t *""'"); ++ } ++ arg2 = (semanage_port_t *)(argp2); ++ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_semanage_context, 0 | 0 ); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_port_set_con" "', argument " "3"" of type '" "semanage_context_t *""'"); ++ } ++ arg3 = (semanage_context_t *)(argp3); ++ result = (int)semanage_port_set_con(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_create(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_port_t **arg2 = (semanage_port_t **) 0 ; +- int result; +- semanage_port_t *temp2 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; +- } +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_port_create",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_port_create(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_semanage_port, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_port_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_port_create",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_create" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_port_create(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_semanage_port, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_clone(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_port_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_port_clone",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_port, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_port_clone(arg1,(semanage_port_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_port, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_port_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_port_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_port_clone",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_clone" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_port, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_port_clone" "', argument " "2"" of type '" "semanage_port_t const *""'"); ++ } ++ arg2 = (semanage_port_t *)(argp2); ++ result = (int)semanage_port_clone(arg1,(struct semanage_port const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_port, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_free(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_port_t *arg1 = (semanage_port_t *) 0 ; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_port_free",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_port, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- semanage_port_free(arg1); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_port_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_port_t *arg1 = (semanage_port_t *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_port_free",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_port, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_free" "', argument " "1"" of type '" "semanage_port_t *""'"); ++ } ++ arg1 = (semanage_port_t *)(argp1); ++ semanage_port_free(arg1); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_modify_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_port_modify_local",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_port_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_semanage_port, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_port_modify_local(arg1,(semanage_port_key_t const *)arg2,(semanage_port_t const *)arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_port_modify_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ void *argp3 = 0 ; ++ int res3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_modify_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_port_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_port_modify_local" "', argument " "2"" of type '" "semanage_port_key_t const *""'"); ++ } ++ arg2 = (semanage_port_key_t *)(argp2); ++ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_semanage_port, 0 | 0 ); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_port_modify_local" "', argument " "3"" of type '" "semanage_port_t const *""'"); ++ } ++ arg3 = (semanage_port_t *)(argp3); ++ result = (int)semanage_port_modify_local(arg1,(struct semanage_port_key const *)arg2,(struct semanage_port const *)arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_del_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_port_key_t *arg2 = (semanage_port_key_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_port_del_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_port_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_port_del_local(arg1,(semanage_port_key_t const *)arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_port_del_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_del_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_port_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_port_del_local" "', argument " "2"" of type '" "semanage_port_key_t const *""'"); ++ } ++ arg2 = (semanage_port_key_t *)(argp2); ++ result = (int)semanage_port_del_local(arg1,(struct semanage_port_key const *)arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_query_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_port_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_port_query_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_port_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_port_query_local(arg1,(semanage_port_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_port, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_port_query_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_port_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_port_query_local",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_query_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_port_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_port_query_local" "', argument " "2"" of type '" "semanage_port_key_t const *""'"); ++ } ++ arg2 = (semanage_port_key_t *)(argp2); ++ result = (int)semanage_port_query_local(arg1,(struct semanage_port_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_port, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_exists_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_port_key_t *arg2 = (semanage_port_key_t *) 0 ; +- int *arg3 = (int *) 0 ; +- int result; +- int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_port_exists_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_port_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_port_exists_local(arg1,(semanage_port_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_port_exists_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_port_exists_local",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_exists_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_port_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_port_exists_local" "', argument " "2"" of type '" "semanage_port_key_t const *""'"); ++ } ++ arg2 = (semanage_port_key_t *)(argp2); ++ result = (int)semanage_port_exists_local(arg1,(struct semanage_port_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res3)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_count_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- unsigned int *arg2 = (unsigned int *) 0 ; +- int result; +- unsigned int temp2 ; +- int res2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; res2 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_port_count_local",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_port_count_local(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_port_count_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ arg2 = &temp2; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_port_count_local",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_count_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_port_count_local(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res2)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_iterate_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_port_iterate_local",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_q_const__struct_semanage_port_p_void__int, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- { +- if ((SWIG_ConvertPtr(obj2,(void **)(&arg3),0,SWIG_POINTER_EXCEPTION|0))== -1) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- } +- result = (int)semanage_port_iterate_local(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_port_iterate_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_iterate_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__struct_semanage_port_p_void__int); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "semanage_port_iterate_local" "', argument " "2"" of type '" "int (*)(semanage_port_t const *,void *)""'"); ++ } ++ } ++ res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_port_iterate_local" "', argument " "3"" of type '" "void *""'"); ++ } ++ result = (int)semanage_port_iterate_local(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_list_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_port_t ***arg2 = (semanage_port_t ***) 0 ; +- unsigned int *arg3 = (unsigned int *) 0 ; +- int result; +- semanage_port_t **temp2 ; +- unsigned int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; +- } +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_port_list_local",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_port_list_local(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- if (resultobj) { +- int value = SWIG_As_int(resultobj); +- if (value >= 0) { +- PyObject* plist = NULL; +- if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_port, +- (void (*) (void*)) &semanage_port_free, &plist) < 0) +- resultobj = SWIG_From_int(STATUS_ERR); +- else +- resultobj = t_output_helper(resultobj, plist); +- } +- } ++SWIGINTERN PyObject *_wrap_semanage_port_list_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ unsigned int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_port_list_local",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_list_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_port_list_local(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ if (resultobj) { ++ int value; ++ SWIG_AsVal_int(resultobj, &value); ++ if (value >= 0) { ++ PyObject* plist = NULL; ++ if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_port, ++ (void (*) (void*)) &semanage_port_free, &plist) < 0) ++ resultobj = SWIG_From_int(STATUS_ERR); ++ else ++ resultobj = SWIG_Python_AppendOutput(resultobj, plist); ++ } + } +- return resultobj; +- fail: +- return NULL; ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_query(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_port_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_port_query",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_port_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_port_query(arg1,(semanage_port_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_port, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_port_query(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_port_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_port_query",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_query" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_port_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_port_query" "', argument " "2"" of type '" "semanage_port_key_t const *""'"); ++ } ++ arg2 = (semanage_port_key_t *)(argp2); ++ result = (int)semanage_port_query(arg1,(struct semanage_port_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_port, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_exists(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_port_key_t *arg2 = (semanage_port_key_t *) 0 ; +- int *arg3 = (int *) 0 ; +- int result; +- int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_port_exists",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_port_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_port_exists(arg1,(semanage_port_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_port_exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_port_exists",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_exists" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_port_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_port_exists" "', argument " "2"" of type '" "semanage_port_key_t const *""'"); ++ } ++ arg2 = (semanage_port_key_t *)(argp2); ++ result = (int)semanage_port_exists(arg1,(struct semanage_port_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res3)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_count(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- unsigned int *arg2 = (unsigned int *) 0 ; +- int result; +- unsigned int temp2 ; +- int res2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; res2 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_port_count",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_port_count(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_port_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ arg2 = &temp2; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_port_count",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_count" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_port_count(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res2)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_iterate(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_port_iterate",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_q_const__struct_semanage_port_p_void__int, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- { +- if ((SWIG_ConvertPtr(obj2,(void **)(&arg3),0,SWIG_POINTER_EXCEPTION|0))== -1) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- } +- result = (int)semanage_port_iterate(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_port_iterate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_iterate" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__struct_semanage_port_p_void__int); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "semanage_port_iterate" "', argument " "2"" of type '" "int (*)(semanage_port_t const *,void *)""'"); ++ } ++ } ++ res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_port_iterate" "', argument " "3"" of type '" "void *""'"); ++ } ++ result = (int)semanage_port_iterate(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_port_list(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_port_t ***arg2 = (semanage_port_t ***) 0 ; +- unsigned int *arg3 = (unsigned int *) 0 ; +- int result; +- semanage_port_t **temp2 ; +- unsigned int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; +- } +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_port_list",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_port_list(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- if (resultobj) { +- int value = SWIG_As_int(resultobj); +- if (value >= 0) { +- PyObject* plist = NULL; +- if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_port, +- (void (*) (void*)) &semanage_port_free, &plist) < 0) +- resultobj = SWIG_From_int(STATUS_ERR); +- else +- resultobj = t_output_helper(resultobj, plist); +- } +- } ++SWIGINTERN PyObject *_wrap_semanage_port_list(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ unsigned int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_port_list",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_port_list" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_port_list(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ if (resultobj) { ++ int value; ++ SWIG_AsVal_int(resultobj, &value); ++ if (value >= 0) { ++ PyObject* plist = NULL; ++ if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_port, ++ (void (*) (void*)) &semanage_port_free, &plist) < 0) ++ resultobj = SWIG_From_int(STATUS_ERR); ++ else ++ resultobj = SWIG_Python_AppendOutput(resultobj, plist); ++ } + } +- return resultobj; +- fail: +- return NULL; ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_compare(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_fcontext_t *arg1 = (semanage_fcontext_t *) 0 ; +- semanage_fcontext_key_t *arg2 = (semanage_fcontext_key_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_compare",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_fcontext, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_fcontext_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_fcontext_compare((semanage_fcontext_t const *)arg1,(semanage_fcontext_key_t const *)arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_fcontext_compare(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_compare",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_fcontext, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_compare" "', argument " "1"" of type '" "semanage_fcontext_t const *""'"); ++ } ++ arg1 = (semanage_fcontext_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_fcontext_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_fcontext_compare" "', argument " "2"" of type '" "semanage_fcontext_key_t const *""'"); ++ } ++ arg2 = (semanage_fcontext_key_t *)(argp2); ++ result = (int)semanage_fcontext_compare((struct semanage_fcontext const *)arg1,(struct semanage_fcontext_key const *)arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_compare2(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_fcontext_t *arg1 = (semanage_fcontext_t *) 0 ; +- semanage_fcontext_t *arg2 = (semanage_fcontext_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_compare2",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_fcontext, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_fcontext, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_fcontext_compare2((semanage_fcontext_t const *)arg1,(semanage_fcontext_t const *)arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_fcontext_compare2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_compare2",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_fcontext, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_compare2" "', argument " "1"" of type '" "semanage_fcontext_t const *""'"); ++ } ++ arg1 = (semanage_fcontext_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_fcontext, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_fcontext_compare2" "', argument " "2"" of type '" "semanage_fcontext_t const *""'"); ++ } ++ arg2 = (semanage_fcontext_t *)(argp2); ++ result = (int)semanage_fcontext_compare2((struct semanage_fcontext const *)arg1,(struct semanage_fcontext const *)arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_key_create(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- char *arg2 = (char *) 0 ; +- int arg3 ; +- semanage_fcontext_key_t **arg4 = (semanage_fcontext_key_t **) 0 ; +- int result; +- semanage_fcontext_key_t *temp4 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- { +- arg4 = &temp4; +- } +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_fcontext_key_create",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { +- SWIG_arg_fail(2);SWIG_fail; +- } +- { +- arg3 = (int)(SWIG_As_int(obj2)); +- if (SWIG_arg_fail(3)) SWIG_fail; +- } +- result = (int)semanage_fcontext_key_create(arg1,(char const *)arg2,arg3,arg4); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg4, SWIGTYPE_p_semanage_fcontext_key, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_fcontext_key_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ 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 ; ++ char *buf2 = 0 ; ++ int alloc2 = 0 ; ++ int val3 ; ++ int ecode3 = 0 ; ++ semanage_fcontext_key_t *temp4 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ { ++ arg4 = &temp4; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OOO:semanage_fcontext_key_create",&obj0,&obj1,&obj2)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_key_create" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_fcontext_key_create" "', argument " "2"" of type '" "char const *""'"); ++ } ++ arg2 = buf2; ++ ecode3 = SWIG_AsVal_int(obj2, &val3); ++ if (!SWIG_IsOK(ecode3)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "semanage_fcontext_key_create" "', argument " "3"" of type '" "int""'"); ++ } ++ arg3 = (int)(val3); ++ result = (int)semanage_fcontext_key_create(arg1,(char const *)arg2,arg3,arg4); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg4, SWIGTYPE_p_semanage_fcontext_key, 0)); ++ } ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return resultobj; ++fail: ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_key_extract(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_fcontext_key_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_key_extract",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_fcontext, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_fcontext_key_extract(arg1,(semanage_fcontext_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_fcontext_key, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_fcontext_key_extract(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_fcontext_key_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_key_extract",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_key_extract" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_fcontext, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_fcontext_key_extract" "', argument " "2"" of type '" "semanage_fcontext_t const *""'"); ++ } ++ arg2 = (semanage_fcontext_t *)(argp2); ++ result = (int)semanage_fcontext_key_extract(arg1,(struct semanage_fcontext const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_fcontext_key, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_key_free(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_fcontext_key_t *arg1 = (semanage_fcontext_key_t *) 0 ; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_key_free",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_fcontext_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- semanage_fcontext_key_free(arg1); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_fcontext_key_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_fcontext_key_t *arg1 = (semanage_fcontext_key_t *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_key_free",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_fcontext_key, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_key_free" "', argument " "1"" of type '" "semanage_fcontext_key_t *""'"); ++ } ++ arg1 = (semanage_fcontext_key_t *)(argp1); ++ semanage_fcontext_key_free(arg1); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_get_expr(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_fcontext_t *arg1 = (semanage_fcontext_t *) 0 ; +- char *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_get_expr",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_fcontext, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (char *)semanage_fcontext_get_expr((semanage_fcontext_t const *)arg1); +- +- resultobj = SWIG_FromCharPtr(result); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_get_expr",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_fcontext, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_get_expr" "', argument " "1"" of type '" "semanage_fcontext_t const *""'"); ++ } ++ arg1 = (semanage_fcontext_t *)(argp1); ++ result = (char *)semanage_fcontext_get_expr((struct semanage_fcontext const *)arg1); ++ resultobj = SWIG_FromCharPtr(result); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_set_expr(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_fcontext_t *arg2 = (semanage_fcontext_t *) 0 ; +- char *arg3 = (char *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_fcontext_set_expr",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_fcontext, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- result = (int)semanage_fcontext_set_expr(arg1,arg2,(char const *)arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_fcontext_set_expr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int res3 ; ++ char *buf3 = 0 ; ++ int alloc3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_set_expr" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_fcontext, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_fcontext_set_expr" "', argument " "2"" of type '" "semanage_fcontext_t *""'"); ++ } ++ arg2 = (semanage_fcontext_t *)(argp2); ++ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_fcontext_set_expr" "', argument " "3"" of type '" "char const *""'"); ++ } ++ arg3 = buf3; ++ result = (int)semanage_fcontext_set_expr(arg1,arg2,(char const *)arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return resultobj; ++fail: ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_get_type(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_fcontext_t *arg1 = (semanage_fcontext_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_get_type",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_fcontext, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_fcontext_get_type((semanage_fcontext_t const *)arg1); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_get_type",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_fcontext, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_get_type" "', argument " "1"" of type '" "semanage_fcontext_t const *""'"); ++ } ++ arg1 = (semanage_fcontext_t *)(argp1); ++ result = (int)semanage_fcontext_get_type((struct semanage_fcontext const *)arg1); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_get_type_str(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- int arg1 ; +- char *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_get_type_str",&obj0)) goto fail; +- { +- arg1 = (int)(SWIG_As_int(obj0)); +- if (SWIG_arg_fail(1)) SWIG_fail; +- } +- result = (char *)semanage_fcontext_get_type_str(arg1); +- +- resultobj = SWIG_FromCharPtr(result); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_get_type_str",&obj0)) SWIG_fail; ++ ecode1 = SWIG_AsVal_int(obj0, &val1); ++ if (!SWIG_IsOK(ecode1)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "semanage_fcontext_get_type_str" "', argument " "1"" of type '" "int""'"); ++ } ++ arg1 = (int)(val1); ++ result = (char *)semanage_fcontext_get_type_str(arg1); ++ resultobj = SWIG_FromCharPtr(result); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_set_type(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_fcontext_t *arg1 = (semanage_fcontext_t *) 0 ; +- int arg2 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_set_type",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_fcontext, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- { +- arg2 = (int)(SWIG_As_int(obj1)); +- if (SWIG_arg_fail(2)) SWIG_fail; +- } +- semanage_fcontext_set_type(arg1,arg2); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_fcontext_set_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_fcontext_t *arg1 = (semanage_fcontext_t *) 0 ; ++ int arg2 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ int val2 ; ++ int ecode2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_set_type",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_fcontext, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_set_type" "', argument " "1"" of type '" "semanage_fcontext_t *""'"); ++ } ++ arg1 = (semanage_fcontext_t *)(argp1); ++ ecode2 = SWIG_AsVal_int(obj1, &val2); ++ if (!SWIG_IsOK(ecode2)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "semanage_fcontext_set_type" "', argument " "2"" of type '" "int""'"); ++ } ++ arg2 = (int)(val2); ++ semanage_fcontext_set_type(arg1,arg2); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_get_con(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_fcontext_t *arg1 = (semanage_fcontext_t *) 0 ; +- semanage_context_t *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_get_con",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_fcontext, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (semanage_context_t *)semanage_fcontext_get_con((semanage_fcontext_t const *)arg1); +- +- resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_semanage_context, 0); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_get_con",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_fcontext, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_get_con" "', argument " "1"" of type '" "semanage_fcontext_t const *""'"); ++ } ++ arg1 = (semanage_fcontext_t *)(argp1); ++ result = (semanage_context_t *)semanage_fcontext_get_con((struct semanage_fcontext const *)arg1); ++ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_semanage_context, 0 | 0 ); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_set_con(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_fcontext_set_con",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_fcontext, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_fcontext_set_con(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_fcontext_set_con(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ void *argp3 = 0 ; ++ int res3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_set_con" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_fcontext, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_fcontext_set_con" "', argument " "2"" of type '" "semanage_fcontext_t *""'"); ++ } ++ arg2 = (semanage_fcontext_t *)(argp2); ++ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_semanage_context, 0 | 0 ); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_fcontext_set_con" "', argument " "3"" of type '" "semanage_context_t *""'"); ++ } ++ arg3 = (semanage_context_t *)(argp3); ++ result = (int)semanage_fcontext_set_con(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_create(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_fcontext_t **arg2 = (semanage_fcontext_t **) 0 ; +- int result; +- semanage_fcontext_t *temp2 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; +- } +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_create",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_fcontext_create(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_semanage_fcontext, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_fcontext_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_create",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_create" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_fcontext_create(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_semanage_fcontext, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_clone(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_fcontext_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_clone",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_fcontext, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_fcontext_clone(arg1,(semanage_fcontext_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_fcontext, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_fcontext_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_fcontext_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_clone",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_clone" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_fcontext, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_fcontext_clone" "', argument " "2"" of type '" "semanage_fcontext_t const *""'"); ++ } ++ arg2 = (semanage_fcontext_t *)(argp2); ++ result = (int)semanage_fcontext_clone(arg1,(struct semanage_fcontext const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_fcontext, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_free(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_fcontext_t *arg1 = (semanage_fcontext_t *) 0 ; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_free",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_fcontext, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- semanage_fcontext_free(arg1); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_fcontext_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_fcontext_t *arg1 = (semanage_fcontext_t *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_free",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_fcontext, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_free" "', argument " "1"" of type '" "semanage_fcontext_t *""'"); ++ } ++ arg1 = (semanage_fcontext_t *)(argp1); ++ semanage_fcontext_free(arg1); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_modify_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_fcontext_modify_local",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_fcontext_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_semanage_fcontext, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_fcontext_modify_local(arg1,(semanage_fcontext_key_t const *)arg2,(semanage_fcontext_t const *)arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_fcontext_modify_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ void *argp3 = 0 ; ++ int res3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_modify_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_fcontext_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_fcontext_modify_local" "', argument " "2"" of type '" "semanage_fcontext_key_t const *""'"); ++ } ++ arg2 = (semanage_fcontext_key_t *)(argp2); ++ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_semanage_fcontext, 0 | 0 ); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_fcontext_modify_local" "', argument " "3"" of type '" "semanage_fcontext_t const *""'"); ++ } ++ arg3 = (semanage_fcontext_t *)(argp3); ++ result = (int)semanage_fcontext_modify_local(arg1,(struct semanage_fcontext_key const *)arg2,(struct semanage_fcontext const *)arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_del_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_fcontext_key_t *arg2 = (semanage_fcontext_key_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_del_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_fcontext_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_fcontext_del_local(arg1,(semanage_fcontext_key_t const *)arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_fcontext_del_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_del_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_fcontext_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_fcontext_del_local" "', argument " "2"" of type '" "semanage_fcontext_key_t const *""'"); ++ } ++ arg2 = (semanage_fcontext_key_t *)(argp2); ++ result = (int)semanage_fcontext_del_local(arg1,(struct semanage_fcontext_key const *)arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_query_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_fcontext_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_query_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_fcontext_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_fcontext_query_local(arg1,(semanage_fcontext_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_fcontext, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_fcontext_query_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_fcontext_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_query_local",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_query_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_fcontext_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_fcontext_query_local" "', argument " "2"" of type '" "semanage_fcontext_key_t const *""'"); ++ } ++ arg2 = (semanage_fcontext_key_t *)(argp2); ++ result = (int)semanage_fcontext_query_local(arg1,(struct semanage_fcontext_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_fcontext, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_exists_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_fcontext_key_t *arg2 = (semanage_fcontext_key_t *) 0 ; +- int *arg3 = (int *) 0 ; +- int result; +- int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_exists_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_fcontext_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_fcontext_exists_local(arg1,(semanage_fcontext_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_fcontext_exists_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_exists_local",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_exists_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_fcontext_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_fcontext_exists_local" "', argument " "2"" of type '" "semanage_fcontext_key_t const *""'"); ++ } ++ arg2 = (semanage_fcontext_key_t *)(argp2); ++ result = (int)semanage_fcontext_exists_local(arg1,(struct semanage_fcontext_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res3)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_count_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- unsigned int *arg2 = (unsigned int *) 0 ; +- int result; +- unsigned int temp2 ; +- int res2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; res2 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_count_local",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_fcontext_count_local(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_fcontext_count_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ arg2 = &temp2; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_count_local",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_count_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_fcontext_count_local(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res2)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_iterate_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_fcontext_iterate_local",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_q_const__struct_semanage_fcontext_p_void__int, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- { +- if ((SWIG_ConvertPtr(obj2,(void **)(&arg3),0,SWIG_POINTER_EXCEPTION|0))== -1) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- } +- result = (int)semanage_fcontext_iterate_local(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_fcontext_iterate_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_iterate_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__struct_semanage_fcontext_p_void__int); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "semanage_fcontext_iterate_local" "', argument " "2"" of type '" "int (*)(semanage_fcontext_t const *,void *)""'"); ++ } ++ } ++ res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_fcontext_iterate_local" "', argument " "3"" of type '" "void *""'"); ++ } ++ result = (int)semanage_fcontext_iterate_local(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_list_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_fcontext_t ***arg2 = (semanage_fcontext_t ***) 0 ; +- unsigned int *arg3 = (unsigned int *) 0 ; +- int result; +- semanage_fcontext_t **temp2 ; +- unsigned int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; +- } +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_list_local",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_fcontext_list_local(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- if (resultobj) { +- int value = SWIG_As_int(resultobj); +- if (value >= 0) { +- PyObject* plist = NULL; +- if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_fcontext, +- (void (*) (void*)) &semanage_fcontext_free, &plist) < 0) +- resultobj = SWIG_From_int(STATUS_ERR); +- else +- resultobj = t_output_helper(resultobj, plist); +- } +- } ++SWIGINTERN PyObject *_wrap_semanage_fcontext_list_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ unsigned int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_list_local",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_list_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_fcontext_list_local(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ if (resultobj) { ++ int value; ++ SWIG_AsVal_int(resultobj, &value); ++ if (value >= 0) { ++ PyObject* plist = NULL; ++ if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_fcontext, ++ (void (*) (void*)) &semanage_fcontext_free, &plist) < 0) ++ resultobj = SWIG_From_int(STATUS_ERR); ++ else ++ resultobj = SWIG_Python_AppendOutput(resultobj, plist); ++ } + } +- return resultobj; +- fail: +- return NULL; ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_query(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_fcontext_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_query",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_fcontext_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_fcontext_query(arg1,(semanage_fcontext_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_fcontext, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_fcontext_query(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_fcontext_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_query",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_query" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_fcontext_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_fcontext_query" "', argument " "2"" of type '" "semanage_fcontext_key_t const *""'"); ++ } ++ arg2 = (semanage_fcontext_key_t *)(argp2); ++ result = (int)semanage_fcontext_query(arg1,(struct semanage_fcontext_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_fcontext, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_exists(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_fcontext_key_t *arg2 = (semanage_fcontext_key_t *) 0 ; +- int *arg3 = (int *) 0 ; +- int result; +- int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_exists",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_fcontext_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_fcontext_exists(arg1,(semanage_fcontext_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_fcontext_exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_fcontext_exists",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_exists" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_fcontext_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_fcontext_exists" "', argument " "2"" of type '" "semanage_fcontext_key_t const *""'"); ++ } ++ arg2 = (semanage_fcontext_key_t *)(argp2); ++ result = (int)semanage_fcontext_exists(arg1,(struct semanage_fcontext_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res3)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_count(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- unsigned int *arg2 = (unsigned int *) 0 ; +- int result; +- unsigned int temp2 ; +- int res2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; res2 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_count",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_fcontext_count(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_fcontext_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ arg2 = &temp2; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_count",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_count" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_fcontext_count(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res2)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_iterate(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_fcontext_iterate",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_q_const__struct_semanage_fcontext_p_void__int, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- { +- if ((SWIG_ConvertPtr(obj2,(void **)(&arg3),0,SWIG_POINTER_EXCEPTION|0))== -1) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- } +- result = (int)semanage_fcontext_iterate(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_fcontext_iterate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_iterate" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__struct_semanage_fcontext_p_void__int); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "semanage_fcontext_iterate" "', argument " "2"" of type '" "int (*)(semanage_fcontext_t const *,void *)""'"); ++ } ++ } ++ res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_fcontext_iterate" "', argument " "3"" of type '" "void *""'"); ++ } ++ result = (int)semanage_fcontext_iterate(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_fcontext_list(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_fcontext_t ***arg2 = (semanage_fcontext_t ***) 0 ; +- unsigned int *arg3 = (unsigned int *) 0 ; +- int result; +- semanage_fcontext_t **temp2 ; +- unsigned int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; +- } +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_list",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_fcontext_list(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- if (resultobj) { +- int value = SWIG_As_int(resultobj); +- if (value >= 0) { +- PyObject* plist = NULL; +- if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_fcontext, +- (void (*) (void*)) &semanage_fcontext_free, &plist) < 0) +- resultobj = SWIG_From_int(STATUS_ERR); +- else +- resultobj = t_output_helper(resultobj, plist); +- } +- } ++SWIGINTERN PyObject *_wrap_semanage_fcontext_list(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ unsigned int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_fcontext_list",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_fcontext_list" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_fcontext_list(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ if (resultobj) { ++ int value; ++ SWIG_AsVal_int(resultobj, &value); ++ if (value >= 0) { ++ PyObject* plist = NULL; ++ if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_fcontext, ++ (void (*) (void*)) &semanage_fcontext_free, &plist) < 0) ++ resultobj = SWIG_From_int(STATUS_ERR); ++ else ++ resultobj = SWIG_Python_AppendOutput(resultobj, plist); ++ } + } +- return resultobj; +- fail: +- return NULL; ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_key_create(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- char *arg2 = (char *) 0 ; +- semanage_seuser_key_t **arg3 = (semanage_seuser_key_t **) 0 ; +- int result; +- semanage_seuser_key_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_key_create",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { +- SWIG_arg_fail(2);SWIG_fail; +- } +- result = (int)semanage_seuser_key_create(arg1,(char const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_seuser_key, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_seuser_key_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ char *buf2 = 0 ; ++ int alloc2 = 0 ; ++ semanage_seuser_key_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_key_create",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_key_create" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_seuser_key_create" "', argument " "2"" of type '" "char const *""'"); ++ } ++ arg2 = buf2; ++ result = (int)semanage_seuser_key_create(arg1,(char const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_seuser_key, 0)); ++ } ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return resultobj; ++fail: ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_key_extract(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_seuser_key_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_key_extract",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_seuser, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_seuser_key_extract(arg1,(semanage_seuser_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_seuser_key, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_seuser_key_extract(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_seuser_key_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_key_extract",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_key_extract" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_seuser, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_seuser_key_extract" "', argument " "2"" of type '" "semanage_seuser_t const *""'"); ++ } ++ arg2 = (semanage_seuser_t *)(argp2); ++ result = (int)semanage_seuser_key_extract(arg1,(struct semanage_seuser const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_seuser_key, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_key_free(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_seuser_key_t *arg1 = (semanage_seuser_key_t *) 0 ; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_key_free",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_seuser_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- semanage_seuser_key_free(arg1); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_seuser_key_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_seuser_key_t *arg1 = (semanage_seuser_key_t *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_key_free",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_seuser_key, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_key_free" "', argument " "1"" of type '" "semanage_seuser_key_t *""'"); ++ } ++ arg1 = (semanage_seuser_key_t *)(argp1); ++ semanage_seuser_key_free(arg1); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_compare(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_seuser_t *arg1 = (semanage_seuser_t *) 0 ; +- semanage_seuser_key_t *arg2 = (semanage_seuser_key_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_compare",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_seuser, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_seuser_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_seuser_compare((semanage_seuser_t const *)arg1,(semanage_seuser_key_t const *)arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_seuser_compare(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_compare",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_seuser, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_compare" "', argument " "1"" of type '" "semanage_seuser_t const *""'"); ++ } ++ arg1 = (semanage_seuser_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_seuser_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_seuser_compare" "', argument " "2"" of type '" "semanage_seuser_key_t const *""'"); ++ } ++ arg2 = (semanage_seuser_key_t *)(argp2); ++ result = (int)semanage_seuser_compare((struct semanage_seuser const *)arg1,(struct semanage_seuser_key const *)arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_compare2(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_seuser_t *arg1 = (semanage_seuser_t *) 0 ; +- semanage_seuser_t *arg2 = (semanage_seuser_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_compare2",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_seuser, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_seuser, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_seuser_compare2((semanage_seuser_t const *)arg1,(semanage_seuser_t const *)arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_seuser_compare2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_compare2",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_seuser, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_compare2" "', argument " "1"" of type '" "semanage_seuser_t const *""'"); ++ } ++ arg1 = (semanage_seuser_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_seuser, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_seuser_compare2" "', argument " "2"" of type '" "semanage_seuser_t const *""'"); ++ } ++ arg2 = (semanage_seuser_t *)(argp2); ++ result = (int)semanage_seuser_compare2((struct semanage_seuser const *)arg1,(struct semanage_seuser const *)arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_get_name(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_seuser_t *arg1 = (semanage_seuser_t *) 0 ; +- char *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_get_name",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_seuser, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (char *)semanage_seuser_get_name((semanage_seuser_t const *)arg1); +- +- resultobj = SWIG_FromCharPtr(result); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_get_name",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_seuser, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_get_name" "', argument " "1"" of type '" "semanage_seuser_t const *""'"); ++ } ++ arg1 = (semanage_seuser_t *)(argp1); ++ result = (char *)semanage_seuser_get_name((struct semanage_seuser const *)arg1); ++ resultobj = SWIG_FromCharPtr(result); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_set_name(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_seuser_t *arg2 = (semanage_seuser_t *) 0 ; +- char *arg3 = (char *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_seuser_set_name",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_seuser, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- result = (int)semanage_seuser_set_name(arg1,arg2,(char const *)arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_seuser_set_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int res3 ; ++ char *buf3 = 0 ; ++ int alloc3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_set_name" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_seuser, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_seuser_set_name" "', argument " "2"" of type '" "semanage_seuser_t *""'"); ++ } ++ arg2 = (semanage_seuser_t *)(argp2); ++ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_seuser_set_name" "', argument " "3"" of type '" "char const *""'"); ++ } ++ arg3 = buf3; ++ result = (int)semanage_seuser_set_name(arg1,arg2,(char const *)arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return resultobj; ++fail: ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_get_sename(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_seuser_t *arg1 = (semanage_seuser_t *) 0 ; +- char *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_get_sename",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_seuser, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (char *)semanage_seuser_get_sename((semanage_seuser_t const *)arg1); +- +- resultobj = SWIG_FromCharPtr(result); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_get_sename",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_seuser, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_get_sename" "', argument " "1"" of type '" "semanage_seuser_t const *""'"); ++ } ++ arg1 = (semanage_seuser_t *)(argp1); ++ result = (char *)semanage_seuser_get_sename((struct semanage_seuser const *)arg1); ++ resultobj = SWIG_FromCharPtr(result); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_set_sename(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_seuser_t *arg2 = (semanage_seuser_t *) 0 ; +- char *arg3 = (char *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_seuser_set_sename",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_seuser, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- result = (int)semanage_seuser_set_sename(arg1,arg2,(char const *)arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_seuser_set_sename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int res3 ; ++ char *buf3 = 0 ; ++ int alloc3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_set_sename" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_seuser, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_seuser_set_sename" "', argument " "2"" of type '" "semanage_seuser_t *""'"); ++ } ++ arg2 = (semanage_seuser_t *)(argp2); ++ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_seuser_set_sename" "', argument " "3"" of type '" "char const *""'"); ++ } ++ arg3 = buf3; ++ result = (int)semanage_seuser_set_sename(arg1,arg2,(char const *)arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return resultobj; ++fail: ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_get_mlsrange(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_seuser_t *arg1 = (semanage_seuser_t *) 0 ; +- char *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_get_mlsrange",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_seuser, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (char *)semanage_seuser_get_mlsrange((semanage_seuser_t const *)arg1); +- +- resultobj = SWIG_FromCharPtr(result); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_get_mlsrange",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_seuser, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_get_mlsrange" "', argument " "1"" of type '" "semanage_seuser_t const *""'"); ++ } ++ arg1 = (semanage_seuser_t *)(argp1); ++ result = (char *)semanage_seuser_get_mlsrange((struct semanage_seuser const *)arg1); ++ resultobj = SWIG_FromCharPtr(result); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_set_mlsrange(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_seuser_t *arg2 = (semanage_seuser_t *) 0 ; +- char *arg3 = (char *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_seuser_set_mlsrange",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_seuser, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- result = (int)semanage_seuser_set_mlsrange(arg1,arg2,(char const *)arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_seuser_set_mlsrange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int res3 ; ++ char *buf3 = 0 ; ++ int alloc3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_set_mlsrange" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_seuser, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_seuser_set_mlsrange" "', argument " "2"" of type '" "semanage_seuser_t *""'"); ++ } ++ arg2 = (semanage_seuser_t *)(argp2); ++ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_seuser_set_mlsrange" "', argument " "3"" of type '" "char const *""'"); ++ } ++ arg3 = buf3; ++ result = (int)semanage_seuser_set_mlsrange(arg1,arg2,(char const *)arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return resultobj; ++fail: ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_create(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_seuser_t **arg2 = (semanage_seuser_t **) 0 ; +- int result; +- semanage_seuser_t *temp2 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; +- } +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_create",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_seuser_create(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_semanage_seuser, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_seuser_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_create",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_create" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_seuser_create(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_semanage_seuser, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_clone(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_seuser_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_clone",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_seuser, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_seuser_clone(arg1,(semanage_seuser_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_seuser, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_seuser_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_seuser_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_clone",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_clone" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_seuser, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_seuser_clone" "', argument " "2"" of type '" "semanage_seuser_t const *""'"); ++ } ++ arg2 = (semanage_seuser_t *)(argp2); ++ result = (int)semanage_seuser_clone(arg1,(struct semanage_seuser const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_seuser, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_free(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_seuser_t *arg1 = (semanage_seuser_t *) 0 ; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_free",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_seuser, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- semanage_seuser_free(arg1); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_seuser_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_seuser_t *arg1 = (semanage_seuser_t *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_free",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_seuser, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_free" "', argument " "1"" of type '" "semanage_seuser_t *""'"); ++ } ++ arg1 = (semanage_seuser_t *)(argp1); ++ semanage_seuser_free(arg1); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_modify_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_seuser_modify_local",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_seuser_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_semanage_seuser, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_seuser_modify_local(arg1,(semanage_seuser_key_t const *)arg2,(semanage_seuser_t const *)arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_seuser_modify_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ void *argp3 = 0 ; ++ int res3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_modify_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_seuser_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_seuser_modify_local" "', argument " "2"" of type '" "semanage_seuser_key_t const *""'"); ++ } ++ arg2 = (semanage_seuser_key_t *)(argp2); ++ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_semanage_seuser, 0 | 0 ); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_seuser_modify_local" "', argument " "3"" of type '" "semanage_seuser_t const *""'"); ++ } ++ arg3 = (semanage_seuser_t *)(argp3); ++ result = (int)semanage_seuser_modify_local(arg1,(struct semanage_seuser_key const *)arg2,(struct semanage_seuser const *)arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_del_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_seuser_key_t *arg2 = (semanage_seuser_key_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_del_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_seuser_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_seuser_del_local(arg1,(semanage_seuser_key_t const *)arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_seuser_del_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_del_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_seuser_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_seuser_del_local" "', argument " "2"" of type '" "semanage_seuser_key_t const *""'"); ++ } ++ arg2 = (semanage_seuser_key_t *)(argp2); ++ result = (int)semanage_seuser_del_local(arg1,(struct semanage_seuser_key const *)arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_query_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_seuser_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_query_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_seuser_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_seuser_query_local(arg1,(semanage_seuser_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_seuser, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_seuser_query_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_seuser_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_query_local",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_query_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_seuser_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_seuser_query_local" "', argument " "2"" of type '" "semanage_seuser_key_t const *""'"); ++ } ++ arg2 = (semanage_seuser_key_t *)(argp2); ++ result = (int)semanage_seuser_query_local(arg1,(struct semanage_seuser_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_seuser, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_exists_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_seuser_key_t *arg2 = (semanage_seuser_key_t *) 0 ; +- int *arg3 = (int *) 0 ; +- int result; +- int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_exists_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_seuser_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_seuser_exists_local(arg1,(semanage_seuser_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_seuser_exists_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_exists_local",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_exists_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_seuser_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_seuser_exists_local" "', argument " "2"" of type '" "semanage_seuser_key_t const *""'"); ++ } ++ arg2 = (semanage_seuser_key_t *)(argp2); ++ result = (int)semanage_seuser_exists_local(arg1,(struct semanage_seuser_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res3)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_count_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- unsigned int *arg2 = (unsigned int *) 0 ; +- int result; +- unsigned int temp2 ; +- int res2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; res2 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_count_local",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_seuser_count_local(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_seuser_count_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ arg2 = &temp2; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_count_local",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_count_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_seuser_count_local(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res2)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_iterate_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_seuser_iterate_local",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_q_const__struct_semanage_seuser_p_void__int, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- { +- if ((SWIG_ConvertPtr(obj2,(void **)(&arg3),0,SWIG_POINTER_EXCEPTION|0))== -1) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- } +- result = (int)semanage_seuser_iterate_local(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_seuser_iterate_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_iterate_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__struct_semanage_seuser_p_void__int); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "semanage_seuser_iterate_local" "', argument " "2"" of type '" "int (*)(semanage_seuser_t const *,void *)""'"); ++ } ++ } ++ res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_seuser_iterate_local" "', argument " "3"" of type '" "void *""'"); ++ } ++ result = (int)semanage_seuser_iterate_local(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_list_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_seuser_t ***arg2 = (semanage_seuser_t ***) 0 ; +- unsigned int *arg3 = (unsigned int *) 0 ; +- int result; +- semanage_seuser_t **temp2 ; +- unsigned int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; +- } +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_list_local",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_seuser_list_local(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- if (resultobj) { +- int value = SWIG_As_int(resultobj); +- if (value >= 0) { +- PyObject* plist = NULL; +- if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_seuser, +- (void (*) (void*)) &semanage_seuser_free, &plist) < 0) +- resultobj = SWIG_From_int(STATUS_ERR); +- else +- resultobj = t_output_helper(resultobj, plist); +- } +- } ++SWIGINTERN PyObject *_wrap_semanage_seuser_list_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ unsigned int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_list_local",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_list_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_seuser_list_local(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ if (resultobj) { ++ int value; ++ SWIG_AsVal_int(resultobj, &value); ++ if (value >= 0) { ++ PyObject* plist = NULL; ++ if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_seuser, ++ (void (*) (void*)) &semanage_seuser_free, &plist) < 0) ++ resultobj = SWIG_From_int(STATUS_ERR); ++ else ++ resultobj = SWIG_Python_AppendOutput(resultobj, plist); ++ } + } +- return resultobj; +- fail: +- return NULL; ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_query(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_seuser_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_query",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_seuser_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_seuser_query(arg1,(semanage_seuser_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_seuser, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_seuser_query(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_seuser_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_query",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_query" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_seuser_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_seuser_query" "', argument " "2"" of type '" "semanage_seuser_key_t const *""'"); ++ } ++ arg2 = (semanage_seuser_key_t *)(argp2); ++ result = (int)semanage_seuser_query(arg1,(struct semanage_seuser_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_seuser, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_exists(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_seuser_key_t *arg2 = (semanage_seuser_key_t *) 0 ; +- int *arg3 = (int *) 0 ; +- int result; +- int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_exists",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_seuser_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_seuser_exists(arg1,(semanage_seuser_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_seuser_exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_exists",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_exists" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_seuser_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_seuser_exists" "', argument " "2"" of type '" "semanage_seuser_key_t const *""'"); ++ } ++ arg2 = (semanage_seuser_key_t *)(argp2); ++ result = (int)semanage_seuser_exists(arg1,(struct semanage_seuser_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res3)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_count(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- unsigned int *arg2 = (unsigned int *) 0 ; +- int result; +- unsigned int temp2 ; +- int res2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; res2 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_count",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_seuser_count(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_seuser_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ arg2 = &temp2; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_count",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_count" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_seuser_count(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res2)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_iterate(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_seuser_iterate",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_q_const__struct_semanage_seuser_p_void__int, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- { +- if ((SWIG_ConvertPtr(obj2,(void **)(&arg3),0,SWIG_POINTER_EXCEPTION|0))== -1) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- } +- result = (int)semanage_seuser_iterate(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_seuser_iterate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_iterate" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__struct_semanage_seuser_p_void__int); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "semanage_seuser_iterate" "', argument " "2"" of type '" "int (*)(semanage_seuser_t const *,void *)""'"); ++ } ++ } ++ res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_seuser_iterate" "', argument " "3"" of type '" "void *""'"); ++ } ++ result = (int)semanage_seuser_iterate(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_list(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_seuser_t ***arg2 = (semanage_seuser_t ***) 0 ; +- unsigned int *arg3 = (unsigned int *) 0 ; +- int result; +- semanage_seuser_t **temp2 ; +- unsigned int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; +- } +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_list",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_seuser_list(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- if (resultobj) { +- int value = SWIG_As_int(resultobj); +- if (value >= 0) { +- PyObject* plist = NULL; +- if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_seuser, +- (void (*) (void*)) &semanage_seuser_free, &plist) < 0) +- resultobj = SWIG_From_int(STATUS_ERR); +- else +- resultobj = t_output_helper(resultobj, plist); +- } +- } ++SWIGINTERN PyObject *_wrap_semanage_seuser_list(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ unsigned int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_list",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_seuser_list" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_seuser_list(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ if (resultobj) { ++ int value; ++ SWIG_AsVal_int(resultobj, &value); ++ if (value >= 0) { ++ PyObject* plist = NULL; ++ if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_seuser, ++ (void (*) (void*)) &semanage_seuser_free, &plist) < 0) ++ resultobj = SWIG_From_int(STATUS_ERR); ++ else ++ resultobj = SWIG_Python_AppendOutput(resultobj, plist); ++ } + } +- return resultobj; +- fail: +- return NULL; ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_compare(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_node_t *arg1 = (semanage_node_t *) 0 ; +- semanage_node_key_t *arg2 = (semanage_node_key_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_node_compare",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_node, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_node_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_node_compare((semanage_node_t const *)arg1,(semanage_node_key_t const *)arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_compare(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_node_compare",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_node, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_compare" "', argument " "1"" of type '" "semanage_node_t const *""'"); ++ } ++ arg1 = (semanage_node_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_node_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_node_compare" "', argument " "2"" of type '" "semanage_node_key_t const *""'"); ++ } ++ arg2 = (semanage_node_key_t *)(argp2); ++ result = (int)semanage_node_compare((struct semanage_node const *)arg1,(struct semanage_node_key const *)arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_compare2(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_node_t *arg1 = (semanage_node_t *) 0 ; +- semanage_node_t *arg2 = (semanage_node_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_node_compare2",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_node, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_node, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_node_compare2((semanage_node_t const *)arg1,(semanage_node_t const *)arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_compare2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_node_compare2",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_node, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_compare2" "', argument " "1"" of type '" "semanage_node_t const *""'"); ++ } ++ arg1 = (semanage_node_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_node, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_node_compare2" "', argument " "2"" of type '" "semanage_node_t const *""'"); ++ } ++ arg2 = (semanage_node_t *)(argp2); ++ result = (int)semanage_node_compare2((struct semanage_node const *)arg1,(struct semanage_node const *)arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_key_create(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- char *arg2 = (char *) 0 ; +- char *arg3 = (char *) 0 ; +- int arg4 ; +- semanage_node_key_t **arg5 = (semanage_node_key_t **) 0 ; +- int result; +- semanage_node_key_t *temp5 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- PyObject * obj3 = 0 ; +- +- { +- arg5 = &temp5; +- } +- if(!PyArg_ParseTuple(args,(char *)"OOOO:semanage_node_key_create",&obj0,&obj1,&obj2,&obj3)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { +- SWIG_arg_fail(2);SWIG_fail; +- } +- if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- { +- arg4 = (int)(SWIG_As_int(obj3)); +- if (SWIG_arg_fail(4)) SWIG_fail; +- } +- result = (int)semanage_node_key_create(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg5, SWIGTYPE_p_semanage_node_key, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_key_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ char *arg2 = (char *) 0 ; ++ 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 ; ++ char *buf2 = 0 ; ++ int alloc2 = 0 ; ++ int res3 ; ++ char *buf3 = 0 ; ++ int alloc3 = 0 ; ++ int val4 ; ++ int ecode4 = 0 ; ++ semanage_node_key_t *temp5 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ PyObject * obj3 = 0 ; ++ ++ { ++ arg5 = &temp5; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OOOO:semanage_node_key_create",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_key_create" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_node_key_create" "', argument " "2"" of type '" "char const *""'"); ++ } ++ arg2 = buf2; ++ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_node_key_create" "', argument " "3"" of type '" "char const *""'"); ++ } ++ arg3 = buf3; ++ ecode4 = SWIG_AsVal_int(obj3, &val4); ++ if (!SWIG_IsOK(ecode4)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "semanage_node_key_create" "', argument " "4"" of type '" "int""'"); ++ } ++ arg4 = (int)(val4); ++ result = (int)semanage_node_key_create(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg5, SWIGTYPE_p_semanage_node_key, 0)); ++ } ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return resultobj; ++fail: ++ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_key_extract(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_node_key_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_node_key_extract",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_node, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_node_key_extract(arg1,(semanage_node_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_node_key, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_key_extract(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_node_key_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_node_key_extract",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_key_extract" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_node, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_node_key_extract" "', argument " "2"" of type '" "semanage_node_t const *""'"); ++ } ++ arg2 = (semanage_node_t *)(argp2); ++ result = (int)semanage_node_key_extract(arg1,(struct semanage_node const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_node_key, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_key_free(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_node_key_t *arg1 = (semanage_node_key_t *) 0 ; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_node_key_free",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_node_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- semanage_node_key_free(arg1); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_key_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_node_key_t *arg1 = (semanage_node_key_t *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_node_key_free",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_node_key, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_key_free" "', argument " "1"" of type '" "semanage_node_key_t *""'"); ++ } ++ arg1 = (semanage_node_key_t *)(argp1); ++ semanage_node_key_free(arg1); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_get_addr(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_node_t *arg2 = (semanage_node_t *) 0 ; +- char **arg3 = (char **) 0 ; +- int result; +- char *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_node_get_addr",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_node, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_node_get_addr(arg1,(semanage_node_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_FromCharPtr(*arg3)); +- free(*arg3); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_get_addr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ char *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_node_get_addr",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_get_addr" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_node, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_node_get_addr" "', argument " "2"" of type '" "semanage_node_t const *""'"); ++ } ++ arg2 = (semanage_node_t *)(argp2); ++ result = (int)semanage_node_get_addr(arg1,(struct semanage_node const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg3)); ++ free(*arg3); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_get_addr_bytes(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_node_t *arg2 = (semanage_node_t *) 0 ; +- char **arg3 = (char **) 0 ; +- size_t *arg4 = (size_t *) 0 ; +- int result; +- char *temp3 ; +- size_t temp4 ; +- int res4 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- arg4 = &temp4; res4 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_node_get_addr_bytes",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_node, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_node_get_addr_bytes(arg1,(semanage_node_t const *)arg2,arg3,arg4); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_FromCharPtr(*arg3)); +- free(*arg3); +- } +- resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_size_t, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_get_addr_bytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ 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 ; ++ int res2 = 0 ; ++ char *temp3 ; ++ size_t temp4 ; ++ int res4 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ arg4 = &temp4; ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_node_get_addr_bytes",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_get_addr_bytes" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_node, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_node_get_addr_bytes" "', argument " "2"" of type '" "semanage_node_t const *""'"); ++ } ++ arg2 = (semanage_node_t *)(argp2); ++ result = (int)semanage_node_get_addr_bytes(arg1,(struct semanage_node const *)arg2,arg3,arg4); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg3)); ++ free(*arg3); ++ } ++ if (SWIG_IsTmpObj(res4)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_size_t, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_set_addr(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_node_t *arg2 = (semanage_node_t *) 0 ; +- int arg3 ; +- char *arg4 = (char *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- PyObject * obj3 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOOO:semanage_node_set_addr",&obj0,&obj1,&obj2,&obj3)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_node, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- { +- arg3 = (int)(SWIG_As_int(obj2)); +- if (SWIG_arg_fail(3)) SWIG_fail; +- } +- if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) { +- SWIG_arg_fail(4);SWIG_fail; +- } +- result = (int)semanage_node_set_addr(arg1,arg2,arg3,(char const *)arg4); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_set_addr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ 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 ; ++ int res2 = 0 ; ++ int val3 ; ++ int ecode3 = 0 ; ++ int res4 ; ++ char *buf4 = 0 ; ++ int alloc4 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ PyObject * obj3 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_set_addr" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_node, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_node_set_addr" "', argument " "2"" of type '" "semanage_node_t *""'"); ++ } ++ arg2 = (semanage_node_t *)(argp2); ++ ecode3 = SWIG_AsVal_int(obj2, &val3); ++ if (!SWIG_IsOK(ecode3)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "semanage_node_set_addr" "', argument " "3"" of type '" "int""'"); ++ } ++ arg3 = (int)(val3); ++ res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4); ++ if (!SWIG_IsOK(res4)) { ++ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "semanage_node_set_addr" "', argument " "4"" of type '" "char const *""'"); ++ } ++ arg4 = buf4; ++ result = (int)semanage_node_set_addr(arg1,arg2,arg3,(char const *)arg4); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); ++ return resultobj; ++fail: ++ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_set_addr_bytes(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_node_t *arg2 = (semanage_node_t *) 0 ; +- char *arg3 = (char *) 0 ; +- size_t arg4 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- PyObject * obj3 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOOO:semanage_node_set_addr_bytes",&obj0,&obj1,&obj2,&obj3)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_node, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- { +- arg4 = (size_t)(SWIG_As_unsigned_SS_long(obj3)); +- if (SWIG_arg_fail(4)) SWIG_fail; +- } +- result = (int)semanage_node_set_addr_bytes(arg1,arg2,(char const *)arg3,arg4); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_set_addr_bytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ 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 ; ++ int res2 = 0 ; ++ int res3 ; ++ char *buf3 = 0 ; ++ int alloc3 = 0 ; ++ size_t val4 ; ++ int ecode4 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ PyObject * obj3 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_set_addr_bytes" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_node, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_node_set_addr_bytes" "', argument " "2"" of type '" "semanage_node_t *""'"); ++ } ++ arg2 = (semanage_node_t *)(argp2); ++ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_node_set_addr_bytes" "', argument " "3"" of type '" "char const *""'"); ++ } ++ arg3 = buf3; ++ ecode4 = SWIG_AsVal_size_t(obj3, &val4); ++ if (!SWIG_IsOK(ecode4)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "semanage_node_set_addr_bytes" "', argument " "4"" of type '" "size_t""'"); ++ } ++ arg4 = (size_t)(val4); ++ result = (int)semanage_node_set_addr_bytes(arg1,arg2,(char const *)arg3,arg4); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return resultobj; ++fail: ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_get_mask(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_node_t *arg2 = (semanage_node_t *) 0 ; +- char **arg3 = (char **) 0 ; +- int result; +- char *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_node_get_mask",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_node, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_node_get_mask(arg1,(semanage_node_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_FromCharPtr(*arg3)); +- free(*arg3); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_get_mask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ char *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_node_get_mask",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_get_mask" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_node, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_node_get_mask" "', argument " "2"" of type '" "semanage_node_t const *""'"); ++ } ++ arg2 = (semanage_node_t *)(argp2); ++ result = (int)semanage_node_get_mask(arg1,(struct semanage_node const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg3)); ++ free(*arg3); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_get_mask_bytes(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_node_t *arg2 = (semanage_node_t *) 0 ; +- char **arg3 = (char **) 0 ; +- size_t *arg4 = (size_t *) 0 ; +- int result; +- char *temp3 ; +- size_t temp4 ; +- int res4 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- arg4 = &temp4; res4 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_node_get_mask_bytes",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_node, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_node_get_mask_bytes(arg1,(semanage_node_t const *)arg2,arg3,arg4); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_FromCharPtr(*arg3)); +- free(*arg3); +- } +- resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_size_t, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_get_mask_bytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ 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 ; ++ int res2 = 0 ; ++ char *temp3 ; ++ size_t temp4 ; ++ int res4 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ arg4 = &temp4; ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_node_get_mask_bytes",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_get_mask_bytes" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_node, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_node_get_mask_bytes" "', argument " "2"" of type '" "semanage_node_t const *""'"); ++ } ++ arg2 = (semanage_node_t *)(argp2); ++ result = (int)semanage_node_get_mask_bytes(arg1,(struct semanage_node const *)arg2,arg3,arg4); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg3)); ++ free(*arg3); ++ } ++ if (SWIG_IsTmpObj(res4)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_size_t, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_set_mask(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_node_t *arg2 = (semanage_node_t *) 0 ; +- int arg3 ; +- char *arg4 = (char *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- PyObject * obj3 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOOO:semanage_node_set_mask",&obj0,&obj1,&obj2,&obj3)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_node, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- { +- arg3 = (int)(SWIG_As_int(obj2)); +- if (SWIG_arg_fail(3)) SWIG_fail; +- } +- if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) { +- SWIG_arg_fail(4);SWIG_fail; +- } +- result = (int)semanage_node_set_mask(arg1,arg2,arg3,(char const *)arg4); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_set_mask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ 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 ; ++ int res2 = 0 ; ++ int val3 ; ++ int ecode3 = 0 ; ++ int res4 ; ++ char *buf4 = 0 ; ++ int alloc4 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ PyObject * obj3 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_set_mask" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_node, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_node_set_mask" "', argument " "2"" of type '" "semanage_node_t *""'"); ++ } ++ arg2 = (semanage_node_t *)(argp2); ++ ecode3 = SWIG_AsVal_int(obj2, &val3); ++ if (!SWIG_IsOK(ecode3)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "semanage_node_set_mask" "', argument " "3"" of type '" "int""'"); ++ } ++ arg3 = (int)(val3); ++ res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4); ++ if (!SWIG_IsOK(res4)) { ++ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "semanage_node_set_mask" "', argument " "4"" of type '" "char const *""'"); ++ } ++ arg4 = buf4; ++ result = (int)semanage_node_set_mask(arg1,arg2,arg3,(char const *)arg4); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); ++ return resultobj; ++fail: ++ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_set_mask_bytes(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_node_t *arg2 = (semanage_node_t *) 0 ; +- char *arg3 = (char *) 0 ; +- size_t arg4 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- PyObject * obj3 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOOO:semanage_node_set_mask_bytes",&obj0,&obj1,&obj2,&obj3)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_node, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- { +- arg4 = (size_t)(SWIG_As_unsigned_SS_long(obj3)); +- if (SWIG_arg_fail(4)) SWIG_fail; +- } +- result = (int)semanage_node_set_mask_bytes(arg1,arg2,(char const *)arg3,arg4); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_set_mask_bytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ 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 ; ++ int res2 = 0 ; ++ int res3 ; ++ char *buf3 = 0 ; ++ int alloc3 = 0 ; ++ size_t val4 ; ++ int ecode4 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ PyObject * obj3 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_set_mask_bytes" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_node, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_node_set_mask_bytes" "', argument " "2"" of type '" "semanage_node_t *""'"); ++ } ++ arg2 = (semanage_node_t *)(argp2); ++ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_node_set_mask_bytes" "', argument " "3"" of type '" "char const *""'"); ++ } ++ arg3 = buf3; ++ ecode4 = SWIG_AsVal_size_t(obj3, &val4); ++ if (!SWIG_IsOK(ecode4)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "semanage_node_set_mask_bytes" "', argument " "4"" of type '" "size_t""'"); ++ } ++ arg4 = (size_t)(val4); ++ result = (int)semanage_node_set_mask_bytes(arg1,arg2,(char const *)arg3,arg4); ++ resultobj = SWIG_From_int((int)(result)); ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return resultobj; ++fail: ++ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_get_proto(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_node_t *arg1 = (semanage_node_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_node_get_proto",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_node, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_node_get_proto((semanage_node_t const *)arg1); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_node_get_proto",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_node, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_get_proto" "', argument " "1"" of type '" "semanage_node_t const *""'"); ++ } ++ arg1 = (semanage_node_t *)(argp1); ++ result = (int)semanage_node_get_proto((struct semanage_node const *)arg1); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_set_proto(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_node_t *arg1 = (semanage_node_t *) 0 ; +- int arg2 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_node_set_proto",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_node, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- { +- arg2 = (int)(SWIG_As_int(obj1)); +- if (SWIG_arg_fail(2)) SWIG_fail; +- } +- semanage_node_set_proto(arg1,arg2); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_set_proto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_node_t *arg1 = (semanage_node_t *) 0 ; ++ int arg2 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ int val2 ; ++ int ecode2 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_node_set_proto",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_node, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_set_proto" "', argument " "1"" of type '" "semanage_node_t *""'"); ++ } ++ arg1 = (semanage_node_t *)(argp1); ++ ecode2 = SWIG_AsVal_int(obj1, &val2); ++ if (!SWIG_IsOK(ecode2)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "semanage_node_set_proto" "', argument " "2"" of type '" "int""'"); ++ } ++ arg2 = (int)(val2); ++ semanage_node_set_proto(arg1,arg2); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_get_proto_str(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- int arg1 ; +- char *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_node_get_proto_str",&obj0)) goto fail; +- { +- arg1 = (int)(SWIG_As_int(obj0)); +- if (SWIG_arg_fail(1)) SWIG_fail; +- } +- result = (char *)semanage_node_get_proto_str(arg1); +- +- resultobj = SWIG_FromCharPtr(result); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_node_get_proto_str",&obj0)) SWIG_fail; ++ ecode1 = SWIG_AsVal_int(obj0, &val1); ++ if (!SWIG_IsOK(ecode1)) { ++ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "semanage_node_get_proto_str" "', argument " "1"" of type '" "int""'"); ++ } ++ arg1 = (int)(val1); ++ result = (char *)semanage_node_get_proto_str(arg1); ++ resultobj = SWIG_FromCharPtr(result); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_get_con(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_node_t *arg1 = (semanage_node_t *) 0 ; +- semanage_context_t *result; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_node_get_con",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_node, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (semanage_context_t *)semanage_node_get_con((semanage_node_t const *)arg1); +- +- resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_semanage_context, 0); +- return resultobj; +- fail: +- return NULL; ++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 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_node_get_con",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_node, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_get_con" "', argument " "1"" of type '" "semanage_node_t const *""'"); ++ } ++ arg1 = (semanage_node_t *)(argp1); ++ result = (semanage_context_t *)semanage_node_get_con((struct semanage_node const *)arg1); ++ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_semanage_context, 0 | 0 ); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_set_con(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_node_set_con",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_node, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_node_set_con(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_set_con(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ void *argp3 = 0 ; ++ int res3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_set_con" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_node, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_node_set_con" "', argument " "2"" of type '" "semanage_node_t *""'"); ++ } ++ arg2 = (semanage_node_t *)(argp2); ++ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_semanage_context, 0 | 0 ); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_node_set_con" "', argument " "3"" of type '" "semanage_context_t *""'"); ++ } ++ arg3 = (semanage_context_t *)(argp3); ++ result = (int)semanage_node_set_con(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_create(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_node_t **arg2 = (semanage_node_t **) 0 ; +- int result; +- semanage_node_t *temp2 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; +- } +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_node_create",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_node_create(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_semanage_node, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_node_create",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_create" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_node_create(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_semanage_node, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_clone(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_node_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_node_clone",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_node, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_node_clone(arg1,(semanage_node_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_node, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_node_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_node_clone",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_clone" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_node, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_node_clone" "', argument " "2"" of type '" "semanage_node_t const *""'"); ++ } ++ arg2 = (semanage_node_t *)(argp2); ++ result = (int)semanage_node_clone(arg1,(struct semanage_node const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_node, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_free(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_node_t *arg1 = (semanage_node_t *) 0 ; +- PyObject * obj0 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_node_free",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_node, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- semanage_node_free(arg1); +- +- Py_INCREF(Py_None); resultobj = Py_None; +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ semanage_node_t *arg1 = (semanage_node_t *) 0 ; ++ void *argp1 = 0 ; ++ int res1 = 0 ; ++ PyObject * obj0 = 0 ; ++ ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_node_free",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_node, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_free" "', argument " "1"" of type '" "semanage_node_t *""'"); ++ } ++ arg1 = (semanage_node_t *)(argp1); ++ semanage_node_free(arg1); ++ resultobj = SWIG_Py_Void(); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_modify_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_node_modify_local",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_node_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_semanage_node, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_node_modify_local(arg1,(semanage_node_key_t const *)arg2,(semanage_node_t const *)arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_modify_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ void *argp3 = 0 ; ++ int res3 = 0 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_modify_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_node_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_node_modify_local" "', argument " "2"" of type '" "semanage_node_key_t const *""'"); ++ } ++ arg2 = (semanage_node_key_t *)(argp2); ++ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_semanage_node, 0 | 0 ); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_node_modify_local" "', argument " "3"" of type '" "semanage_node_t const *""'"); ++ } ++ arg3 = (semanage_node_t *)(argp3); ++ result = (int)semanage_node_modify_local(arg1,(struct semanage_node_key const *)arg2,(struct semanage_node const *)arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_del_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_node_key_t *arg2 = (semanage_node_key_t *) 0 ; +- int result; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_node_del_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_node_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_node_del_local(arg1,(semanage_node_key_t const *)arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_del_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_del_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_node_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_node_del_local" "', argument " "2"" of type '" "semanage_node_key_t const *""'"); ++ } ++ arg2 = (semanage_node_key_t *)(argp2); ++ result = (int)semanage_node_del_local(arg1,(struct semanage_node_key const *)arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_query_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_node_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_node_query_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_node_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_node_query_local(arg1,(semanage_node_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_node, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_query_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_node_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_node_query_local",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_query_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_node_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_node_query_local" "', argument " "2"" of type '" "semanage_node_key_t const *""'"); ++ } ++ arg2 = (semanage_node_key_t *)(argp2); ++ result = (int)semanage_node_query_local(arg1,(struct semanage_node_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_node, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_exists_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_node_key_t *arg2 = (semanage_node_key_t *) 0 ; +- int *arg3 = (int *) 0 ; +- int result; +- int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_node_exists_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_node_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_node_exists_local(arg1,(semanage_node_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_exists_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_node_exists_local",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_exists_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_node_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_node_exists_local" "', argument " "2"" of type '" "semanage_node_key_t const *""'"); ++ } ++ arg2 = (semanage_node_key_t *)(argp2); ++ result = (int)semanage_node_exists_local(arg1,(struct semanage_node_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res3)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_count_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- unsigned int *arg2 = (unsigned int *) 0 ; +- int result; +- unsigned int temp2 ; +- int res2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; res2 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_node_count_local",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_node_count_local(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_count_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ arg2 = &temp2; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_node_count_local",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_count_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_node_count_local(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res2)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_iterate_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_node_iterate_local",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_q_const__struct_semanage_node_p_void__int, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- { +- if ((SWIG_ConvertPtr(obj2,(void **)(&arg3),0,SWIG_POINTER_EXCEPTION|0))== -1) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- } +- result = (int)semanage_node_iterate_local(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_iterate_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_iterate_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__struct_semanage_node_p_void__int); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "semanage_node_iterate_local" "', argument " "2"" of type '" "int (*)(semanage_node_t const *,void *)""'"); ++ } ++ } ++ res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_node_iterate_local" "', argument " "3"" of type '" "void *""'"); ++ } ++ result = (int)semanage_node_iterate_local(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_list_local(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_node_t ***arg2 = (semanage_node_t ***) 0 ; +- unsigned int *arg3 = (unsigned int *) 0 ; +- int result; +- semanage_node_t **temp2 ; +- unsigned int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; +- } +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_node_list_local",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_node_list_local(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- if (resultobj) { +- int value = SWIG_As_int(resultobj); +- if (value >= 0) { +- PyObject* plist = NULL; +- if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_node, +- (void (*) (void*)) &semanage_node_free, &plist) < 0) +- resultobj = SWIG_From_int(STATUS_ERR); +- else +- resultobj = t_output_helper(resultobj, plist); +- } +- } ++SWIGINTERN PyObject *_wrap_semanage_node_list_local(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ unsigned int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_node_list_local",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_list_local" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_node_list_local(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ if (resultobj) { ++ int value; ++ SWIG_AsVal_int(resultobj, &value); ++ if (value >= 0) { ++ PyObject* plist = NULL; ++ if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_node, ++ (void (*) (void*)) &semanage_node_free, &plist) < 0) ++ resultobj = SWIG_From_int(STATUS_ERR); ++ else ++ resultobj = SWIG_Python_AppendOutput(resultobj, plist); ++ } + } +- return resultobj; +- fail: +- return NULL; ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_query(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- semanage_node_t *temp3 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_node_query",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_node_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_node_query(arg1,(semanage_node_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_node, 0)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_query(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ semanage_node_t *temp3 ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ { ++ arg3 = &temp3; ++ } ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_node_query",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_query" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_node_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_node_query" "', argument " "2"" of type '" "semanage_node_key_t const *""'"); ++ } ++ arg2 = (semanage_node_key_t *)(argp2); ++ result = (int)semanage_node_query(arg1,(struct semanage_node_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_node, 0)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_exists(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_node_key_t *arg2 = (semanage_node_key_t *) 0 ; +- int *arg3 = (int *) 0 ; +- int result; +- int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_node_exists",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_node_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_node_exists(arg1,(semanage_node_key_t const *)arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ int res2 = 0 ; ++ int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"OO:semanage_node_exists",&obj0,&obj1)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_exists" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_semanage_node_key, 0 | 0 ); ++ if (!SWIG_IsOK(res2)) { ++ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "semanage_node_exists" "', argument " "2"" of type '" "semanage_node_key_t const *""'"); ++ } ++ arg2 = (semanage_node_key_t *)(argp2); ++ result = (int)semanage_node_exists(arg1,(struct semanage_node_key const *)arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res3)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_count(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- unsigned int *arg2 = (unsigned int *) 0 ; +- int result; +- unsigned int temp2 ; +- int res2 = 0 ; +- PyObject * obj0 = 0 ; +- +- arg2 = &temp2; res2 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_node_count",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_node_count(arg1,arg2); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, 0))); +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ 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 ; ++ ++ arg2 = &temp2; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_node_count",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_count" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_node_count(arg1,arg2); ++ resultobj = SWIG_From_int((int)(result)); ++ if (SWIG_IsTmpObj(res2)) { ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); ++ } else { ++ int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; ++ resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_iterate(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- 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; +- PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; +- +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_node_iterate",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_q_const__struct_semanage_node_p_void__int, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- { +- if ((SWIG_ConvertPtr(obj2,(void **)(&arg3),0,SWIG_POINTER_EXCEPTION|0))== -1) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- } +- result = (int)semanage_node_iterate(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- return resultobj; +- fail: +- return NULL; ++SWIGINTERN PyObject *_wrap_semanage_node_iterate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ ++ 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 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_iterate" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ { ++ int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__struct_semanage_node_p_void__int); ++ if (!SWIG_IsOK(res)) { ++ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "semanage_node_iterate" "', argument " "2"" of type '" "int (*)(semanage_node_t const *,void *)""'"); ++ } ++ } ++ res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0); ++ if (!SWIG_IsOK(res3)) { ++ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "semanage_node_iterate" "', argument " "3"" of type '" "void *""'"); ++ } ++ result = (int)semanage_node_iterate(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ return resultobj; ++fail: ++ return NULL; + } + + +-static PyObject *_wrap_semanage_node_list(PyObject *self, PyObject *args) { +- PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_node_t ***arg2 = (semanage_node_t ***) 0 ; +- unsigned int *arg3 = (unsigned int *) 0 ; +- int result; +- semanage_node_t **temp2 ; +- unsigned int temp3 ; +- int res3 = 0 ; +- PyObject * obj0 = 0 ; +- +- { +- arg2 = &temp2; +- } +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_node_list",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(1)) SWIG_fail; +- result = (int)semanage_node_list(arg1,arg2,arg3); +- +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- if (resultobj) { +- int value = SWIG_As_int(resultobj); +- if (value >= 0) { +- PyObject* plist = NULL; +- if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_node, +- (void (*) (void*)) &semanage_node_free, &plist) < 0) +- resultobj = SWIG_From_int(STATUS_ERR); +- else +- resultobj = t_output_helper(resultobj, plist); +- } +- } ++SWIGINTERN PyObject *_wrap_semanage_node_list(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { ++ PyObject *resultobj = 0; ++ 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 ; ++ unsigned int temp3 ; ++ int res3 = SWIG_TMPOBJ ; ++ PyObject * obj0 = 0 ; ++ ++ { ++ arg2 = &temp2; ++ } ++ arg3 = &temp3; ++ if (!PyArg_ParseTuple(args,(char *)"O:semanage_node_list",&obj0)) SWIG_fail; ++ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_semanage_handle, 0 | 0 ); ++ if (!SWIG_IsOK(res1)) { ++ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semanage_node_list" "', argument " "1"" of type '" "semanage_handle_t *""'"); ++ } ++ arg1 = (semanage_handle_t *)(argp1); ++ result = (int)semanage_node_list(arg1,arg2,arg3); ++ resultobj = SWIG_From_int((int)(result)); ++ { ++ if (resultobj) { ++ int value; ++ SWIG_AsVal_int(resultobj, &value); ++ if (value >= 0) { ++ PyObject* plist = NULL; ++ if (semanage_array2plist(arg1, (void**) *arg2, *arg3, SWIGTYPE_p_semanage_node, ++ (void (*) (void*)) &semanage_node_free, &plist) < 0) ++ resultobj = SWIG_From_int(STATUS_ERR); ++ else ++ resultobj = SWIG_Python_AppendOutput(resultobj, plist); ++ } + } +- return resultobj; +- fail: +- return NULL; ++ } ++ return resultobj; ++fail: ++ return NULL; + } + + +@@ -8946,121 +11580,228 @@ + + /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + +-static swig_type_info _swigt__p_semanage_node[] = {{"_p_semanage_node", 0, "struct semanage_node *|semanage_node_t *", 0, 0, 0, 0},{"_p_semanage_node", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_semanage_node[] = {{"_p_p_semanage_node", 0, "struct semanage_node **|semanage_node_t **", 0, 0, 0, 0},{"_p_p_semanage_node", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_p_semanage_node[] = {{"_p_p_p_semanage_node", 0, "struct semanage_node ***|semanage_node_t ***", 0, 0, 0, 0},{"_p_p_p_semanage_node", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_f_p_q_const__struct_semanage_user_p_void__int[] = {{"_p_f_p_q_const__struct_semanage_user_p_void__int", 0, "int (*)(struct semanage_user const *,void *)|int (*)(semanage_user_t const *,void *)", 0, 0, 0, 0},{"_p_f_p_q_const__struct_semanage_user_p_void__int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_f_p_q_const__struct_semanage_iface_p_void__int[] = {{"_p_f_p_q_const__struct_semanage_iface_p_void__int", 0, "int (*)(struct semanage_iface const *,void *)|int (*)(semanage_iface_t const *,void *)", 0, 0, 0, 0},{"_p_f_p_q_const__struct_semanage_iface_p_void__int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_f_p_q_const__struct_semanage_bool_p_void__int[] = {{"_p_f_p_q_const__struct_semanage_bool_p_void__int", 0, "int (*)(struct semanage_bool const *,void *)|int (*)(semanage_bool_t const *,void *)", 0, 0, 0, 0},{"_p_f_p_q_const__struct_semanage_bool_p_void__int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_p_char[] = {{"_p_p_p_char", 0, "char ***", 0, 0, 0, 0},{"_p_p_p_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_char[] = {{"_p_char", 0, "char *", 0, 0, 0, 0},{"_p_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_char[] = {{"_p_p_char", 0, "char **", 0, 0, 0, 0},{"_p_p_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_semanage_port_key[] = {{"_p_p_semanage_port_key", 0, "struct semanage_port_key **|semanage_port_key_t **", 0, 0, 0, 0},{"_p_p_semanage_port_key", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_semanage_port_key[] = {{"_p_semanage_port_key", 0, "struct semanage_port_key *|semanage_port_key_t *", 0, 0, 0, 0},{"_p_semanage_port_key", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_f_p_q_const__struct_semanage_port_p_void__int[] = {{"_p_f_p_q_const__struct_semanage_port_p_void__int", 0, "int (*)(struct semanage_port const *,void *)|int (*)(semanage_port_t const *,void *)", 0, 0, 0, 0},{"_p_f_p_q_const__struct_semanage_port_p_void__int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_f_p_q_const__struct_semanage_seuser_p_void__int[] = {{"_p_f_p_q_const__struct_semanage_seuser_p_void__int", 0, "int (*)(struct semanage_seuser const *,void *)|int (*)(semanage_seuser_t const *,void *)", 0, 0, 0, 0},{"_p_f_p_q_const__struct_semanage_seuser_p_void__int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_f_p_q_const__struct_semanage_node_p_void__int[] = {{"_p_f_p_q_const__struct_semanage_node_p_void__int", 0, "int (*)(struct semanage_node const *,void *)|int (*)(semanage_node_t const *,void *)", 0, 0, 0, 0},{"_p_f_p_q_const__struct_semanage_node_p_void__int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_semanage_seuser[] = {{"_p_semanage_seuser", 0, "struct semanage_seuser *|semanage_seuser_t *", 0, 0, 0, 0},{"_p_semanage_seuser", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_semanage_seuser[] = {{"_p_p_semanage_seuser", 0, "struct semanage_seuser **|semanage_seuser_t **", 0, 0, 0, 0},{"_p_p_semanage_seuser", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_p_semanage_seuser[] = {{"_p_p_p_semanage_seuser", 0, "struct semanage_seuser ***|semanage_seuser_t ***", 0, 0, 0, 0},{"_p_p_p_semanage_seuser", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_semanage_node_key[] = {{"_p_semanage_node_key", 0, "struct semanage_node_key *|semanage_node_key_t *", 0, 0, 0, 0},{"_p_semanage_node_key", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_semanage_node_key[] = {{"_p_p_semanage_node_key", 0, "struct semanage_node_key **|semanage_node_key_t **", 0, 0, 0, 0},{"_p_p_semanage_node_key", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_p_semanage_bool[] = {{"_p_p_p_semanage_bool", 0, "struct semanage_bool ***|semanage_bool_t ***", 0, 0, 0, 0},{"_p_p_p_semanage_bool", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_semanage_bool[] = {{"_p_p_semanage_bool", 0, "struct semanage_bool **|semanage_bool_t **", 0, 0, 0, 0},{"_p_p_semanage_bool", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_semanage_bool[] = {{"_p_semanage_bool", 0, "struct semanage_bool *|semanage_bool_t *", 0, 0, 0, 0},{"_p_semanage_bool", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_p_semanage_user[] = {{"_p_p_p_semanage_user", 0, "struct semanage_user ***|semanage_user_t ***", 0, 0, 0, 0},{"_p_p_p_semanage_user", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_semanage_user[] = {{"_p_p_semanage_user", 0, "struct semanage_user **|semanage_user_t **", 0, 0, 0, 0},{"_p_p_semanage_user", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_semanage_user[] = {{"_p_semanage_user", 0, "struct semanage_user *|semanage_user_t *", 0, 0, 0, 0},{"_p_semanage_user", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__size_t[] = {{"_size_t", 0, "size_t", 0, 0, 0, 0},{"_size_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_size_t[] = {{"_p_size_t", 0, "size_t *", 0, 0, 0, 0},{"_p_size_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_semanage_user_key[] = {{"_p_p_semanage_user_key", 0, "struct semanage_user_key **|semanage_user_key_t **", 0, 0, 0, 0},{"_p_p_semanage_user_key", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_semanage_user_key[] = {{"_p_semanage_user_key", 0, "struct semanage_user_key *|semanage_user_key_t *", 0, 0, 0, 0},{"_p_semanage_user_key", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_semanage_seuser_key[] = {{"_p_semanage_seuser_key", 0, "struct semanage_seuser_key *|semanage_seuser_key_t *", 0, 0, 0, 0},{"_p_semanage_seuser_key", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_semanage_seuser_key[] = {{"_p_p_semanage_seuser_key", 0, "struct semanage_seuser_key **|semanage_seuser_key_t **", 0, 0, 0, 0},{"_p_p_semanage_seuser_key", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_p_semanage_iface[] = {{"_p_p_p_semanage_iface", 0, "struct semanage_iface ***|semanage_iface_t ***", 0, 0, 0, 0},{"_p_p_p_semanage_iface", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_semanage_iface[] = {{"_p_p_semanage_iface", 0, "struct semanage_iface **|semanage_iface_t **", 0, 0, 0, 0},{"_p_p_semanage_iface", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_semanage_iface[] = {{"_p_semanage_iface", 0, "struct semanage_iface *|semanage_iface_t *", 0, 0, 0, 0},{"_p_semanage_iface", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_semanage_bool_key[] = {{"_p_semanage_bool_key", 0, "struct semanage_bool_key *|semanage_bool_key_t *", 0, 0, 0, 0},{"_p_semanage_bool_key", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_semanage_bool_key[] = {{"_p_p_semanage_bool_key", 0, "struct semanage_bool_key **|semanage_bool_key_t **", 0, 0, 0, 0},{"_p_p_semanage_bool_key", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_semanage_fcontext_key[] = {{"_p_semanage_fcontext_key", 0, "struct semanage_fcontext_key *|semanage_fcontext_key_t *", 0, 0, 0, 0},{"_p_semanage_fcontext_key", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_semanage_fcontext_key[] = {{"_p_p_semanage_fcontext_key", 0, "struct semanage_fcontext_key **|semanage_fcontext_key_t **", 0, 0, 0, 0},{"_p_p_semanage_fcontext_key", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_f_p_q_const__struct_semanage_fcontext_p_void__int[] = {{"_p_f_p_q_const__struct_semanage_fcontext_p_void__int", 0, "int (*)(struct semanage_fcontext const *,void *)|int (*)(semanage_fcontext_t const *,void *)", 0, 0, 0, 0},{"_p_f_p_q_const__struct_semanage_fcontext_p_void__int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_unsigned_int[] = {{"_p_unsigned_int", 0, "unsigned int *", 0, 0, 0, 0},{"_p_unsigned_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_semanage_context[] = {{"_p_semanage_context", 0, "struct semanage_context *|semanage_context_t *", 0, 0, 0, 0},{"_p_semanage_context", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_semanage_context[] = {{"_p_p_semanage_context", 0, "struct semanage_context **|semanage_context_t **", 0, 0, 0, 0},{"_p_p_semanage_context", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_semanage_fcontext[] = {{"_p_semanage_fcontext", 0, "struct semanage_fcontext *|semanage_fcontext_t *", 0, 0, 0, 0},{"_p_semanage_fcontext", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_semanage_fcontext[] = {{"_p_p_semanage_fcontext", 0, "struct semanage_fcontext **|semanage_fcontext_t **", 0, 0, 0, 0},{"_p_p_semanage_fcontext", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_p_semanage_fcontext[] = {{"_p_p_p_semanage_fcontext", 0, "struct semanage_fcontext ***|semanage_fcontext_t ***", 0, 0, 0, 0},{"_p_p_p_semanage_fcontext", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_semanage_module_info[] = {{"_p_semanage_module_info", 0, "struct semanage_module_info *|semanage_module_info_t *", 0, 0, 0, 0},{"_p_semanage_module_info", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_semanage_module_info[] = {{"_p_p_semanage_module_info", 0, "struct semanage_module_info **|semanage_module_info_t **", 0, 0, 0, 0},{"_p_p_semanage_module_info", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_semanage_iface_key[] = {{"_p_p_semanage_iface_key", 0, "struct semanage_iface_key **|semanage_iface_key_t **", 0, 0, 0, 0},{"_p_p_semanage_iface_key", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_semanage_iface_key[] = {{"_p_semanage_iface_key", 0, "struct semanage_iface_key *|semanage_iface_key_t *", 0, 0, 0, 0},{"_p_semanage_iface_key", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_f_p_void_p_struct_semanage_handle_p_q_const__char_v_______void[] = {{"_p_f_p_void_p_struct_semanage_handle_p_q_const__char_v_______void", 0, "void (*)(void *,struct semanage_handle *,char const *,...)|void (*)(void *,semanage_handle_t *,char const *,...)", 0, 0, 0, 0},{"_p_f_p_void_p_struct_semanage_handle_p_q_const__char_v_______void", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__ptrdiff_t[] = {{"_ptrdiff_t", 0, "ptrdiff_t", 0, 0, 0, 0},{"_ptrdiff_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_semanage_port[] = {{"_p_semanage_port", 0, "struct semanage_port *|semanage_port_t *", 0, 0, 0, 0},{"_p_semanage_port", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_semanage_port[] = {{"_p_p_semanage_port", 0, "struct semanage_port **|semanage_port_t **", 0, 0, 0, 0},{"_p_p_semanage_port", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_p_p_semanage_port[] = {{"_p_p_p_semanage_port", 0, "struct semanage_port ***|semanage_port_t ***", 0, 0, 0, 0},{"_p_p_p_semanage_port", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_int[] = {{"_p_int", 0, "int *", 0, 0, 0, 0},{"_p_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_semanage_handle[] = {{"_p_semanage_handle", 0, "struct semanage_handle *|semanage_handle_t *", 0, 0, 0, 0},{"_p_semanage_handle", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +- +-static swig_type_info *swig_types_initial[] = { +-_swigt__p_semanage_node, +-_swigt__p_p_semanage_node, +-_swigt__p_p_p_semanage_node, +-_swigt__p_f_p_q_const__struct_semanage_user_p_void__int, +-_swigt__p_f_p_q_const__struct_semanage_iface_p_void__int, +-_swigt__p_f_p_q_const__struct_semanage_bool_p_void__int, +-_swigt__p_p_p_char, +-_swigt__p_char, +-_swigt__p_p_char, +-_swigt__p_p_semanage_port_key, +-_swigt__p_semanage_port_key, +-_swigt__p_f_p_q_const__struct_semanage_port_p_void__int, +-_swigt__p_f_p_q_const__struct_semanage_seuser_p_void__int, +-_swigt__p_f_p_q_const__struct_semanage_node_p_void__int, +-_swigt__p_semanage_seuser, +-_swigt__p_p_semanage_seuser, +-_swigt__p_p_p_semanage_seuser, +-_swigt__p_semanage_node_key, +-_swigt__p_p_semanage_node_key, +-_swigt__p_p_p_semanage_bool, +-_swigt__p_p_semanage_bool, +-_swigt__p_semanage_bool, +-_swigt__p_p_p_semanage_user, +-_swigt__p_p_semanage_user, +-_swigt__p_semanage_user, +-_swigt__size_t, +-_swigt__p_size_t, +-_swigt__p_p_semanage_user_key, +-_swigt__p_semanage_user_key, +-_swigt__p_semanage_seuser_key, +-_swigt__p_p_semanage_seuser_key, +-_swigt__p_p_p_semanage_iface, +-_swigt__p_p_semanage_iface, +-_swigt__p_semanage_iface, +-_swigt__p_semanage_bool_key, +-_swigt__p_p_semanage_bool_key, +-_swigt__p_semanage_fcontext_key, +-_swigt__p_p_semanage_fcontext_key, +-_swigt__p_f_p_q_const__struct_semanage_fcontext_p_void__int, +-_swigt__p_unsigned_int, +-_swigt__p_semanage_context, +-_swigt__p_p_semanage_context, +-_swigt__p_semanage_fcontext, +-_swigt__p_p_semanage_fcontext, +-_swigt__p_p_p_semanage_fcontext, +-_swigt__p_semanage_module_info, +-_swigt__p_p_semanage_module_info, +-_swigt__p_p_semanage_iface_key, +-_swigt__p_semanage_iface_key, +-_swigt__p_f_p_void_p_struct_semanage_handle_p_q_const__char_v_______void, +-_swigt__ptrdiff_t, +-_swigt__p_semanage_port, +-_swigt__p_p_semanage_port, +-_swigt__p_p_p_semanage_port, +-_swigt__p_int, +-_swigt__p_semanage_handle, +-0 ++static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_f_p_q_const__struct_semanage_bool_p_void__int = {"_p_f_p_q_const__struct_semanage_bool_p_void__int", "int (*)(struct semanage_bool const *,void *)|int (*)(semanage_bool_t const *,void *)", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_f_p_q_const__struct_semanage_fcontext_p_void__int = {"_p_f_p_q_const__struct_semanage_fcontext_p_void__int", "int (*)(struct semanage_fcontext const *,void *)|int (*)(semanage_fcontext_t const *,void *)", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_f_p_q_const__struct_semanage_iface_p_void__int = {"_p_f_p_q_const__struct_semanage_iface_p_void__int", "int (*)(struct semanage_iface const *,void *)|int (*)(semanage_iface_t const *,void *)", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_f_p_q_const__struct_semanage_node_p_void__int = {"_p_f_p_q_const__struct_semanage_node_p_void__int", "int (*)(struct semanage_node const *,void *)|int (*)(semanage_node_t const *,void *)", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_f_p_q_const__struct_semanage_port_p_void__int = {"_p_f_p_q_const__struct_semanage_port_p_void__int", "int (*)(struct semanage_port const *,void *)|int (*)(semanage_port_t const *,void *)", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_f_p_q_const__struct_semanage_seuser_p_void__int = {"_p_f_p_q_const__struct_semanage_seuser_p_void__int", "int (*)(struct semanage_seuser const *,void *)|int (*)(semanage_seuser_t const *,void *)", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_f_p_q_const__struct_semanage_user_p_void__int = {"_p_f_p_q_const__struct_semanage_user_p_void__int", "int (*)(struct semanage_user const *,void *)|int (*)(semanage_user_t const *,void *)", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_f_p_void_p_struct_semanage_handle_p_q_const__char_v_______void = {"_p_f_p_void_p_struct_semanage_handle_p_q_const__char_v_______void", "void (*)(void *,struct semanage_handle *,char const *,...)|void (*)(void *,semanage_handle_t *,char const *,...)", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_p_p_char = {"_p_p_p_char", "char ***", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_p_p_semanage_bool = {"_p_p_p_semanage_bool", "struct semanage_bool ***|semanage_bool_t ***", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_p_p_semanage_fcontext = {"_p_p_p_semanage_fcontext", "struct semanage_fcontext ***|semanage_fcontext_t ***", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_p_p_semanage_iface = {"_p_p_p_semanage_iface", "struct semanage_iface ***|semanage_iface_t ***", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_p_p_semanage_node = {"_p_p_p_semanage_node", "struct semanage_node ***|semanage_node_t ***", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_p_p_semanage_port = {"_p_p_p_semanage_port", "struct semanage_port ***|semanage_port_t ***", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_p_p_semanage_seuser = {"_p_p_p_semanage_seuser", "struct semanage_seuser ***|semanage_seuser_t ***", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_p_p_semanage_user = {"_p_p_p_semanage_user", "struct semanage_user ***|semanage_user_t ***", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_p_semanage_bool = {"_p_p_semanage_bool", "struct semanage_bool **|semanage_bool_t **", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_p_semanage_bool_key = {"_p_p_semanage_bool_key", "struct semanage_bool_key **|semanage_bool_key_t **", 0, 0, (void*)0, 0}; ++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", "struct semanage_fcontext_key **|semanage_fcontext_key_t **", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_p_semanage_iface = {"_p_p_semanage_iface", "struct semanage_iface **|semanage_iface_t **", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_p_semanage_iface_key = {"_p_p_semanage_iface_key", "struct semanage_iface_key **|semanage_iface_key_t **", 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}; ++static swig_type_info _swigt__p_p_semanage_node = {"_p_p_semanage_node", "struct semanage_node **|semanage_node_t **", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_p_semanage_node_key = {"_p_p_semanage_node_key", "struct semanage_node_key **|semanage_node_key_t **", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_p_semanage_port = {"_p_p_semanage_port", "struct semanage_port **|semanage_port_t **", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_p_semanage_port_key = {"_p_p_semanage_port_key", "struct semanage_port_key **|semanage_port_key_t **", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_p_semanage_seuser = {"_p_p_semanage_seuser", "struct semanage_seuser **|semanage_seuser_t **", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_p_semanage_seuser_key = {"_p_p_semanage_seuser_key", "struct semanage_seuser_key **|semanage_seuser_key_t **", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_p_semanage_user = {"_p_p_semanage_user", "struct semanage_user **|semanage_user_t **", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_p_semanage_user_key = {"_p_p_semanage_user_key", "struct semanage_user_key **|semanage_user_key_t **", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_semanage_bool = {"_p_semanage_bool", "struct semanage_bool *|semanage_bool_t *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_semanage_bool_key = {"_p_semanage_bool_key", "struct semanage_bool_key *|semanage_bool_key_t *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_semanage_context = {"_p_semanage_context", "struct semanage_context *|semanage_context_t *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_semanage_fcontext = {"_p_semanage_fcontext", "struct semanage_fcontext *|semanage_fcontext_t *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_semanage_fcontext_key = {"_p_semanage_fcontext_key", "struct semanage_fcontext_key *|semanage_fcontext_key_t *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_semanage_handle = {"_p_semanage_handle", "struct semanage_handle *|semanage_handle_t *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_semanage_iface = {"_p_semanage_iface", "struct semanage_iface *|semanage_iface_t *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_semanage_iface_key = {"_p_semanage_iface_key", "struct semanage_iface_key *|semanage_iface_key_t *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_semanage_module_info = {"_p_semanage_module_info", "struct semanage_module_info *|semanage_module_info_t *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_semanage_node = {"_p_semanage_node", "struct semanage_node *|semanage_node_t *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_semanage_node_key = {"_p_semanage_node_key", "struct semanage_node_key *|semanage_node_key_t *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_semanage_port = {"_p_semanage_port", "struct semanage_port *|semanage_port_t *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_semanage_port_key = {"_p_semanage_port_key", "struct semanage_port_key *|semanage_port_key_t *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_semanage_seuser = {"_p_semanage_seuser", "struct semanage_seuser *|semanage_seuser_t *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_semanage_seuser_key = {"_p_semanage_seuser_key", "struct semanage_seuser_key *|semanage_seuser_key_t *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_semanage_user = {"_p_semanage_user", "struct semanage_user *|semanage_user_t *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_semanage_user_key = {"_p_semanage_user_key", "struct semanage_user_key *|semanage_user_key_t *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_size_t = {"_p_size_t", "size_t *", 0, 0, (void*)0, 0}; ++static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *", 0, 0, (void*)0, 0}; ++ ++static swig_type_info *swig_type_initial[] = { ++ &_swigt__p_char, ++ &_swigt__p_f_p_q_const__struct_semanage_bool_p_void__int, ++ &_swigt__p_f_p_q_const__struct_semanage_fcontext_p_void__int, ++ &_swigt__p_f_p_q_const__struct_semanage_iface_p_void__int, ++ &_swigt__p_f_p_q_const__struct_semanage_node_p_void__int, ++ &_swigt__p_f_p_q_const__struct_semanage_port_p_void__int, ++ &_swigt__p_f_p_q_const__struct_semanage_seuser_p_void__int, ++ &_swigt__p_f_p_q_const__struct_semanage_user_p_void__int, ++ &_swigt__p_f_p_void_p_struct_semanage_handle_p_q_const__char_v_______void, ++ &_swigt__p_int, ++ &_swigt__p_p_char, ++ &_swigt__p_p_p_char, ++ &_swigt__p_p_p_semanage_bool, ++ &_swigt__p_p_p_semanage_fcontext, ++ &_swigt__p_p_p_semanage_iface, ++ &_swigt__p_p_p_semanage_node, ++ &_swigt__p_p_p_semanage_port, ++ &_swigt__p_p_p_semanage_seuser, ++ &_swigt__p_p_p_semanage_user, ++ &_swigt__p_p_semanage_bool, ++ &_swigt__p_p_semanage_bool_key, ++ &_swigt__p_p_semanage_context, ++ &_swigt__p_p_semanage_fcontext, ++ &_swigt__p_p_semanage_fcontext_key, ++ &_swigt__p_p_semanage_iface, ++ &_swigt__p_p_semanage_iface_key, ++ &_swigt__p_p_semanage_module_info, ++ &_swigt__p_p_semanage_node, ++ &_swigt__p_p_semanage_node_key, ++ &_swigt__p_p_semanage_port, ++ &_swigt__p_p_semanage_port_key, ++ &_swigt__p_p_semanage_seuser, ++ &_swigt__p_p_semanage_seuser_key, ++ &_swigt__p_p_semanage_user, ++ &_swigt__p_p_semanage_user_key, ++ &_swigt__p_semanage_bool, ++ &_swigt__p_semanage_bool_key, ++ &_swigt__p_semanage_context, ++ &_swigt__p_semanage_fcontext, ++ &_swigt__p_semanage_fcontext_key, ++ &_swigt__p_semanage_handle, ++ &_swigt__p_semanage_iface, ++ &_swigt__p_semanage_iface_key, ++ &_swigt__p_semanage_module_info, ++ &_swigt__p_semanage_node, ++ &_swigt__p_semanage_node_key, ++ &_swigt__p_semanage_port, ++ &_swigt__p_semanage_port_key, ++ &_swigt__p_semanage_seuser, ++ &_swigt__p_semanage_seuser_key, ++ &_swigt__p_semanage_user, ++ &_swigt__p_semanage_user_key, ++ &_swigt__p_size_t, ++ &_swigt__p_unsigned_int, ++}; ++ ++static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_f_p_q_const__struct_semanage_bool_p_void__int[] = { {&_swigt__p_f_p_q_const__struct_semanage_bool_p_void__int, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_f_p_q_const__struct_semanage_fcontext_p_void__int[] = { {&_swigt__p_f_p_q_const__struct_semanage_fcontext_p_void__int, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_f_p_q_const__struct_semanage_iface_p_void__int[] = { {&_swigt__p_f_p_q_const__struct_semanage_iface_p_void__int, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_f_p_q_const__struct_semanage_node_p_void__int[] = { {&_swigt__p_f_p_q_const__struct_semanage_node_p_void__int, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_f_p_q_const__struct_semanage_port_p_void__int[] = { {&_swigt__p_f_p_q_const__struct_semanage_port_p_void__int, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_f_p_q_const__struct_semanage_seuser_p_void__int[] = { {&_swigt__p_f_p_q_const__struct_semanage_seuser_p_void__int, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_f_p_q_const__struct_semanage_user_p_void__int[] = { {&_swigt__p_f_p_q_const__struct_semanage_user_p_void__int, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_f_p_void_p_struct_semanage_handle_p_q_const__char_v_______void[] = { {&_swigt__p_f_p_void_p_struct_semanage_handle_p_q_const__char_v_______void, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_p_p_char[] = { {&_swigt__p_p_p_char, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_p_p_semanage_bool[] = { {&_swigt__p_p_p_semanage_bool, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_p_p_semanage_fcontext[] = { {&_swigt__p_p_p_semanage_fcontext, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_p_p_semanage_iface[] = { {&_swigt__p_p_p_semanage_iface, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_p_p_semanage_node[] = { {&_swigt__p_p_p_semanage_node, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_p_p_semanage_port[] = { {&_swigt__p_p_p_semanage_port, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_p_p_semanage_seuser[] = { {&_swigt__p_p_p_semanage_seuser, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_p_p_semanage_user[] = { {&_swigt__p_p_p_semanage_user, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_p_semanage_bool[] = { {&_swigt__p_p_semanage_bool, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_p_semanage_bool_key[] = { {&_swigt__p_p_semanage_bool_key, 0, 0, 0},{0, 0, 0, 0}}; ++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_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}}; ++static swig_cast_info _swigc__p_p_semanage_node[] = { {&_swigt__p_p_semanage_node, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_p_semanage_node_key[] = { {&_swigt__p_p_semanage_node_key, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_p_semanage_port[] = { {&_swigt__p_p_semanage_port, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_p_semanage_port_key[] = { {&_swigt__p_p_semanage_port_key, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_p_semanage_seuser[] = { {&_swigt__p_p_semanage_seuser, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_p_semanage_seuser_key[] = { {&_swigt__p_p_semanage_seuser_key, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_p_semanage_user[] = { {&_swigt__p_p_semanage_user, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_p_semanage_user_key[] = { {&_swigt__p_p_semanage_user_key, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_semanage_bool[] = { {&_swigt__p_semanage_bool, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_semanage_bool_key[] = { {&_swigt__p_semanage_bool_key, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_semanage_context[] = { {&_swigt__p_semanage_context, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_semanage_fcontext[] = { {&_swigt__p_semanage_fcontext, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_semanage_fcontext_key[] = { {&_swigt__p_semanage_fcontext_key, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_semanage_handle[] = { {&_swigt__p_semanage_handle, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_semanage_iface[] = { {&_swigt__p_semanage_iface, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_semanage_iface_key[] = { {&_swigt__p_semanage_iface_key, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_semanage_module_info[] = { {&_swigt__p_semanage_module_info, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_semanage_node[] = { {&_swigt__p_semanage_node, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_semanage_node_key[] = { {&_swigt__p_semanage_node_key, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_semanage_port[] = { {&_swigt__p_semanage_port, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_semanage_port_key[] = { {&_swigt__p_semanage_port_key, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_semanage_seuser[] = { {&_swigt__p_semanage_seuser, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_semanage_seuser_key[] = { {&_swigt__p_semanage_seuser_key, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_semanage_user[] = { {&_swigt__p_semanage_user, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_semanage_user_key[] = { {&_swigt__p_semanage_user_key, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_size_t[] = { {&_swigt__p_size_t, 0, 0, 0},{0, 0, 0, 0}}; ++static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}}; ++ ++static swig_cast_info *swig_cast_initial[] = { ++ _swigc__p_char, ++ _swigc__p_f_p_q_const__struct_semanage_bool_p_void__int, ++ _swigc__p_f_p_q_const__struct_semanage_fcontext_p_void__int, ++ _swigc__p_f_p_q_const__struct_semanage_iface_p_void__int, ++ _swigc__p_f_p_q_const__struct_semanage_node_p_void__int, ++ _swigc__p_f_p_q_const__struct_semanage_port_p_void__int, ++ _swigc__p_f_p_q_const__struct_semanage_seuser_p_void__int, ++ _swigc__p_f_p_q_const__struct_semanage_user_p_void__int, ++ _swigc__p_f_p_void_p_struct_semanage_handle_p_q_const__char_v_______void, ++ _swigc__p_int, ++ _swigc__p_p_char, ++ _swigc__p_p_p_char, ++ _swigc__p_p_p_semanage_bool, ++ _swigc__p_p_p_semanage_fcontext, ++ _swigc__p_p_p_semanage_iface, ++ _swigc__p_p_p_semanage_node, ++ _swigc__p_p_p_semanage_port, ++ _swigc__p_p_p_semanage_seuser, ++ _swigc__p_p_p_semanage_user, ++ _swigc__p_p_semanage_bool, ++ _swigc__p_p_semanage_bool_key, ++ _swigc__p_p_semanage_context, ++ _swigc__p_p_semanage_fcontext, ++ _swigc__p_p_semanage_fcontext_key, ++ _swigc__p_p_semanage_iface, ++ _swigc__p_p_semanage_iface_key, ++ _swigc__p_p_semanage_module_info, ++ _swigc__p_p_semanage_node, ++ _swigc__p_p_semanage_node_key, ++ _swigc__p_p_semanage_port, ++ _swigc__p_p_semanage_port_key, ++ _swigc__p_p_semanage_seuser, ++ _swigc__p_p_semanage_seuser_key, ++ _swigc__p_p_semanage_user, ++ _swigc__p_p_semanage_user_key, ++ _swigc__p_semanage_bool, ++ _swigc__p_semanage_bool_key, ++ _swigc__p_semanage_context, ++ _swigc__p_semanage_fcontext, ++ _swigc__p_semanage_fcontext_key, ++ _swigc__p_semanage_handle, ++ _swigc__p_semanage_iface, ++ _swigc__p_semanage_iface_key, ++ _swigc__p_semanage_module_info, ++ _swigc__p_semanage_node, ++ _swigc__p_semanage_node_key, ++ _swigc__p_semanage_port, ++ _swigc__p_semanage_port_key, ++ _swigc__p_semanage_seuser, ++ _swigc__p_semanage_seuser_key, ++ _swigc__p_semanage_user, ++ _swigc__p_semanage_user_key, ++ _swigc__p_size_t, ++ _swigc__p_unsigned_int, + }; + + +@@ -9072,85 +11813,329 @@ + #ifdef __cplusplus + } + #endif +- ++/* ----------------------------------------------------------------------------- ++ * Type initialization: ++ * This problem is tough by the requirement that no dynamic ++ * memory is used. Also, since swig_type_info structures store pointers to ++ * swig_cast_info structures and swig_cast_info structures store pointers back ++ * to swig_type_info structures, we need some lookup code at initialization. ++ * The idea is that swig generates all the structures that are needed. ++ * The runtime then collects these partially filled structures. ++ * The SWIG_InitializeModule function takes these initial arrays out of ++ * swig_module, and does all the lookup, filling in the swig_module.types ++ * array with the correct data and linking the correct swig_cast_info ++ * structures together. ++ * ++ * The generated swig_type_info structures are assigned staticly to an initial ++ * array. We just loop though that array, and handle each type individually. ++ * First we lookup if this type has been already loaded, and if so, use the ++ * loaded structure instead of the generated one. Then we have to fill in the ++ * cast linked list. The cast data is initially stored in something like a ++ * two-dimensional array. Each row corresponds to a type (there are the same ++ * number of rows as there are in the swig_type_initial array). Each entry in ++ * a column is one of the swig_cast_info structures for that type. ++ * The cast_initial array is actually an array of arrays, because each row has ++ * a variable number of columns. So to actually build the cast linked list, ++ * we find the array of casts associated with the type, and loop through it ++ * adding the casts to the list. The one last trick we need to do is making ++ * sure the type pointer in the swig_cast_info struct is correct. ++ * ++ * First off, we lookup the cast->type name to see if it is already loaded. ++ * There are three cases to handle: ++ * 1) If the cast->type has already been loaded AND the type we are adding ++ * casting info to has not been loaded (it is in this module), THEN we ++ * replace the cast->type pointer with the type pointer that has already ++ * been loaded. ++ * 2) If BOTH types (the one we are adding casting info to, and the ++ * cast->type) are loaded, THEN the cast info has already been loaded by ++ * the previous module so we just ignore it. ++ * 3) Finally, if cast->type has not already been loaded, then we add that ++ * swig_cast_info to the linked list (because the cast->type) pointer will ++ * be correct. ++ * ----------------------------------------------------------------------------- */ + + #ifdef __cplusplus + extern "C" { ++#if 0 ++} /* c-mode */ ++#endif ++#endif ++ ++#if 0 ++#define SWIGRUNTIME_DEBUG ++#endif ++ ++SWIGRUNTIME void ++SWIG_InitializeModule(void *clientdata) { ++ size_t i; ++ swig_module_info *module_head; ++ static int init_run = 0; ++ ++ clientdata = clientdata; ++ ++ if (init_run) return; ++ init_run = 1; ++ ++ /* Initialize the swig_module */ ++ swig_module.type_initial = swig_type_initial; ++ swig_module.cast_initial = swig_cast_initial; ++ ++ /* Try and load any already created modules */ ++ module_head = SWIG_GetModule(clientdata); ++ if (module_head) { ++ swig_module.next = module_head->next; ++ module_head->next = &swig_module; ++ } else { ++ /* This is the first module loaded */ ++ swig_module.next = &swig_module; ++ SWIG_SetModule(clientdata, &swig_module); ++ } ++ ++ /* Now work on filling in swig_module.types */ ++#ifdef SWIGRUNTIME_DEBUG ++ printf("SWIG_InitializeModule: size %d\n", swig_module.size); ++#endif ++ for (i = 0; i < swig_module.size; ++i) { ++ swig_type_info *type = 0; ++ swig_type_info *ret; ++ swig_cast_info *cast; ++ ++#ifdef SWIGRUNTIME_DEBUG ++ printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); ++#endif ++ ++ /* if there is another module already loaded */ ++ if (swig_module.next != &swig_module) { ++ type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); ++ } ++ if (type) { ++ /* Overwrite clientdata field */ ++#ifdef SWIGRUNTIME_DEBUG ++ printf("SWIG_InitializeModule: found type %s\n", type->name); ++#endif ++ if (swig_module.type_initial[i]->clientdata) { ++ type->clientdata = swig_module.type_initial[i]->clientdata; ++#ifdef SWIGRUNTIME_DEBUG ++ printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); + #endif ++ } ++ } else { ++ type = swig_module.type_initial[i]; ++ } + +- /* Python-specific SWIG API */ ++ /* Insert casting types */ ++ cast = swig_module.cast_initial[i]; ++ while (cast->type) { ++ /* Don't need to add information already in the list */ ++ ret = 0; ++#ifdef SWIGRUNTIME_DEBUG ++ printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); ++#endif ++ if (swig_module.next != &swig_module) { ++ ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); ++#ifdef SWIGRUNTIME_DEBUG ++ if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); ++#endif ++ } ++ if (ret) { ++ if (type == swig_module.type_initial[i]) { ++#ifdef SWIGRUNTIME_DEBUG ++ printf("SWIG_InitializeModule: skip old type %s\n", ret->name); ++#endif ++ cast->type = ret; ++ ret = 0; ++ } else { ++ /* Check for casting already in the list */ ++ swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); ++#ifdef SWIGRUNTIME_DEBUG ++ if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); ++#endif ++ if (!ocast) ret = 0; ++ } ++ } ++ ++ if (!ret) { ++#ifdef SWIGRUNTIME_DEBUG ++ printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); ++#endif ++ if (type->cast) { ++ type->cast->prev = cast; ++ cast->next = type->cast; ++ } ++ type->cast = cast; ++ } ++ cast++; ++ } ++ /* Set entry in modules->types array equal to the type */ ++ swig_module.types[i] = type; ++ } ++ swig_module.types[i] = 0; ++ ++#ifdef SWIGRUNTIME_DEBUG ++ printf("**** SWIG_InitializeModule: Cast List ******\n"); ++ for (i = 0; i < swig_module.size; ++i) { ++ int j = 0; ++ swig_cast_info *cast = swig_module.cast_initial[i]; ++ printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); ++ while (cast->type) { ++ printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); ++ cast++; ++ ++j; ++ } ++ printf("---- Total casts: %d\n",j); ++ } ++ printf("**** SWIG_InitializeModule: Cast List ******\n"); ++#endif ++} ++ ++/* This function will propagate the clientdata field of type to ++* any new swig_type_info structures that have been added into the list ++* of equivalent types. It is like calling ++* SWIG_TypeClientData(type, clientdata) a second time. ++*/ ++SWIGRUNTIME void ++SWIG_PropagateClientData(void) { ++ size_t i; ++ swig_cast_info *equiv; ++ static int init_run = 0; ++ ++ if (init_run) return; ++ init_run = 1; ++ ++ for (i = 0; i < swig_module.size; i++) { ++ if (swig_module.types[i]->clientdata) { ++ equiv = swig_module.types[i]->cast; ++ while (equiv) { ++ if (!equiv->converter) { ++ if (equiv->type && !equiv->type->clientdata) ++ SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); ++ } ++ equiv = equiv->next; ++ } ++ } ++ } ++} ++ ++#ifdef __cplusplus ++#if 0 ++{ ++ /* c-mode */ ++#endif ++} ++#endif ++ ++ ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++ /* Python-specific SWIG API */ + #define SWIG_newvarlink() SWIG_Python_newvarlink() + #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) + #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) +- +- /* ----------------------------------------------------------------------------- +- * global variable support code. +- * ----------------------------------------------------------------------------- */ +- +- typedef struct swig_globalvar { +- char *name; /* Name of global variable */ +- PyObject *(*get_attr)(); /* Return the current value */ +- int (*set_attr)(PyObject *); /* Set the value */ +- struct swig_globalvar *next; +- } swig_globalvar; +- +- typedef struct swig_varlinkobject { +- PyObject_HEAD +- swig_globalvar *vars; +- } swig_varlinkobject; +- +- static PyObject * +- swig_varlink_repr(swig_varlinkobject *v) { +- v = v; +- return PyString_FromString(""); ++ ++ /* ----------------------------------------------------------------------------- ++ * global variable support code. ++ * ----------------------------------------------------------------------------- */ ++ ++ typedef struct swig_globalvar { ++ char *name; /* Name of global variable */ ++ PyObject *(*get_attr)(void); /* Return the current value */ ++ int (*set_attr)(PyObject *); /* Set the value */ ++ struct swig_globalvar *next; ++ } swig_globalvar; ++ ++ typedef struct swig_varlinkobject { ++ PyObject_HEAD ++ swig_globalvar *vars; ++ } swig_varlinkobject; ++ ++ SWIGINTERN PyObject * ++ swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) { ++ return PyString_FromString(""); ++ } ++ ++ SWIGINTERN PyObject * ++ swig_varlink_str(swig_varlinkobject *v) { ++ PyObject *str = PyString_FromString("("); ++ swig_globalvar *var; ++ for (var = v->vars; var; var=var->next) { ++ PyString_ConcatAndDel(&str,PyString_FromString(var->name)); ++ if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", ")); + } +- +- static int +- swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) { +- swig_globalvar *var; +- flags = flags; +- fprintf(fp,"Swig global variables { "); +- for (var = v->vars; var; var=var->next) { +- fprintf(fp,"%s", var->name); +- if (var->next) fprintf(fp,", "); +- } +- fprintf(fp," }\n"); +- return 0; ++ PyString_ConcatAndDel(&str,PyString_FromString(")")); ++ return str; ++ } ++ ++ SWIGINTERN int ++ swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) { ++ PyObject *str = swig_varlink_str(v); ++ fprintf(fp,"Swig global variables "); ++ fprintf(fp,"%s\n", PyString_AsString(str)); ++ Py_DECREF(str); ++ return 0; ++ } ++ ++ SWIGINTERN void ++ swig_varlink_dealloc(swig_varlinkobject *v) { ++ swig_globalvar *var = v->vars; ++ while (var) { ++ swig_globalvar *n = var->next; ++ free(var->name); ++ free(var); ++ var = n; + } +- +- static PyObject * +- swig_varlink_getattr(swig_varlinkobject *v, char *n) { +- swig_globalvar *var = v->vars; +- while (var) { +- if (strcmp(var->name,n) == 0) { +- return (*var->get_attr)(); +- } +- var = var->next; +- } +- PyErr_SetString(PyExc_NameError,"Unknown C global variable"); +- return NULL; ++ } ++ ++ SWIGINTERN PyObject * ++ swig_varlink_getattr(swig_varlinkobject *v, char *n) { ++ PyObject *res = NULL; ++ swig_globalvar *var = v->vars; ++ while (var) { ++ if (strcmp(var->name,n) == 0) { ++ res = (*var->get_attr)(); ++ break; ++ } ++ var = var->next; + } +- +- static int +- swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { +- swig_globalvar *var = v->vars; +- while (var) { +- if (strcmp(var->name,n) == 0) { +- return (*var->set_attr)(p); +- } +- var = var->next; +- } +- PyErr_SetString(PyExc_NameError,"Unknown C global variable"); +- return 1; ++ if (res == NULL && !PyErr_Occurred()) { ++ PyErr_SetString(PyExc_NameError,"Unknown C global variable"); + } +- +- static PyTypeObject varlinktype = { +- PyObject_HEAD_INIT(0) ++ return res; ++ } ++ ++ SWIGINTERN int ++ swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { ++ int res = 1; ++ swig_globalvar *var = v->vars; ++ while (var) { ++ if (strcmp(var->name,n) == 0) { ++ res = (*var->set_attr)(p); ++ break; ++ } ++ var = var->next; ++ } ++ if (res == 1 && !PyErr_Occurred()) { ++ PyErr_SetString(PyExc_NameError,"Unknown C global variable"); ++ } ++ return res; ++ } ++ ++ SWIGINTERN PyTypeObject* ++ swig_varlink_type(void) { ++ static char varlink__doc__[] = "Swig var link object"; ++ static PyTypeObject varlink_type; ++ static int type_init = 0; ++ if (!type_init) { ++ const PyTypeObject tmp ++ = { ++ PyObject_HEAD_INIT(NULL) + 0, /* Number of items in variable part (ob_size) */ + (char *)"swigvarlink", /* Type name (tp_name) */ + sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */ + 0, /* Itemsize (tp_itemsize) */ +- 0, /* Deallocator (tp_dealloc) */ ++ (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */ + (printfunc) swig_varlink_print, /* Print (tp_print) */ + (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */ + (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */ +@@ -9161,20 +12146,16 @@ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ +- 0, /* tp_str */ ++ (reprfunc)swig_varlink_str, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + 0, /* tp_flags */ +- 0, /* tp_doc */ +-#if PY_VERSION_HEX >= 0x02000000 ++ varlink__doc__, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ +-#endif +-#if PY_VERSION_HEX >= 0x02010000 + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ +-#endif + #if PY_VERSION_HEX >= 0x02020000 + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ + #endif +@@ -9184,186 +12165,122 @@ + #ifdef COUNT_ALLOCS + 0,0,0,0 /* tp_alloc -> tp_next */ + #endif +- }; +- +- /* Create a variable linking object for use later */ +- static PyObject * +- SWIG_Python_newvarlink(void) { +- swig_varlinkobject *result = 0; +- result = PyMem_NEW(swig_varlinkobject,1); +- varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */ +- result->ob_type = &varlinktype; +- result->vars = 0; +- result->ob_refcnt = 0; +- Py_XINCREF((PyObject *) result); +- return ((PyObject*) result); ++ }; ++ varlink_type = tmp; ++ varlink_type.ob_type = &PyType_Type; ++ type_init = 1; + } +- +- static void +- SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { +- swig_varlinkobject *v; +- swig_globalvar *gv; +- v= (swig_varlinkobject *) p; +- gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); +- gv->name = (char *) malloc(strlen(name)+1); +- strcpy(gv->name,name); ++ return &varlink_type; ++ } ++ ++ /* Create a variable linking object for use later */ ++ SWIGINTERN PyObject * ++ SWIG_Python_newvarlink(void) { ++ swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type()); ++ if (result) { ++ result->vars = 0; ++ } ++ return ((PyObject*) result); ++ } ++ ++ SWIGINTERN void ++ SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { ++ swig_varlinkobject *v = (swig_varlinkobject *) p; ++ swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); ++ if (gv) { ++ size_t size = strlen(name)+1; ++ gv->name = (char *)malloc(size); ++ if (gv->name) { ++ strncpy(gv->name,name,size); + gv->get_attr = get_attr; + gv->set_attr = set_attr; + gv->next = v->vars; +- v->vars = gv; ++ } + } +- +- /* ----------------------------------------------------------------------------- +- * constants/methods manipulation +- * ----------------------------------------------------------------------------- */ +- +- /* Install Constants */ +- static void +- SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) { +- PyObject *obj = 0; +- size_t i; +- for (i = 0; constants[i].type; i++) { +- switch(constants[i].type) { +- case SWIG_PY_INT: +- obj = PyInt_FromLong(constants[i].lvalue); +- break; +- case SWIG_PY_FLOAT: +- obj = PyFloat_FromDouble(constants[i].dvalue); +- break; +- case SWIG_PY_STRING: +- if (constants[i].pvalue) { +- obj = PyString_FromString((char *) constants[i].pvalue); +- } else { +- Py_INCREF(Py_None); +- obj = Py_None; +- } +- break; +- case SWIG_PY_POINTER: +- obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0); +- break; +- case SWIG_PY_BINARY: +- obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); +- break; +- default: +- obj = 0; +- break; +- } +- if (obj) { +- PyDict_SetItemString(d,constants[i].name,obj); +- Py_DECREF(obj); +- } +- } ++ v->vars = gv; ++ } ++ ++ SWIGINTERN PyObject * ++ SWIG_globals() { ++ static PyObject *_SWIG_globals = 0; ++ if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink(); ++ return _SWIG_globals; ++ } ++ ++ /* ----------------------------------------------------------------------------- ++ * constants/methods manipulation ++ * ----------------------------------------------------------------------------- */ ++ ++ /* Install Constants */ ++ SWIGINTERN void ++ SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) { ++ PyObject *obj = 0; ++ size_t i; ++ for (i = 0; constants[i].type; ++i) { ++ switch(constants[i].type) { ++ case SWIG_PY_POINTER: ++ obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0); ++ break; ++ case SWIG_PY_BINARY: ++ obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); ++ break; ++ default: ++ obj = 0; ++ break; ++ } ++ if (obj) { ++ PyDict_SetItemString(d, constants[i].name, obj); ++ Py_DECREF(obj); ++ } + } +- +- /* -----------------------------------------------------------------------------*/ +- /* Fix SwigMethods to carry the callback ptrs when needed */ +- /* -----------------------------------------------------------------------------*/ +- +- static void +- SWIG_Python_FixMethods(PyMethodDef *methods, ++ } ++ ++ /* -----------------------------------------------------------------------------*/ ++ /* Fix SwigMethods to carry the callback ptrs when needed */ ++ /* -----------------------------------------------------------------------------*/ ++ ++ SWIGINTERN void ++ SWIG_Python_FixMethods(PyMethodDef *methods, + swig_const_info *const_table, + swig_type_info **types, + swig_type_info **types_initial) { +- size_t i; +- for (i = 0; methods[i].ml_name; ++i) { +- char *c = methods[i].ml_doc; +- if (c && (c = strstr(c, "swig_ptr: "))) { +- int j; +- swig_const_info *ci = 0; +- char *name = c + 10; +- for (j = 0; const_table[j].type; j++) { +- if (strncmp(const_table[j].name, name, +- strlen(const_table[j].name)) == 0) { +- ci = &(const_table[j]); +- break; +- } +- } +- if (ci) { +- size_t shift = (ci->ptype) - types; +- swig_type_info *ty = types_initial[shift]; +- size_t ldoc = (c - methods[i].ml_doc); +- size_t lptr = strlen(ty->name)+2*sizeof(void*)+2; +- char *ndoc = (char*)malloc(ldoc + lptr + 10); +- char *buff = ndoc; +- void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue); +- strncpy(buff, methods[i].ml_doc, ldoc); +- buff += ldoc; +- strncpy(buff, "swig_ptr: ", 10); +- buff += 10; +- SWIG_PackVoidPtr(buff, ptr, ty->name, lptr); +- methods[i].ml_doc = ndoc; +- } ++ size_t i; ++ for (i = 0; methods[i].ml_name; ++i) { ++ char *c = methods[i].ml_doc; ++ if (c && (c = strstr(c, "swig_ptr: "))) { ++ int j; ++ swig_const_info *ci = 0; ++ char *name = c + 10; ++ for (j = 0; const_table[j].type; ++j) { ++ if (strncmp(const_table[j].name, name, ++ strlen(const_table[j].name)) == 0) { ++ ci = &(const_table[j]); ++ break; ++ } ++ } ++ if (ci) { ++ size_t shift = (ci->ptype) - types; ++ swig_type_info *ty = types_initial[shift]; ++ size_t ldoc = (c - methods[i].ml_doc); ++ size_t lptr = strlen(ty->name)+2*sizeof(void*)+2; ++ char *ndoc = (char*)malloc(ldoc + lptr + 10); ++ if (ndoc) { ++ char *buff = ndoc; ++ void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0; ++ if (ptr) { ++ strncpy(buff, methods[i].ml_doc, ldoc); ++ buff += ldoc; ++ strncpy(buff, "swig_ptr: ", 10); ++ buff += 10; ++ SWIG_PackVoidPtr(buff, ptr, ty->name, lptr); ++ methods[i].ml_doc = ndoc; + } ++ } + } ++ } + } +- +- /* -----------------------------------------------------------------------------* +- * Initialize type list +- * -----------------------------------------------------------------------------*/ +- +-#if PY_MAJOR_VERSION < 2 +- /* PyModule_AddObject function was introduced in Python 2.0. The following function +- is copied out of Python/modsupport.c in python version 2.3.4 */ +- static int +- PyModule_AddObject(PyObject *m, char *name, PyObject *o) +- { +- PyObject *dict; +- if (!PyModule_Check(m)) { +- PyErr_SetString(PyExc_TypeError, +- "PyModule_AddObject() needs module as first arg"); +- return -1; +- } +- if (!o) { +- PyErr_SetString(PyExc_TypeError, +- "PyModule_AddObject() needs non-NULL value"); +- return -1; +- } +- +- dict = PyModule_GetDict(m); +- if (dict == NULL) { +- /* Internal error -- modules must have a dict! */ +- PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__", +- PyModule_GetName(m)); +- return -1; +- } +- if (PyDict_SetItemString(dict, name, o)) +- return -1; +- Py_DECREF(o); +- return 0; +- } +-#endif +- +- static swig_type_info ** +- SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) { +- static PyMethodDef swig_empty_runtime_method_table[] = { +- { +- NULL, NULL, 0, NULL +- } +- };/* Sentinel */ +- +- PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, +- swig_empty_runtime_method_table); +- PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL); +- if (pointer && module) { +- PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer); +- } +- return type_list_handle; +- } +- +- static swig_type_info ** +- SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) { +- swig_type_info **type_pointer; +- +- /* first check if module already created */ +- type_pointer = SWIG_Python_GetTypeListHandle(); +- if (type_pointer) { +- return type_pointer; +- } else { +- /* create a new module and variable */ +- return SWIG_Python_SetTypeListHandle(type_list_handle); +- } +- } +- ++ } ++ + #ifdef __cplusplus + } + #endif +@@ -9372,106 +12289,42 @@ + * Partial Init method + * -----------------------------------------------------------------------------*/ + +-#ifdef SWIG_LINK_RUNTIME +-#ifdef __cplusplus +-extern "C" +-#endif +-SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *); +-#endif +- + #ifdef __cplusplus + extern "C" + #endif +-SWIGEXPORT(void) SWIG_init(void) { +- static PyObject *SWIG_globals = 0; +- static int typeinit = 0; +- PyObject *m, *d; +- int i; +- if (!SWIG_globals) SWIG_globals = SWIG_newvarlink(); +- +- /* Fix SwigMethods to carry the callback ptrs when needed */ +- SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial); +- +- m = Py_InitModule((char *) SWIG_name, SwigMethods); +- d = PyModule_GetDict(m); +- +- if (!typeinit) { +-#ifdef SWIG_LINK_RUNTIME +- swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle); +-#else +-# ifndef SWIG_STATIC_RUNTIME +- swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle); +-# endif +-#endif +- for (i = 0; swig_types_initial[i]; i++) { +- swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]); +- } +- typeinit = 1; +- } +- SWIG_InstallConstants(d,swig_const_table); +- +- { +- PyDict_SetItemString(d,"SEMANAGE_MSG_ERR", SWIG_From_int((int)(1))); +- } +- { +- PyDict_SetItemString(d,"SEMANAGE_MSG_WARN", SWIG_From_int((int)(2))); +- } +- { +- PyDict_SetItemString(d,"SEMANAGE_MSG_INFO", SWIG_From_int((int)(3))); +- } +- { +- PyDict_SetItemString(d,"SEMANAGE_CON_INVALID", SWIG_From_int((int)(SEMANAGE_CON_INVALID))); +- } +- { +- PyDict_SetItemString(d,"SEMANAGE_CON_DIRECT", SWIG_From_int((int)(SEMANAGE_CON_DIRECT))); +- } +- { +- PyDict_SetItemString(d,"SEMANAGE_CON_POLSERV_LOCAL", SWIG_From_int((int)(SEMANAGE_CON_POLSERV_LOCAL))); +- } +- { +- PyDict_SetItemString(d,"SEMANAGE_CON_POLSERV_REMOTE", SWIG_From_int((int)(SEMANAGE_CON_POLSERV_REMOTE))); +- } +- { +- PyDict_SetItemString(d,"SEMANAGE_CAN_READ", SWIG_From_int((int)(1))); +- } +- { +- PyDict_SetItemString(d,"SEMANAGE_CAN_WRITE", SWIG_From_int((int)(2))); +- } +- { +- PyDict_SetItemString(d,"SEMANAGE_PROTO_UDP", SWIG_From_int((int)(0))); +- } +- { +- PyDict_SetItemString(d,"SEMANAGE_PROTO_TCP", SWIG_From_int((int)(1))); +- } +- { +- PyDict_SetItemString(d,"SEMANAGE_FCONTEXT_ALL", SWIG_From_int((int)(0))); +- } +- { +- PyDict_SetItemString(d,"SEMANAGE_FCONTEXT_REG", SWIG_From_int((int)(1))); +- } +- { +- PyDict_SetItemString(d,"SEMANAGE_FCONTEXT_DIR", SWIG_From_int((int)(2))); +- } +- { +- PyDict_SetItemString(d,"SEMANAGE_FCONTEXT_CHAR", SWIG_From_int((int)(3))); +- } +- { +- PyDict_SetItemString(d,"SEMANAGE_FCONTEXT_BLOCK", SWIG_From_int((int)(4))); +- } +- { +- PyDict_SetItemString(d,"SEMANAGE_FCONTEXT_SOCK", SWIG_From_int((int)(5))); +- } +- { +- PyDict_SetItemString(d,"SEMANAGE_FCONTEXT_LINK", SWIG_From_int((int)(6))); +- } +- { +- PyDict_SetItemString(d,"SEMANAGE_FCONTEXT_PIPE", SWIG_From_int((int)(7))); +- } +- { +- PyDict_SetItemString(d,"SEMANAGE_PROTO_IP4", SWIG_From_int((int)(0))); +- } +- { +- PyDict_SetItemString(d,"SEMANAGE_PROTO_IP6", SWIG_From_int((int)(1))); +- } ++SWIGEXPORT void SWIG_init(void) { ++ PyObject *m, *d; ++ ++ /* Fix SwigMethods to carry the callback ptrs when needed */ ++ SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial); ++ ++ m = Py_InitModule((char *) SWIG_name, SwigMethods); ++ d = PyModule_GetDict(m); ++ ++ SWIG_InitializeModule(0); ++ SWIG_InstallConstants(d,swig_const_table); ++ ++ ++ SWIG_Python_SetConstant(d, "SEMANAGE_MSG_ERR",SWIG_From_int((int)(1))); ++ SWIG_Python_SetConstant(d, "SEMANAGE_MSG_WARN",SWIG_From_int((int)(2))); ++ SWIG_Python_SetConstant(d, "SEMANAGE_MSG_INFO",SWIG_From_int((int)(3))); ++ SWIG_Python_SetConstant(d, "SEMANAGE_CON_INVALID",SWIG_From_int((int)(SEMANAGE_CON_INVALID))); ++ SWIG_Python_SetConstant(d, "SEMANAGE_CON_DIRECT",SWIG_From_int((int)(SEMANAGE_CON_DIRECT))); ++ SWIG_Python_SetConstant(d, "SEMANAGE_CON_POLSERV_LOCAL",SWIG_From_int((int)(SEMANAGE_CON_POLSERV_LOCAL))); ++ SWIG_Python_SetConstant(d, "SEMANAGE_CON_POLSERV_REMOTE",SWIG_From_int((int)(SEMANAGE_CON_POLSERV_REMOTE))); ++ SWIG_Python_SetConstant(d, "SEMANAGE_CAN_READ",SWIG_From_int((int)(1))); ++ SWIG_Python_SetConstant(d, "SEMANAGE_CAN_WRITE",SWIG_From_int((int)(2))); ++ SWIG_Python_SetConstant(d, "SEMANAGE_PROTO_UDP",SWIG_From_int((int)(0))); ++ SWIG_Python_SetConstant(d, "SEMANAGE_PROTO_TCP",SWIG_From_int((int)(1))); ++ SWIG_Python_SetConstant(d, "SEMANAGE_FCONTEXT_ALL",SWIG_From_int((int)(0))); ++ SWIG_Python_SetConstant(d, "SEMANAGE_FCONTEXT_REG",SWIG_From_int((int)(1))); ++ SWIG_Python_SetConstant(d, "SEMANAGE_FCONTEXT_DIR",SWIG_From_int((int)(2))); ++ SWIG_Python_SetConstant(d, "SEMANAGE_FCONTEXT_CHAR",SWIG_From_int((int)(3))); ++ SWIG_Python_SetConstant(d, "SEMANAGE_FCONTEXT_BLOCK",SWIG_From_int((int)(4))); ++ SWIG_Python_SetConstant(d, "SEMANAGE_FCONTEXT_SOCK",SWIG_From_int((int)(5))); ++ SWIG_Python_SetConstant(d, "SEMANAGE_FCONTEXT_LINK",SWIG_From_int((int)(6))); ++ 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))); + } + +diff --exclude-from=exclude -N -u -r nsalibsemanage/VERSION libsemanage-1.6.2/VERSION +--- nsalibsemanage/VERSION 2006-04-05 13:33:50.000000000 -0400 ++++ libsemanage-1.6.2/VERSION 2006-03-21 09:19:55.000000000 -0500 +@@ -1 +1 @@ +-1.6.3 ++1.6.2 diff --git a/libsemanage.spec b/libsemanage.spec index 540d15c..d83421a 100644 --- a/libsemanage.spec +++ b/libsemanage.spec @@ -1,13 +1,12 @@ -%define libsepolver 1.12-1 -%define libselinuxver 1.30-1 +%define libsepolver 1.12.5-1 +%define libselinuxver 1.30.3-1 Summary: SELinux binary policy manipulation library Name: libsemanage -Version: 1.6.2 -Release: 2 +Version: 1.6.5 +Release: 1 License: GPL Group: System Environment/Libraries Source: http://www.nsa.gov/selinux/archives/libsemanage-%{version}.tgz -Patch: libsemanage-rhat.patch BuildRoot: %{_tmppath}/%{name}-buildroot BuildRequires: libselinux-devel >= %{libselinuxver} @@ -40,7 +39,6 @@ needed for developing applications that manipulate binary policies. %prep %setup -q -%patch -p1 -b .rhat %build make clean @@ -74,6 +72,18 @@ rm -rf ${RPM_BUILD_ROOT} %{_mandir}/man3/* %changelog +* Fri Apr 14 2006 Dan Walsh - 1.6.5-1 +- Upgrade to latest from NSA + * Merged file context sorting code from Christopher Ashworth + (Tresys Technology), based on fc_sort.c code in refpolicy. + * Merged python binding t_output_helper removal patch from Dan Walsh. + * Regenerated swig files. + +* Wed Mar 29 2006 Dan Walsh - 1.6.3-1 +- Fix to work with new version of swig +- Upgrade to latest from NSA + * Merged corrected fix for descriptor leak from Dan Walsh. + * Wed Mar 29 2006 Dan Walsh - 1.6.2-2 - Fix leaky descriptor diff --git a/sources b/sources index d2fc5f2..3810fd8 100644 --- a/sources +++ b/sources @@ -1 +1 @@ -187deb14a3577967b5ddac2013cd641c libsemanage-1.6.2.tgz +e82f27ce38a2e02efecd00ca434545c5 libsemanage-1.6.5.tgz