diff --git a/libsemanage-rhat.patch b/libsemanage-rhat.patch index a7a699c..f2267a6 100644 --- a/libsemanage-rhat.patch +++ b/libsemanage-rhat.patch @@ -1,11 +1,6616 @@ -diff --exclude-from=exclude -N -u -r nsalibsemanage/src/semanage_store.c libsemanage-1.3.64/src/semanage_store.c ---- nsalibsemanage/src/semanage_store.c 2005-11-16 08:44:47.000000000 -0500 -+++ libsemanage-1.3.64/src/semanage_store.c 2005-12-07 08:07:02.000000000 -0500 -@@ -917,6 +917,7 @@ - INFO(sh, "Non-fatal error: Could not copy %s to %s.", active_seusers, store_seusers); - /* Non-fatal; fall through */ - } -+ chmod(store_seusers, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); +diff --exclude-from=exclude -N -u -r nsalibsemanage/include/semanage/semanage.h libsemanage-1.5.3/include/semanage/semanage.h +--- nsalibsemanage/include/semanage/semanage.h 2005-11-04 15:37:49.000000000 -0500 ++++ libsemanage-1.5.3/include/semanage/semanage.h 2005-12-27 10:56:24.000000000 -0500 +@@ -32,9 +32,7 @@ + #include + #include + #include +-#if 0 + #include +-#endif + + /* Dbase */ + #include +@@ -42,10 +40,8 @@ + #include + #include + #include +-#if 0 + #include + #include +-#endif + #include + #include + +diff --exclude-from=exclude -N -u -r nsalibsemanage/src/libsemanage.map libsemanage-1.5.3/src/libsemanage.map +--- nsalibsemanage/src/libsemanage.map 2005-11-08 14:48:37.000000000 -0500 ++++ libsemanage-1.5.3/src/libsemanage.map 2005-12-27 10:56:26.000000000 -0500 +@@ -10,6 +10,6 @@ + semanage_module_get_version; semanage_select_store; + semanage_reload_policy; semanage_set_reload; + semanage_user_*; semanage_bool_*; semanage_seuser_*; +- semanage_iface_*; semanage_context_*; ++ semanage_iface_*; semanage_port_*; semanage_context_*; + local: *; + }; +diff --exclude-from=exclude -N -u -r nsalibsemanage/src/policy_components.c libsemanage-1.5.3/src/policy_components.c +--- nsalibsemanage/src/policy_components.c 2005-12-13 11:18:11.000000000 -0500 ++++ libsemanage-1.5.3/src/policy_components.c 2005-12-27 10:56:28.000000000 -0500 +@@ -127,10 +127,10 @@ + + { semanage_user_dbase_local(handle), + semanage_user_dbase_policy(handle), MODE_MODIFY }, +-#if 0 ++ + { semanage_port_dbase_local(handle), + semanage_port_dbase_policy(handle), MODE_MODIFY }, +-#endif ++ + { semanage_iface_dbase_local(handle), + semanage_iface_dbase_policy(handle), MODE_MODIFY }, + +diff --exclude-from=exclude -N -u -r nsalibsemanage/src/port_record.c libsemanage-1.5.3/src/port_record.c +--- nsalibsemanage/src/port_record.c 2005-12-14 14:16:47.000000000 -0500 ++++ libsemanage-1.5.3/src/port_record.c 2005-12-27 10:56:29.000000000 -0500 +@@ -17,24 +17,6 @@ + #include "handle.h" + #include "database.h" + +-/* FIXME: Remove when sepol port interface is stabilized and exported. */ +-#define sepol_port_compare(port, key) -1 +-#define sepol_port_key_create(handle, low, high, proto, key) -1 +-#define sepol_port_key_extract(handle, port, key) -1 +-#define sepol_port_key_free(key) +-#define sepol_port_get_proto(port) -1 +-#define sepol_port_set_proto(port, proto) +-#define sepol_port_get_proto_str(port) NULL +-#define sepol_port_get_low(port) -1 +-#define sepol_port_get_high(port) -1 +-#define sepol_port_set_port(port, num) +-#define sepol_port_set_range(port, low, high) +-#define sepol_port_get_con(port) NULL +-#define sepol_port_set_con(port, con) +-#define sepol_port_create(handle, port) -1 +-#define sepol_port_clone(handle, port1, port2) -1 +-#define sepol_port_free(port) +- + /* Key */ + int semanage_port_compare( + semanage_port_t* port, +diff --exclude-from=exclude -N -u -r nsalibsemanage/src/ports_policydb.c libsemanage-1.5.3/src/ports_policydb.c +--- nsalibsemanage/src/ports_policydb.c 2005-12-14 14:16:47.000000000 -0500 ++++ libsemanage-1.5.3/src/ports_policydb.c 2005-12-27 10:56:31.000000000 -0500 +@@ -16,13 +16,6 @@ + #include "debug.h" + #include "database_policydb.h" + +-/* FIXME: Remove when sepol port interface is stabilized and exported. */ +-#define sepol_port_modify NULL +-#define sepol_port_query NULL +-#define sepol_port_count NULL +-#define sepol_port_exists NULL +-#define sepol_port_iterate NULL +- + /* PORT RECORD (SEPOL): POLICYDB extension : method table */ + record_policydb_table_t SEMANAGE_PORT_POLICYDB_RTABLE = { + .add = NULL, +diff --exclude-from=exclude -N -u -r nsalibsemanage/src/semanage.py libsemanage-1.5.3/src/semanage.py +--- nsalibsemanage/src/semanage.py 2005-12-06 13:36:45.000000000 -0500 ++++ libsemanage-1.5.3/src/semanage.py 2005-12-27 10:59:08.000000000 -0500 +@@ -44,28 +44,6 @@ + semanage_port_by_idx = _semanage.semanage_port_by_idx + + char_by_idx = _semanage.char_by_idx +- +-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_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_MSG_ERR = _semanage.SEMANAGE_MSG_ERR + SEMANAGE_MSG_WARN = _semanage.SEMANAGE_MSG_WARN + SEMANAGE_MSG_INFO = _semanage.SEMANAGE_MSG_INFO +@@ -78,34 +56,6 @@ + + semanage_msg_set_callback = _semanage.semanage_msg_set_callback + +-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_bool_add_local = _semanage.semanage_bool_add_local +- +-semanage_bool_modify_local = _semanage.semanage_bool_modify_local +- +-semanage_bool_set_local = _semanage.semanage_bool_set_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_handle_create = _semanage.semanage_handle_create + + semanage_handle_destroy = _semanage.semanage_handle_destroy +@@ -148,43 +98,53 @@ + + semanage_module_get_version = _semanage.semanage_module_get_version + +-semanage_user_key_create = _semanage.semanage_user_key_create ++semanage_context_get_user = _semanage.semanage_context_get_user + +-semanage_user_key_extract = _semanage.semanage_user_key_extract ++semanage_context_set_user = _semanage.semanage_context_set_user + +-semanage_user_key_free = _semanage.semanage_user_key_free ++semanage_context_get_role = _semanage.semanage_context_get_role + +-semanage_user_compare = _semanage.semanage_user_compare ++semanage_context_set_role = _semanage.semanage_context_set_role + +-semanage_user_get_name = _semanage.semanage_user_get_name ++semanage_context_get_type = _semanage.semanage_context_get_type + +-semanage_user_set_name = _semanage.semanage_user_set_name ++semanage_context_set_type = _semanage.semanage_context_set_type + +-semanage_user_get_mlslevel = _semanage.semanage_user_get_mlslevel ++semanage_context_get_mls = _semanage.semanage_context_get_mls + +-semanage_user_set_mlslevel = _semanage.semanage_user_set_mlslevel ++semanage_context_set_mls = _semanage.semanage_context_set_mls + +-semanage_user_get_mlsrange = _semanage.semanage_user_get_mlsrange ++semanage_context_create = _semanage.semanage_context_create + +-semanage_user_set_mlsrange = _semanage.semanage_user_set_mlsrange ++semanage_context_clone = _semanage.semanage_context_clone + +-semanage_user_get_num_roles = _semanage.semanage_user_get_num_roles ++semanage_context_free = _semanage.semanage_context_free + +-semanage_user_add_role = _semanage.semanage_user_add_role ++semanage_context_from_string = _semanage.semanage_context_from_string + +-semanage_user_del_role = _semanage.semanage_user_del_role ++semanage_context_to_string = _semanage.semanage_context_to_string + +-semanage_user_has_role = _semanage.semanage_user_has_role ++semanage_bool_key_create = _semanage.semanage_bool_key_create + +-semanage_user_get_roles = _semanage.semanage_user_get_roles ++semanage_bool_key_extract = _semanage.semanage_bool_key_extract + +-semanage_user_set_roles = _semanage.semanage_user_set_roles ++semanage_bool_key_free = _semanage.semanage_bool_key_free + +-semanage_user_create = _semanage.semanage_user_create ++semanage_bool_compare = _semanage.semanage_bool_compare + +-semanage_user_clone = _semanage.semanage_user_clone ++semanage_bool_get_name = _semanage.semanage_bool_get_name + +-semanage_user_free = _semanage.semanage_user_free ++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 + +@@ -196,6 +156,24 @@ + + semanage_bool_list = _semanage.semanage_bool_list + ++semanage_bool_add_local = _semanage.semanage_bool_add_local ++ ++semanage_bool_modify_local = _semanage.semanage_bool_modify_local ++ ++semanage_bool_set_local = _semanage.semanage_bool_set_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_iface_compare = _semanage.semanage_iface_compare + + semanage_iface_key_create = _semanage.semanage_iface_key_create +@@ -222,31 +200,71 @@ + + semanage_iface_free = _semanage.semanage_iface_free + +-semanage_seuser_key_create = _semanage.semanage_seuser_key_create ++semanage_iface_add_local = _semanage.semanage_iface_add_local + +-semanage_seuser_key_extract = _semanage.semanage_seuser_key_extract ++semanage_iface_modify_local = _semanage.semanage_iface_modify_local + +-semanage_seuser_key_free = _semanage.semanage_seuser_key_free ++semanage_iface_set_local = _semanage.semanage_iface_set_local + +-semanage_seuser_compare = _semanage.semanage_seuser_compare ++semanage_iface_del_local = _semanage.semanage_iface_del_local + +-semanage_seuser_get_name = _semanage.semanage_seuser_get_name ++semanage_iface_query_local = _semanage.semanage_iface_query_local + +-semanage_seuser_set_name = _semanage.semanage_seuser_set_name ++semanage_iface_exists_local = _semanage.semanage_iface_exists_local + +-semanage_seuser_get_sename = _semanage.semanage_seuser_get_sename ++semanage_iface_count_local = _semanage.semanage_iface_count_local + +-semanage_seuser_set_sename = _semanage.semanage_seuser_set_sename ++semanage_iface_iterate_local = _semanage.semanage_iface_iterate_local + +-semanage_seuser_get_mlsrange = _semanage.semanage_seuser_get_mlsrange ++semanage_iface_list_local = _semanage.semanage_iface_list_local + +-semanage_seuser_set_mlsrange = _semanage.semanage_seuser_set_mlsrange ++semanage_iface_query = _semanage.semanage_iface_query + +-semanage_seuser_create = _semanage.semanage_seuser_create ++semanage_iface_exists = _semanage.semanage_iface_exists + +-semanage_seuser_clone = _semanage.semanage_seuser_clone ++semanage_iface_count = _semanage.semanage_iface_count + +-semanage_seuser_free = _semanage.semanage_seuser_free ++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_get_name = _semanage.semanage_user_get_name ++ ++semanage_user_set_name = _semanage.semanage_user_set_name ++ ++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_add_local = _semanage.semanage_user_add_local + +@@ -266,49 +284,103 @@ + + semanage_user_list_local = _semanage.semanage_user_list_local + +-semanage_context_get_user = _semanage.semanage_context_get_user ++semanage_user_query = _semanage.semanage_user_query + +-semanage_context_set_user = _semanage.semanage_context_set_user ++semanage_user_exists = _semanage.semanage_user_exists + +-semanage_context_get_role = _semanage.semanage_context_get_role ++semanage_user_count = _semanage.semanage_user_count + +-semanage_context_set_role = _semanage.semanage_context_set_role ++semanage_user_iterate = _semanage.semanage_user_iterate + +-semanage_context_get_type = _semanage.semanage_context_get_type ++semanage_user_list = _semanage.semanage_user_list ++SEMANAGE_PROTO_UDP = _semanage.SEMANAGE_PROTO_UDP ++SEMANAGE_PROTO_TCP = _semanage.SEMANAGE_PROTO_TCP + +-semanage_context_set_type = _semanage.semanage_context_set_type ++semanage_port_compare = _semanage.semanage_port_compare + +-semanage_context_get_mls = _semanage.semanage_context_get_mls ++semanage_port_key_create = _semanage.semanage_port_key_create + +-semanage_context_set_mls = _semanage.semanage_context_set_mls ++semanage_port_key_extract = _semanage.semanage_port_key_extract + +-semanage_context_create = _semanage.semanage_context_create ++semanage_port_key_free = _semanage.semanage_port_key_free + +-semanage_context_clone = _semanage.semanage_context_clone ++semanage_port_get_proto = _semanage.semanage_port_get_proto + +-semanage_context_free = _semanage.semanage_context_free ++semanage_port_set_proto = _semanage.semanage_port_set_proto + +-semanage_context_from_string = _semanage.semanage_context_from_string ++semanage_port_get_proto_str = _semanage.semanage_port_get_proto_str + +-semanage_context_to_string = _semanage.semanage_context_to_string ++semanage_port_get_low = _semanage.semanage_port_get_low + +-semanage_iface_add_local = _semanage.semanage_iface_add_local ++semanage_port_get_high = _semanage.semanage_port_get_high + +-semanage_iface_modify_local = _semanage.semanage_iface_modify_local ++semanage_port_set_port = _semanage.semanage_port_set_port + +-semanage_iface_set_local = _semanage.semanage_iface_set_local ++semanage_port_set_range = _semanage.semanage_port_set_range + +-semanage_iface_del_local = _semanage.semanage_iface_del_local ++semanage_port_get_con = _semanage.semanage_port_get_con + +-semanage_iface_query_local = _semanage.semanage_iface_query_local ++semanage_port_set_con = _semanage.semanage_port_set_con + +-semanage_iface_exists_local = _semanage.semanage_iface_exists_local ++semanage_port_create = _semanage.semanage_port_create + +-semanage_iface_count_local = _semanage.semanage_iface_count_local ++semanage_port_clone = _semanage.semanage_port_clone + +-semanage_iface_iterate_local = _semanage.semanage_iface_iterate_local ++semanage_port_free = _semanage.semanage_port_free + +-semanage_iface_list_local = _semanage.semanage_iface_list_local ++semanage_port_add_local = _semanage.semanage_port_add_local ++ ++semanage_port_modify_local = _semanage.semanage_port_modify_local ++ ++semanage_port_set_local = _semanage.semanage_port_set_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_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_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_add = _semanage.semanage_seuser_add + +@@ -328,13 +400,3 @@ + + semanage_seuser_list = _semanage.semanage_seuser_list + +-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 +- +diff --exclude-from=exclude -N -u -r nsalibsemanage/src/semanageswig.i libsemanage-1.5.3/src/semanageswig.i +--- nsalibsemanage/src/semanageswig.i 2005-11-28 14:53:14.000000000 -0500 ++++ libsemanage-1.5.3/src/semanageswig.i 2005-12-27 10:59:04.000000000 -0500 +@@ -149,7 +149,6 @@ + + /* the wrapper will setup this parameter for passing... the resulting python functions + will not take the semanage_port_t *** parameter */ +-/* + %typemap(in, numinputs=0) semanage_port_t ***(semanage_port_t **temp) { + $1 = &temp; + } +@@ -173,27 +172,24 @@ + %typemap(in, numinputs=0) semanage_port_key_t **(semanage_port_key_t *temp) { + $1 = &temp; + } +-*/ + + /* pull in the headers */ +-%include "../include/semanage/boolean_record.h" + %include "../include/semanage/debug.h" +-%include "../include/semanage/interfaces_policy.h" +-%include "../include/semanage/booleans_local.h" +-%include "../include/semanage/handle.h" +-%include "../include/semanage/modules.h" +-%include "../include/semanage/semanage.h" ++%include "../include/semanage/handle.h" ++%include "../include/semanage/modules.h" ++%include "../include/semanage/context_record.h" ++%include "../include/semanage/boolean_record.h" ++%include "../include/semanage/booleans_policy.h" ++%include "../include/semanage/booleans_local.h" ++%include "../include/semanage/iface_record.h" ++%include "../include/semanage/interfaces_local.h" ++%include "../include/semanage/interfaces_policy.h" + %include "../include/semanage/user_record.h" +-%include "../include/semanage/booleans_policy.h" +-%include "../include/semanage/iface_record.h" +-%include "../include/semanage/seuser_record.h" + %include "../include/semanage/users_local.h" +-%include "../include/semanage/context_record.h" +-%include "../include/semanage/interfaces_local.h" +-%include "../include/semanage/seusers.h" + %include "../include/semanage/users_policy.h" +-/* + %include "../include/semanage/port_record.h" + %include "../include/semanage/ports_local.h" + %include "../include/semanage/ports_policy.h" +-*/ ++%include "../include/semanage/seuser_record.h" ++%include "../include/semanage/seusers.h" ++%include "../include/semanage/semanage.h" +diff --exclude-from=exclude -N -u -r nsalibsemanage/src/semanageswig_wrap.c libsemanage-1.5.3/src/semanageswig_wrap.c +--- nsalibsemanage/src/semanageswig_wrap.c 2005-12-06 13:36:45.000000000 -0500 ++++ libsemanage-1.5.3/src/semanageswig_wrap.c 2005-12-27 10:59:08.000000000 -0500 +@@ -1321,47 +1321,51 @@ + + /* -------- TYPES TABLE (BEGIN) -------- */ + +-#define SWIGTYPE_p_f_p_struct_semanage_bool_p_void__int swig_types[0] +-#define SWIGTYPE_p_f_p_struct_semanage_iface_p_void__int swig_types[1] ++#define SWIGTYPE_p_f_p_struct_semanage_iface_p_void__int swig_types[0] ++#define SWIGTYPE_p_f_p_struct_semanage_bool_p_void__int swig_types[1] + #define SWIGTYPE_p_p_p_char swig_types[2] + #define SWIGTYPE_p_char swig_types[3] + #define SWIGTYPE_p_p_char swig_types[4] + #define SWIGTYPE_p_f_p_struct_semanage_user_p_void__int swig_types[5] +-#define SWIGTYPE_p_f_p_struct_semanage_seuser_p_void__int swig_types[6] +-#define SWIGTYPE_p_p_semanage_port_t swig_types[7] +-#define SWIGTYPE_p_semanage_port_t swig_types[8] +-#define SWIGTYPE_p_p_semanage_seuser swig_types[9] +-#define SWIGTYPE_p_semanage_seuser swig_types[10] +-#define SWIGTYPE_p_p_p_semanage_seuser swig_types[11] +-#define SWIGTYPE_p_p_p_semanage_bool swig_types[12] +-#define SWIGTYPE_p_p_semanage_bool swig_types[13] +-#define SWIGTYPE_p_semanage_bool swig_types[14] +-#define SWIGTYPE_p_p_semanage_user swig_types[15] +-#define SWIGTYPE_p_semanage_user swig_types[16] +-#define SWIGTYPE_p_size_t swig_types[17] +-#define SWIGTYPE_size_t swig_types[18] +-#define SWIGTYPE_p_p_p_semanage_user swig_types[19] +-#define SWIGTYPE_p_semanage_seuser_key swig_types[20] ++#define SWIGTYPE_p_semanage_port_key swig_types[6] ++#define SWIGTYPE_p_p_semanage_port_key swig_types[7] ++#define SWIGTYPE_p_f_p_struct_semanage_port_p_void__int swig_types[8] ++#define SWIGTYPE_p_f_p_struct_semanage_seuser_p_void__int swig_types[9] ++#define SWIGTYPE_p_p_semanage_seuser swig_types[10] ++#define SWIGTYPE_p_semanage_seuser swig_types[11] ++#define SWIGTYPE_p_p_p_semanage_seuser swig_types[12] ++#define SWIGTYPE_p_p_p_semanage_bool swig_types[13] ++#define SWIGTYPE_p_p_semanage_bool swig_types[14] ++#define SWIGTYPE_p_semanage_bool swig_types[15] ++#define SWIGTYPE_p_p_semanage_user swig_types[16] ++#define SWIGTYPE_p_semanage_user swig_types[17] ++#define SWIGTYPE_p_size_t swig_types[18] ++#define SWIGTYPE_size_t swig_types[19] ++#define SWIGTYPE_p_p_p_semanage_user swig_types[20] + #define SWIGTYPE_p_p_semanage_user_key swig_types[21] + #define SWIGTYPE_p_semanage_user_key swig_types[22] +-#define SWIGTYPE_p_p_semanage_seuser_key swig_types[23] +-#define SWIGTYPE_p_semanage_iface swig_types[24] ++#define SWIGTYPE_p_semanage_seuser_key swig_types[23] ++#define SWIGTYPE_p_p_semanage_seuser_key swig_types[24] + #define SWIGTYPE_p_p_p_semanage_iface swig_types[25] + #define SWIGTYPE_p_p_semanage_iface swig_types[26] +-#define SWIGTYPE_p_semanage_bool_key swig_types[27] ++#define SWIGTYPE_p_semanage_iface swig_types[27] + #define SWIGTYPE_p_p_semanage_bool_key swig_types[28] +-#define SWIGTYPE_p_unsigned_int swig_types[29] +-#define SWIGTYPE_p_semanage_context swig_types[30] ++#define SWIGTYPE_p_semanage_bool_key swig_types[29] ++#define SWIGTYPE_p_unsigned_int swig_types[30] + #define SWIGTYPE_p_p_semanage_context swig_types[31] +-#define SWIGTYPE_p_p_semanage_module_info swig_types[32] ++#define SWIGTYPE_p_semanage_context swig_types[32] + #define SWIGTYPE_p_semanage_module_info swig_types[33] +-#define SWIGTYPE_p_p_semanage_iface_key swig_types[34] +-#define SWIGTYPE_p_semanage_iface_key swig_types[35] +-#define SWIGTYPE_p_f_p_void_p_struct_semanage_handle_p_q_const__char_v_______void swig_types[36] +-#define SWIGTYPE_ptrdiff_t swig_types[37] +-#define SWIGTYPE_p_int swig_types[38] +-#define SWIGTYPE_p_semanage_handle swig_types[39] +-static swig_type_info *swig_types[41]; ++#define SWIGTYPE_p_p_semanage_module_info swig_types[34] ++#define SWIGTYPE_p_p_semanage_iface_key swig_types[35] ++#define SWIGTYPE_p_semanage_iface_key swig_types[36] ++#define SWIGTYPE_p_f_p_void_p_struct_semanage_handle_p_q_const__char_v_______void swig_types[37] ++#define SWIGTYPE_ptrdiff_t swig_types[38] ++#define SWIGTYPE_p_p_semanage_port swig_types[39] ++#define SWIGTYPE_p_semanage_port swig_types[40] ++#define SWIGTYPE_p_p_p_semanage_port swig_types[41] ++#define SWIGTYPE_p_int swig_types[42] ++#define SWIGTYPE_p_semanage_handle swig_types[43] ++static swig_type_info *swig_types[45]; + + /* -------- TYPES TABLE (END) -------- */ + +@@ -1532,7 +1536,15 @@ + return Py_None; + } + +-int semanage_bool_key_create(semanage_handle_t *,char const *,semanage_bool_key_t **); ++ ++ /*@/usr/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/ ++#define SWIG_From_int PyInt_FromLong ++/*@@*/ ++ ++int semanage_msg_get_level(semanage_handle_t *); ++char const *semanage_msg_get_channel(semanage_handle_t *); ++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 */ + SWIGINTERN int +@@ -1578,59 +1590,6 @@ + } + + +- /*@/usr/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/ +-#define SWIG_From_int PyInt_FromLong +-/*@@*/ +- +-int semanage_bool_key_extract(semanage_handle_t *,semanage_bool_t *,semanage_bool_key_t **); +-void semanage_bool_key_free(semanage_bool_key_t *); +-int semanage_bool_compare(semanage_bool_t *,semanage_bool_key_t *); +-char const *semanage_bool_get_name(semanage_bool_t *); +-int semanage_bool_set_name(semanage_handle_t *,semanage_bool_t *,char const *); +-int semanage_bool_get_value(semanage_bool_t *); +-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 *,semanage_bool_t **); +-void semanage_bool_free(semanage_bool_t *); +-int semanage_msg_get_level(semanage_handle_t *); +-char const *semanage_msg_get_channel(semanage_handle_t *); +-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 *); +-int semanage_iface_query(semanage_handle_t *,semanage_iface_key_t *,semanage_iface_t **); +-int semanage_iface_exists(semanage_handle_t *,semanage_iface_key_t *,int *); +- +-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; +-} +- +- +-int semanage_iface_count(semanage_handle_t *,unsigned int *); +-int semanage_iface_iterate(semanage_handle_t *,int (*)(semanage_iface_t *,void *),void *); +-int semanage_iface_list(semanage_handle_t *,semanage_iface_t ***,size_t *); +-int semanage_bool_add_local(semanage_handle_t *,semanage_bool_key_t *,semanage_bool_t *); +-int semanage_bool_modify_local(semanage_handle_t *,semanage_bool_key_t *,semanage_bool_t *); +-int semanage_bool_set_local(semanage_handle_t *,semanage_bool_key_t *,semanage_bool_t *); +-int semanage_bool_del_local(semanage_handle_t *,semanage_bool_key_t *); +-int semanage_bool_query_local(semanage_handle_t *,semanage_bool_key_t *,semanage_bool_t **); +-int semanage_bool_exists_local(semanage_handle_t *,semanage_bool_key_t *,int *); +-int semanage_bool_count_local(semanage_handle_t *,unsigned int *); +-int semanage_bool_iterate_local(semanage_handle_t *,int (*)(semanage_bool_t *,void *),void *); +-int semanage_bool_list_local(semanage_handle_t *,semanage_bool_t ***,size_t *); +- + SWIGINTERN int + SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val) + { +@@ -1678,6 +1637,91 @@ + return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0); + } + ++ ++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 *); ++int semanage_context_set_user(semanage_handle_t *,semanage_context_t *,char const *); ++char const *semanage_context_get_role(semanage_context_t *); ++int semanage_context_set_role(semanage_handle_t *,semanage_context_t *,char const *); ++char const *semanage_context_get_type(semanage_context_t *); ++int semanage_context_set_type(semanage_handle_t *,semanage_context_t *,char const *); ++char const *semanage_context_get_mls(semanage_context_t *); ++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 *,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 *,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 *,semanage_bool_key_t **); ++void semanage_bool_key_free(semanage_bool_key_t *); ++int semanage_bool_compare(semanage_bool_t *,semanage_bool_key_t *); ++char const *semanage_bool_get_name(semanage_bool_t *); ++int semanage_bool_set_name(semanage_handle_t *,semanage_bool_t *,char const *); ++int semanage_bool_get_value(semanage_bool_t *); ++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 *,semanage_bool_t **); ++void semanage_bool_free(semanage_bool_t *); ++int semanage_bool_query(semanage_handle_t *,semanage_bool_key_t *,semanage_bool_t **); ++int semanage_bool_exists(semanage_handle_t *,semanage_bool_key_t *,int *); ++int semanage_bool_count(semanage_handle_t *,unsigned int *); ++int semanage_bool_iterate(semanage_handle_t *,int (*)(semanage_bool_t *,void *),void *); ++int semanage_bool_list(semanage_handle_t *,semanage_bool_t ***,size_t *); ++int semanage_bool_add_local(semanage_handle_t *,semanage_bool_key_t *,semanage_bool_t *); ++int semanage_bool_modify_local(semanage_handle_t *,semanage_bool_key_t *,semanage_bool_t *); ++int semanage_bool_set_local(semanage_handle_t *,semanage_bool_key_t *,semanage_bool_t *); ++int semanage_bool_del_local(semanage_handle_t *,semanage_bool_key_t *); ++int semanage_bool_query_local(semanage_handle_t *,semanage_bool_key_t *,semanage_bool_t **); ++int semanage_bool_exists_local(semanage_handle_t *,semanage_bool_key_t *,int *); ++int semanage_bool_count_local(semanage_handle_t *,unsigned int *); ++int semanage_bool_iterate_local(semanage_handle_t *,int (*)(semanage_bool_t *,void *),void *); ++int semanage_bool_list_local(semanage_handle_t *,semanage_bool_t ***,size_t *); ++int semanage_iface_compare(semanage_iface_t *,semanage_iface_key_t *); ++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 *,semanage_iface_key_t **); ++void semanage_iface_key_free(semanage_iface_key_t *); ++char const *semanage_iface_get_name(semanage_iface_t *); ++int semanage_iface_set_name(semanage_handle_t *,semanage_iface_t *,char const *); ++semanage_context_t *semanage_iface_get_ifcon(semanage_iface_t *); ++void semanage_iface_set_ifcon(semanage_iface_t *,semanage_context_t *); ++semanage_context_t *semanage_iface_get_msgcon(semanage_iface_t *); ++void semanage_iface_set_msgcon(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 *,semanage_iface_t **); ++void semanage_iface_free(semanage_iface_t *); ++int semanage_iface_add_local(semanage_handle_t *,semanage_iface_key_t *,semanage_iface_t *); ++int semanage_iface_modify_local(semanage_handle_t *,semanage_iface_key_t *,semanage_iface_t *); ++int semanage_iface_set_local(semanage_handle_t *,semanage_iface_key_t *,semanage_iface_t *); ++int semanage_iface_del_local(semanage_handle_t *,semanage_iface_key_t *); ++int semanage_iface_query_local(semanage_handle_t *,semanage_iface_key_t *,semanage_iface_t **); ++int semanage_iface_exists_local(semanage_handle_t *,semanage_iface_key_t *,int *); ++int semanage_iface_count_local(semanage_handle_t *,unsigned int *); ++int semanage_iface_iterate_local(semanage_handle_t *,int (*)(semanage_iface_t *,void *),void *); ++int semanage_iface_list_local(semanage_handle_t *,semanage_iface_t ***,size_t *); ++int semanage_iface_query(semanage_handle_t *,semanage_iface_key_t *,semanage_iface_t **); ++int semanage_iface_exists(semanage_handle_t *,semanage_iface_key_t *,int *); ++int semanage_iface_count(semanage_handle_t *,unsigned int *); ++int semanage_iface_iterate(semanage_handle_t *,int (*)(semanage_iface_t *,void *),void *); ++int semanage_iface_list(semanage_handle_t *,semanage_iface_t ***,size_t *); + 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 *,semanage_user_key_t **); + void semanage_user_key_free(semanage_user_key_t *); +@@ -1697,24 +1741,50 @@ + int semanage_user_create(semanage_handle_t *,semanage_user_t **); + int semanage_user_clone(semanage_handle_t *,semanage_user_t *,semanage_user_t **); + void semanage_user_free(semanage_user_t *); +-int semanage_bool_query(semanage_handle_t *,semanage_bool_key_t *,semanage_bool_t **); +-int semanage_bool_exists(semanage_handle_t *,semanage_bool_key_t *,int *); +-int semanage_bool_count(semanage_handle_t *,unsigned int *); +-int semanage_bool_iterate(semanage_handle_t *,int (*)(semanage_bool_t *,void *),void *); +-int semanage_bool_list(semanage_handle_t *,semanage_bool_t ***,size_t *); +-int semanage_iface_compare(semanage_iface_t *,semanage_iface_key_t *); +-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 *,semanage_iface_key_t **); +-void semanage_iface_key_free(semanage_iface_key_t *); +-char const *semanage_iface_get_name(semanage_iface_t *); +-int semanage_iface_set_name(semanage_handle_t *,semanage_iface_t *,char const *); +-semanage_context_t *semanage_iface_get_ifcon(semanage_iface_t *); +-void semanage_iface_set_ifcon(semanage_iface_t *,semanage_context_t *); +-semanage_context_t *semanage_iface_get_msgcon(semanage_iface_t *); +-void semanage_iface_set_msgcon(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 *,semanage_iface_t **); +-void semanage_iface_free(semanage_iface_t *); ++int semanage_user_add_local(semanage_handle_t *,semanage_user_key_t *,semanage_user_t *); ++int semanage_user_modify_local(semanage_handle_t *,semanage_user_key_t *,semanage_user_t *); ++int semanage_user_set_local(semanage_handle_t *,semanage_user_key_t *,semanage_user_t *); ++int semanage_user_del_local(semanage_handle_t *,semanage_user_key_t *); ++int semanage_user_query_local(semanage_handle_t *,semanage_user_key_t *,semanage_user_t **); ++int semanage_user_exists_local(semanage_handle_t *,semanage_user_key_t *,int *); ++int semanage_user_count_local(semanage_handle_t *,unsigned int *); ++int semanage_user_iterate_local(semanage_handle_t *,int (*)(semanage_user_t *,void *),void *); ++int semanage_user_list_local(semanage_handle_t *,semanage_user_t ***,size_t *); ++int semanage_user_query(semanage_handle_t *,semanage_user_key_t *,semanage_user_t **); ++int semanage_user_exists(semanage_handle_t *,semanage_user_key_t *,int *); ++int semanage_user_count(semanage_handle_t *,unsigned int *); ++int semanage_user_iterate(semanage_handle_t *,int (*)(semanage_user_t *,void *),void *); ++int semanage_user_list(semanage_handle_t *,semanage_user_t ***,size_t *); ++int semanage_port_compare(semanage_port_t *,semanage_port_key_t *); ++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 *,semanage_port_key_t **); ++void semanage_port_key_free(semanage_port_key_t *); ++int semanage_port_get_proto(semanage_port_t *); ++void semanage_port_set_proto(semanage_port_t *,int); ++char const *semanage_port_get_proto_str(semanage_port_t *); ++int semanage_port_get_low(semanage_port_t *); ++int semanage_port_get_high(semanage_port_t *); ++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 *); ++void semanage_port_set_con(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 *,semanage_port_t **); ++void semanage_port_free(semanage_port_t *); ++int semanage_port_add_local(semanage_handle_t *,semanage_port_key_t *,semanage_port_t *); ++int semanage_port_modify_local(semanage_handle_t *,semanage_port_key_t *,semanage_port_t *); ++int semanage_port_set_local(semanage_handle_t *,semanage_port_key_t *,semanage_port_t *); ++int semanage_port_del_local(semanage_handle_t *,semanage_port_key_t *); ++int semanage_port_query_local(semanage_handle_t *,semanage_port_key_t *,semanage_port_t **); ++int semanage_port_exists_local(semanage_handle_t *,semanage_port_key_t *,int *); ++int semanage_port_count_local(semanage_handle_t *,unsigned int *); ++int semanage_port_iterate_local(semanage_handle_t *,int (*)(semanage_port_t *,void *),void *); ++int semanage_port_list_local(semanage_handle_t *,semanage_port_t ***,size_t *); ++int semanage_port_query(semanage_handle_t *,semanage_port_key_t *,semanage_port_t **); ++int semanage_port_exists(semanage_handle_t *,semanage_port_key_t *,int *); ++int semanage_port_count(semanage_handle_t *,unsigned int *); ++int semanage_port_iterate(semanage_handle_t *,int (*)(semanage_port_t *,void *),void *); ++int semanage_port_list(semanage_handle_t *,semanage_port_t ***,size_t *); + 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 *,semanage_seuser_key_t **); + void semanage_seuser_key_free(semanage_seuser_key_t *); +@@ -1728,37 +1798,6 @@ + int semanage_seuser_create(semanage_handle_t *,semanage_seuser_t **); + int semanage_seuser_clone(semanage_handle_t *,semanage_seuser_t *,semanage_seuser_t **); + void semanage_seuser_free(semanage_seuser_t *); +-int semanage_user_add_local(semanage_handle_t *,semanage_user_key_t *,semanage_user_t *); +-int semanage_user_modify_local(semanage_handle_t *,semanage_user_key_t *,semanage_user_t *); +-int semanage_user_set_local(semanage_handle_t *,semanage_user_key_t *,semanage_user_t *); +-int semanage_user_del_local(semanage_handle_t *,semanage_user_key_t *); +-int semanage_user_query_local(semanage_handle_t *,semanage_user_key_t *,semanage_user_t **); +-int semanage_user_exists_local(semanage_handle_t *,semanage_user_key_t *,int *); +-int semanage_user_count_local(semanage_handle_t *,unsigned int *); +-int semanage_user_iterate_local(semanage_handle_t *,int (*)(semanage_user_t *,void *),void *); +-int semanage_user_list_local(semanage_handle_t *,semanage_user_t ***,size_t *); +-char const *semanage_context_get_user(semanage_context_t *); +-int semanage_context_set_user(semanage_handle_t *,semanage_context_t *,char const *); +-char const *semanage_context_get_role(semanage_context_t *); +-int semanage_context_set_role(semanage_handle_t *,semanage_context_t *,char const *); +-char const *semanage_context_get_type(semanage_context_t *); +-int semanage_context_set_type(semanage_handle_t *,semanage_context_t *,char const *); +-char const *semanage_context_get_mls(semanage_context_t *); +-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 *,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 *,char **); +-int semanage_iface_add_local(semanage_handle_t *,semanage_iface_key_t *,semanage_iface_t *); +-int semanage_iface_modify_local(semanage_handle_t *,semanage_iface_key_t *,semanage_iface_t *); +-int semanage_iface_set_local(semanage_handle_t *,semanage_iface_key_t *,semanage_iface_t *); +-int semanage_iface_del_local(semanage_handle_t *,semanage_iface_key_t *); +-int semanage_iface_query_local(semanage_handle_t *,semanage_iface_key_t *,semanage_iface_t **); +-int semanage_iface_exists_local(semanage_handle_t *,semanage_iface_key_t *,int *); +-int semanage_iface_count_local(semanage_handle_t *,unsigned int *); +-int semanage_iface_iterate_local(semanage_handle_t *,int (*)(semanage_iface_t *,void *),void *); +-int semanage_iface_list_local(semanage_handle_t *,semanage_iface_t ***,size_t *); + int semanage_seuser_add(semanage_handle_t *,semanage_seuser_key_t *,semanage_seuser_t *); + int semanage_seuser_modify(semanage_handle_t *,semanage_seuser_key_t *,semanage_seuser_t *); + int semanage_seuser_set(semanage_handle_t *,semanage_seuser_key_t *,semanage_seuser_t *); +@@ -1768,11 +1807,6 @@ + int semanage_seuser_count(semanage_handle_t *,unsigned int *); + int semanage_seuser_iterate(semanage_handle_t *,int (*)(semanage_seuser_t *,void *),void *); + int semanage_seuser_list(semanage_handle_t *,semanage_seuser_t ***,size_t *); +-int semanage_user_query(semanage_handle_t *,semanage_user_key_t *,semanage_user_t **); +-int semanage_user_exists(semanage_handle_t *,semanage_user_key_t *,int *); +-int semanage_user_count(semanage_handle_t *,unsigned int *); +-int semanage_user_iterate(semanage_handle_t *,int (*)(semanage_user_t *,void *),void *); +-int semanage_user_list(semanage_handle_t *,semanage_user_t ***,size_t *); + #ifdef __cplusplus + extern "C" { + #endif +@@ -1833,7 +1867,7 @@ + PyObject * obj1 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"OO:semanage_port_by_idx",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_p_semanage_port_t, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_p_semanage_port, SWIG_POINTER_EXCEPTION | 0); + if (SWIG_arg_fail(1)) SWIG_fail; + { + arg2 = (int)(SWIG_As_int(obj1)); +@@ -1841,7 +1875,7 @@ + } + result = (semanage_port_t *)semanage_port_by_idx(arg1,arg2); + +- resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_semanage_port_t, 0); ++ resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_semanage_port, 0); + return resultobj; + fail: + return NULL; +@@ -1872,25 +1906,16 @@ + } + + +-static PyObject *_wrap_semanage_bool_key_create(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_msg_get_level(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; + PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_bool_key_create",&obj0,&obj1,&obj2)) goto fail; ++ 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; +- if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { +- SWIG_arg_fail(2);SWIG_fail; +- } +- SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_p_semanage_bool_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_bool_key_create(arg1,(char const *)arg2,arg3); ++ result = (int)semanage_msg_get_level(arg1); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -1901,132 +1926,139 @@ + } + + +-static PyObject *_wrap_semanage_bool_key_extract(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_msg_get_channel(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; ++ char *result; + PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_bool_key_extract",&obj0,&obj1,&obj2)) goto fail; ++ 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; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_bool, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_p_semanage_bool_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_bool_key_extract(arg1,arg2,arg3); ++ result = (char *)semanage_msg_get_channel(arg1); + +- { +- resultobj = SWIG_From_int((int)(result)); +- } ++ resultobj = SWIG_FromCharPtr(result); + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_bool_key_free(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_msg_get_fname(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_bool_key_t *arg1 = (semanage_bool_key_t *) 0 ; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ char *result; + 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(!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; +- semanage_bool_key_free(arg1); ++ result = (char *)semanage_msg_get_fname(arg1); + +- Py_INCREF(Py_None); resultobj = Py_None; ++ resultobj = SWIG_FromCharPtr(result); + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_bool_compare(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_msg_set_callback(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; ++ 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 *)"OO:semanage_bool_compare",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_bool, SWIG_POINTER_EXCEPTION | 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_semanage_bool_key, SWIG_POINTER_EXCEPTION | 0); ++ 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; +- result = (int)semanage_bool_compare(arg1,arg2); +- + { +- resultobj = SWIG_From_int((int)(result)); ++ if ((SWIG_ConvertPtr(obj2,(void **)(&arg3),0,SWIG_POINTER_EXCEPTION|0))== -1) { ++ SWIG_arg_fail(3);SWIG_fail; ++ } + } ++ semanage_msg_set_callback(arg1,arg2,arg3); ++ ++ Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_bool_get_name(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_handle_create(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_bool_t *arg1 = (semanage_bool_t *) 0 ; +- char *result; ++ 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; ++} ++ ++ ++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_bool_get_name",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_bool, SWIG_POINTER_EXCEPTION | 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; +- result = (char *)semanage_bool_get_name(arg1); ++ semanage_handle_destroy(arg1); + +- resultobj = SWIG_FromCharPtr(result); ++ Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_bool_set_name(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_select_store(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; ++ 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_bool_set_name",&obj0,&obj1,&obj2)) goto fail; ++ 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; +- 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; ++ if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { ++ SWIG_arg_fail(2);SWIG_fail; + } +- result = (int)semanage_bool_set_name(arg1,arg2,(char const *)arg3); +- + { +- resultobj = SWIG_From_int((int)(result)); ++ 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; + } + + +-static PyObject *_wrap_semanage_bool_get_value(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_reload_policy(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_bool_t *arg1 = (semanage_bool_t *) 0 ; ++ semanage_handle_t *arg1 = (semanage_handle_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(!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_bool_get_value(arg1); ++ result = (int)semanage_reload_policy(arg1); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -2037,21 +2069,21 @@ + } + + +-static PyObject *_wrap_semanage_bool_set_value(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_set_reload(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_bool_t *arg1 = (semanage_bool_t *) 0 ; ++ semanage_handle_t *arg1 = (semanage_handle_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(!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_bool_set_value(arg1,arg2); ++ semanage_set_reload(arg1,arg2); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; +@@ -2060,20 +2092,16 @@ + } + + +-static PyObject *_wrap_semanage_bool_create(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_is_managed(PyObject *self, PyObject *args) { + PyObject *resultobj; + semanage_handle_t *arg1 = (semanage_handle_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_create",&obj0,&obj1)) goto fail; ++ 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; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_p_semanage_bool, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_bool_create(arg1,arg2); ++ result = (int)semanage_is_managed(arg1); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -2084,24 +2112,16 @@ + } + + +-static PyObject *_wrap_semanage_bool_clone(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_connect(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; + PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_bool_clone",&obj0,&obj1,&obj2)) goto fail; ++ 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; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_bool, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_p_semanage_bool, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_bool_clone(arg1,arg2,arg3); ++ result = (int)semanage_connect(arg1); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -2112,33 +2132,36 @@ + } + + +-static PyObject *_wrap_semanage_bool_free(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_disconnect(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_bool_t *arg1 = (semanage_bool_t *) 0 ; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ int result; + 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(!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; +- semanage_bool_free(arg1); ++ result = (int)semanage_disconnect(arg1); + +- Py_INCREF(Py_None); resultobj = Py_None; ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_msg_get_level(PyObject *self, PyObject *args) { ++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_msg_get_level",&obj0)) goto fail; ++ 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_msg_get_level(arg1); ++ result = (int)semanage_begin_transaction(arg1); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -2149,88 +2172,109 @@ + } + + +-static PyObject *_wrap_semanage_msg_get_channel(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_commit(PyObject *self, PyObject *args) { + PyObject *resultobj; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- char *result; ++ int result; + PyObject * obj0 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_msg_get_channel",&obj0)) goto fail; ++ 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 = (char *)semanage_msg_get_channel(arg1); ++ result = (int)semanage_commit(arg1); + +- resultobj = SWIG_FromCharPtr(result); ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_msg_get_fname(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_module_install(PyObject *self, PyObject *args) { + PyObject *resultobj; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- char *result; ++ char *arg2 = (char *) 0 ; ++ size_t arg3 ; ++ int result; + PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_msg_get_fname",&obj0)) goto fail; ++ 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; +- result = (char *)semanage_msg_get_fname(arg1); ++ 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_FromCharPtr(result); ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_msg_set_callback(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_module_upgrade(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 ; ++ 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_msg_set_callback",&obj0,&obj1,&obj2)) goto fail; ++ 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; +- 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_AsCharPtr(obj1, (char**)&arg2)) { ++ SWIG_arg_fail(2);SWIG_fail; ++ } + { +- if ((SWIG_ConvertPtr(obj2,(void **)(&arg3),0,SWIG_POINTER_EXCEPTION|0))== -1) { +- SWIG_arg_fail(3);SWIG_fail; +- } ++ arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2)); ++ if (SWIG_arg_fail(3)) SWIG_fail; + } +- semanage_msg_set_callback(arg1,arg2,arg3); ++ result = (int)semanage_module_upgrade(arg1,arg2,arg3); + +- Py_INCREF(Py_None); resultobj = Py_None; ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_iface_query(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_module_install_base(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 ; ++ 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_iface_query",&obj0,&obj1,&obj2)) goto fail; ++ 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; +- 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_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_iface_query(arg1,arg2,arg3); ++ 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)); +@@ -2241,50 +2285,785 @@ + } + + +-static PyObject *_wrap_semanage_iface_exists(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_module_remove(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 ; ++ char *arg2 = (char *) 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; ++ 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; +- 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,arg2,arg3); ++ 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)); + } +- 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; + } + + +-static PyObject *_wrap_semanage_iface_count(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_module_list(PyObject *self, PyObject *args) { + PyObject *resultobj; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- unsigned int *arg2 = (unsigned int *) 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 ; +- PyObject * obj1 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_count",&obj0,&obj1)) goto fail; ++ { ++ 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; ++} ++ ++ ++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; ++} ++ ++ ++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; ++} ++ ++ ++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; ++} ++ ++ ++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; ++} ++ ++ ++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(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; ++} ++ ++ ++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(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; ++} ++ ++ ++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(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; ++} ++ ++ ++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(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; ++} ++ ++ ++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; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if(!PyArg_ParseTuple(args,(char *)"OO:semanage_context_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; ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); ++ if (SWIG_arg_fail(2)) SWIG_fail; ++ result = (int)semanage_context_create(arg1,arg2); ++ ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } ++ 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; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_context_clone",&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; ++ SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); ++ if (SWIG_arg_fail(3)) SWIG_fail; ++ result = (int)semanage_context_clone(arg1,arg2,arg3); ++ ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } ++ 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; ++} ++ ++ ++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; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_context_from_string",&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; ++ } ++ SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); ++ if (SWIG_arg_fail(3)) SWIG_fail; ++ result = (int)semanage_context_from_string(arg1,(char const *)arg2,arg3); ++ ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } ++ return resultobj; ++ fail: ++ 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; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_context_to_string",&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; ++ SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_p_char, SWIG_POINTER_EXCEPTION | 0); ++ if (SWIG_arg_fail(3)) SWIG_fail; ++ result = (int)semanage_context_to_string(arg1,arg2,arg3); ++ ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } ++ 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; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_bool_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; ++ } ++ SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_p_semanage_bool_key, SWIG_POINTER_EXCEPTION | 0); ++ if (SWIG_arg_fail(3)) SWIG_fail; ++ result = (int)semanage_bool_key_create(arg1,(char const *)arg2,arg3); ++ ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } ++ return resultobj; ++ fail: ++ 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; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_bool_key_extract",&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; ++ SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_p_semanage_bool_key, SWIG_POINTER_EXCEPTION | 0); ++ if (SWIG_arg_fail(3)) SWIG_fail; ++ result = (int)semanage_bool_key_extract(arg1,arg2,arg3); ++ ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } ++ 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; ++} ++ ++ ++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(arg1,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(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; ++} ++ ++ ++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(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; ++} ++ ++ ++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; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if(!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_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; ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_p_semanage_bool, SWIG_POINTER_EXCEPTION | 0); ++ if (SWIG_arg_fail(2)) SWIG_fail; ++ result = (int)semanage_bool_create(arg1,arg2); ++ ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } ++ 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; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_bool_clone",&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; ++ SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_p_semanage_bool, SWIG_POINTER_EXCEPTION | 0); ++ if (SWIG_arg_fail(3)) SWIG_fail; ++ result = (int)semanage_bool_clone(arg1,arg2,arg3); ++ ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } ++ 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; ++} ++ ++ ++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; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ ++ if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_bool_query",&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_p_semanage_bool, SWIG_POINTER_EXCEPTION | 0); ++ if (SWIG_arg_fail(3)) SWIG_fail; ++ result = (int)semanage_bool_query(arg1,arg2,arg3); ++ ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } ++ 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,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; ++} ++ ++ ++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; ++ PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ ++ if(!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_count",&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_unsigned_int, SWIG_POINTER_EXCEPTION | 0); + if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_iface_count(arg1,arg2); ++ result = (int)semanage_bool_count(arg1,arg2); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -2295,27 +3074,27 @@ + } + + +-static PyObject *_wrap_semanage_iface_iterate(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_bool_iterate(PyObject *self, PyObject *args) { + PyObject *resultobj; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int (*arg2)(semanage_iface_t *,void *) = (int (*)(semanage_iface_t *,void *)) 0 ; ++ int (*arg2)(semanage_bool_t *,void *) = (int (*)(semanage_bool_t *,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; ++ 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_struct_semanage_iface_p_void__int, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_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_iface_iterate(arg1,arg2,arg3); ++ result = (int)semanage_bool_iterate(arg1,arg2,arg3); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -2326,10 +3105,10 @@ + } + + +-static PyObject *_wrap_semanage_iface_list(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_bool_list(PyObject *self, PyObject *args) { + PyObject *resultobj; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_iface_t ***arg2 = (semanage_iface_t ***) 0 ; ++ semanage_bool_t ***arg2 = (semanage_bool_t ***) 0 ; + size_t *arg3 = (size_t *) 0 ; + int result; + size_t temp3 ; +@@ -2338,12 +3117,12 @@ + PyObject * obj1 = 0 ; + + arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_list",&obj0,&obj1)) goto fail; ++ if(!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_list",&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_p_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_p_p_semanage_bool, SWIG_POINTER_EXCEPTION | 0); + if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_iface_list(arg1,arg2,arg3); ++ result = (int)semanage_bool_list(arg1,arg2,arg3); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -2607,75 +3386,77 @@ + } + + +-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; +-} +- +- +-static PyObject *_wrap_semanage_handle_destroy(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_iface_compare(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ 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 *)"O:semanage_handle_destroy",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 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; +- semanage_handle_destroy(arg1); ++ 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(arg1,arg2); + +- Py_INCREF(Py_None); resultobj = Py_None; ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_select_store(PyObject *self, PyObject *args) { ++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 ; +- enum semanage_connect_type arg3 ; ++ semanage_iface_key_t **arg3 = (semanage_iface_key_t **) 0 ; ++ int result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_select_store",&obj0,&obj1,&obj2)) goto fail; ++ if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_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; + } ++ SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_p_semanage_iface_key, SWIG_POINTER_EXCEPTION | 0); ++ if (SWIG_arg_fail(3)) SWIG_fail; ++ result = (int)semanage_iface_key_create(arg1,(char const *)arg2,arg3); ++ + { +- arg3 = (enum semanage_connect_type)(SWIG_As_int(obj2)); +- if (SWIG_arg_fail(3)) SWIG_fail; ++ resultobj = SWIG_From_int((int)(result)); + } +- semanage_select_store(arg1,arg2,(enum semanage_connect_type )arg3); +- +- Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_reload_policy(PyObject *self, PyObject *args) { ++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; + PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_reload_policy",&obj0)) goto fail; ++ if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_key_extract",&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; +- result = (int)semanage_reload_policy(arg1); ++ 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_p_semanage_iface_key, SWIG_POINTER_EXCEPTION | 0); ++ if (SWIG_arg_fail(3)) SWIG_fail; ++ result = (int)semanage_iface_key_extract(arg1,arg2,arg3); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -2686,21 +3467,15 @@ + } + + +-static PyObject *_wrap_semanage_set_reload(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_iface_key_free(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int arg2 ; ++ semanage_iface_key_t *arg1 = (semanage_iface_key_t *) 0 ; + 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(!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; +- { +- arg2 = (int)(SWIG_As_int(obj1)); +- if (SWIG_arg_fail(2)) SWIG_fail; +- } +- semanage_set_reload(arg1,arg2); ++ semanage_iface_key_free(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; +@@ -2709,36 +3484,43 @@ + } + + +-static PyObject *_wrap_semanage_is_managed(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_iface_get_name(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int result; ++ semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; ++ char *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(!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 = (int)semanage_is_managed(arg1); ++ result = (char *)semanage_iface_get_name(arg1); + +- { +- resultobj = SWIG_From_int((int)(result)); +- } ++ resultobj = SWIG_FromCharPtr(result); + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_connect(PyObject *self, PyObject *args) { ++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 *)"O:semanage_connect",&obj0)) goto fail; ++ 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; +- result = (int)semanage_connect(arg1); ++ 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)); +@@ -2749,118 +3531,98 @@ + } + + +-static PyObject *_wrap_semanage_disconnect(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_iface_get_ifcon(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int result; ++ semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; ++ semanage_context_t *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(!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 = (int)semanage_disconnect(arg1); ++ result = (semanage_context_t *)semanage_iface_get_ifcon(arg1); + +- { +- resultobj = SWIG_From_int((int)(result)); +- } ++ resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_semanage_context, 0); + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_begin_transaction(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_iface_set_ifcon(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int result; ++ semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; ++ semanage_context_t *arg2 = (semanage_context_t *) 0 ; + PyObject * obj0 = 0 ; ++ PyObject * obj1 = 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(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_set_ifcon",&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; +- result = (int)semanage_begin_transaction(arg1); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); ++ if (SWIG_arg_fail(2)) SWIG_fail; ++ semanage_iface_set_ifcon(arg1,arg2); + +- { +- resultobj = SWIG_From_int((int)(result)); +- } ++ Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_commit(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_iface_get_msgcon(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int result; ++ semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; ++ semanage_context_t *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(!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 = (int)semanage_commit(arg1); ++ result = (semanage_context_t *)semanage_iface_get_msgcon(arg1); + +- { +- resultobj = SWIG_From_int((int)(result)); +- } ++ resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_semanage_context, 0); + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_module_install(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_iface_set_msgcon(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- char *arg2 = (char *) 0 ; +- size_t arg3 ; +- int result; ++ semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; ++ semanage_context_t *arg2 = (semanage_context_t *) 0 ; + 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(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_set_msgcon",&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; +- 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); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); ++ if (SWIG_arg_fail(2)) SWIG_fail; ++ semanage_iface_set_msgcon(arg1,arg2); + +- { +- resultobj = SWIG_From_int((int)(result)); +- } ++ Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_module_upgrade(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_iface_create(PyObject *self, PyObject *args) { + PyObject *resultobj; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- char *arg2 = (char *) 0 ; +- size_t arg3 ; ++ semanage_iface_t **arg2 = (semanage_iface_t **) 0 ; + 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; ++ if(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_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; +- } +- { +- arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2)); +- if (SWIG_arg_fail(3)) SWIG_fail; +- } +- result = (int)semanage_module_upgrade(arg1,arg2,arg3); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); ++ if (SWIG_arg_fail(2)) SWIG_fail; ++ result = (int)semanage_iface_create(arg1,arg2); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -2871,27 +3633,24 @@ + } + + +-static PyObject *_wrap_semanage_module_install_base(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_iface_clone(PyObject *self, PyObject *args) { + PyObject *resultobj; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- char *arg2 = (char *) 0 ; +- size_t arg3 ; ++ semanage_iface_t *arg2 = (semanage_iface_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_module_install_base",&obj0,&obj1,&obj2)) goto fail; ++ if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_clone",&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); ++ 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_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); ++ if (SWIG_arg_fail(3)) SWIG_fail; ++ result = (int)semanage_iface_clone(arg1,arg2,arg3); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -2902,238 +3661,234 @@ + } + + +-static PyObject *_wrap_semanage_module_remove(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_iface_free(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- char *arg2 = (char *) 0 ; +- int result; ++ semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; + 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(!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; +- if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { +- SWIG_arg_fail(2);SWIG_fail; +- } +- result = (int)semanage_module_remove(arg1,arg2); ++ semanage_iface_free(arg1); + +- { +- resultobj = SWIG_From_int((int)(result)); +- } ++ Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_module_list(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_iface_add_local(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 ; ++ semanage_iface_key_t *arg2 = (semanage_iface_key_t *) 0 ; ++ semanage_iface_t *arg3 = (semanage_iface_t *) 0 ; + int result; +- semanage_module_info_t *temp2 ; +- int temp3 ; +- int res3 = 0 ; + PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; + +- { +- arg2 = &temp2; +- } +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_module_list",&obj0)) goto fail; ++ if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_add_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; +- result = (int)semanage_module_list(arg1,arg2,arg3); ++ 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_add_local(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; +-} +- +- +-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; + } + + +-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; ++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 *)"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(!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,arg2,arg3); ++ + { +- arg2 = (int)(SWIG_As_int(obj1)); +- if (SWIG_arg_fail(2)) SWIG_fail; ++ resultobj = SWIG_From_int((int)(result)); + } +- 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; + } + + +-static PyObject *_wrap_semanage_module_get_name(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_iface_set_local(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_module_info_t *arg1 = (semanage_module_info_t *) 0 ; +- char *result; ++ 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 *)"O:semanage_module_get_name",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_module_info, SWIG_POINTER_EXCEPTION | 0); ++ if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_set_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; +- result = (char *)semanage_module_get_name(arg1); ++ 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_set_local(arg1,arg2,arg3); + +- resultobj = SWIG_FromCharPtr(result); ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_module_get_version(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_iface_del_local(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_module_info_t *arg1 = (semanage_module_info_t *) 0 ; +- char *result; ++ 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 *)"O:semanage_module_get_version",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_module_info, SWIG_POINTER_EXCEPTION | 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; +- result = (char *)semanage_module_get_version(arg1); ++ 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,arg2); + +- resultobj = SWIG_FromCharPtr(result); ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_user_key_create(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_iface_query_local(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 ; ++ semanage_iface_key_t *arg2 = (semanage_iface_key_t *) 0 ; ++ semanage_iface_t **arg3 = (semanage_iface_t **) 0 ; + int result; +- semanage_user_key_t *temp3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; + +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_user_key_create",&obj0,&obj1)) goto fail; ++ if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_query_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; +- if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { +- SWIG_arg_fail(2);SWIG_fail; +- } +- result = (int)semanage_user_key_create(arg1,(char const *)arg2,arg3); ++ 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_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); ++ if (SWIG_arg_fail(3)) SWIG_fail; ++ result = (int)semanage_iface_query_local(arg1,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; + } + + +-static PyObject *_wrap_semanage_user_key_extract(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_iface_exists_local(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 ; ++ semanage_iface_key_t *arg2 = (semanage_iface_key_t *) 0 ; ++ int *arg3 = (int *) 0 ; + int result; +- semanage_user_key_t *temp3 ; ++ int temp3 ; ++ int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_user_key_extract",&obj0,&obj1)) goto fail; ++ 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_user, SWIG_POINTER_EXCEPTION | 0); ++ 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_user_key_extract(arg1,arg2,arg3); ++ result = (int)semanage_iface_exists_local(arg1,arg2,arg3); + + { + resultobj = SWIG_From_int((int)(result)); + } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_user_key, 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; + } + + +-static PyObject *_wrap_semanage_user_key_free(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_iface_count_local(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_user_key_t *arg1 = (semanage_user_key_t *) 0 ; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ unsigned int *arg2 = (unsigned int *) 0 ; ++ int result; + PyObject * obj0 = 0 ; ++ PyObject * obj1 = 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(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_count_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; +- semanage_user_key_free(arg1); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_int, SWIG_POINTER_EXCEPTION | 0); ++ if (SWIG_arg_fail(2)) SWIG_fail; ++ result = (int)semanage_iface_count_local(arg1,arg2); + +- Py_INCREF(Py_None); resultobj = Py_None; ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_user_compare(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_iface_iterate_local(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_user_t *arg1 = (semanage_user_t *) 0 ; +- semanage_user_key_t *arg2 = (semanage_user_key_t *) 0 ; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ int (*arg2)(semanage_iface_t *,void *) = (int (*)(semanage_iface_t *,void *)) 0 ; ++ void *arg3 = (void *) 0 ; + int result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ PyObject * obj2 = 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(!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_semanage_user_key, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_struct_semanage_iface_p_void__int, SWIG_POINTER_EXCEPTION | 0); + if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_user_compare(arg1,arg2); ++ { ++ 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)); +@@ -3144,43 +3899,54 @@ + } + + +-static PyObject *_wrap_semanage_user_get_name(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_iface_list_local(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_user_t *arg1 = (semanage_user_t *) 0 ; +- char *result; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ semanage_iface_t ***arg2 = (semanage_iface_t ***) 0 ; ++ size_t *arg3 = (size_t *) 0 ; ++ int result; ++ size_t temp3 ; ++ int res3 = 0 ; + PyObject * obj0 = 0 ; ++ PyObject * obj1 = 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); ++ arg3 = &temp3; res3 = SWIG_NEWOBJ; ++ if(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_list_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; +- result = (char *)semanage_user_get_name(arg1); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_p_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); ++ if (SWIG_arg_fail(2)) SWIG_fail; ++ result = (int)semanage_iface_list_local(arg1,arg2,arg3); + +- resultobj = SWIG_FromCharPtr(result); ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } ++ resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? ++ SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_size_t, 0))); + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_user_set_name(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_iface_query(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 ; ++ 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_user_set_name",&obj0,&obj1,&obj2)) goto fail; ++ if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_query",&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); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_iface_key, 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); ++ SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); ++ if (SWIG_arg_fail(3)) SWIG_fail; ++ result = (int)semanage_iface_query(arg1,arg2,arg3); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -3191,43 +3957,50 @@ + } + + +-static PyObject *_wrap_semanage_user_get_mlslevel(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_iface_exists(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_user_t *arg1 = (semanage_user_t *) 0 ; +- char *result; ++ 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 ; + +- 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); ++ 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; +- result = (char *)semanage_user_get_mlslevel(arg1); ++ 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,arg2,arg3); + +- resultobj = SWIG_FromCharPtr(result); ++ { ++ 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; + } + + +-static PyObject *_wrap_semanage_user_set_mlslevel(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_iface_count(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 *arg2 = (unsigned int *) 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; ++ if(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_count",&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); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_int, 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); ++ result = (int)semanage_iface_count(arg1,arg2); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -3238,116 +4011,141 @@ + } + + +-static PyObject *_wrap_semanage_user_get_mlsrange(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_iface_iterate(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_user_t *arg1 = (semanage_user_t *) 0 ; +- char *result; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ int (*arg2)(semanage_iface_t *,void *) = (int (*)(semanage_iface_t *,void *)) 0 ; ++ void *arg3 = (void *) 0 ; ++ int result; + PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 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(!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; +- result = (char *)semanage_user_get_mlsrange(arg1); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_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_FromCharPtr(result); ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_user_set_mlsrange(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_iface_list(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 ; ++ semanage_iface_t ***arg2 = (semanage_iface_t ***) 0 ; ++ size_t *arg3 = (size_t *) 0 ; + int result; ++ size_t temp3 ; ++ int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_set_mlsrange",&obj0,&obj1,&obj2)) goto fail; ++ arg3 = &temp3; res3 = SWIG_NEWOBJ; ++ if(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_list",&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); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_p_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_user_set_mlsrange(arg1,arg2,(char const *)arg3); ++ result = (int)semanage_iface_list(arg1,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_size_t, 0))); + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_user_get_num_roles(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_key_create(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_user_t *arg1 = (semanage_user_t *) 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; ++ semanage_user_key_t *temp3 ; + PyObject * obj0 = 0 ; ++ PyObject * obj1 = 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); ++ { ++ 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; +- result = (int)semanage_user_get_num_roles(arg1); ++ 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; + } + + +-static PyObject *_wrap_semanage_user_add_role(PyObject *self, PyObject *args) { ++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 ; +- char *arg3 = (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 ; +- PyObject * obj2 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_add_role",&obj0,&obj1,&obj2)) goto fail; ++ { ++ 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; +- if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) { +- SWIG_arg_fail(3);SWIG_fail; +- } +- result = (int)semanage_user_add_role(arg1,arg2,(char const *)arg3); ++ result = (int)semanage_user_key_extract(arg1,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; + } + + +-static PyObject *_wrap_semanage_user_del_role(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_key_free(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_user_t *arg1 = (semanage_user_t *) 0 ; +- char *arg2 = (char *) 0 ; ++ semanage_user_key_t *arg1 = (semanage_user_key_t *) 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(!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; +- if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { +- SWIG_arg_fail(2);SWIG_fail; +- } +- semanage_user_del_role(arg1,(char const *)arg2); ++ semanage_user_key_free(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; +@@ -3356,21 +4154,20 @@ + } + + +-static PyObject *_wrap_semanage_user_has_role(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_compare(PyObject *self, PyObject *args) { + PyObject *resultobj; + semanage_user_t *arg1 = (semanage_user_t *) 0 ; +- char *arg2 = (char *) 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_has_role",&obj0,&obj1)) goto fail; ++ 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; +- if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { +- SWIG_arg_fail(2);SWIG_fail; +- } +- result = (int)semanage_user_has_role(arg1,(char const *)arg2); ++ 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(arg1,arg2); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -3381,68 +4178,43 @@ + } + + +-static PyObject *_wrap_semanage_user_get_roles(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_get_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 ; +- size_t *arg4 = (size_t *) 0 ; +- int result; +- char **temp3 ; +- size_t temp4 ; +- int res4 = 0 ; ++ semanage_user_t *arg1 = (semanage_user_t *) 0 ; ++ char *result; + 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(!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; +- 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,arg2,(char const ***)arg3,arg4); ++ result = (char *)semanage_user_get_name(arg1); + +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_p_char, 0)); +- } +- resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_size_t, 0))); ++ resultobj = SWIG_FromCharPtr(result); + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_user_set_roles(PyObject *self, PyObject *args) { ++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 ; +- size_t arg4 ; ++ char *arg3 = (char *) 0 ; + int result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; +- PyObject * obj3 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OOOO:semanage_user_set_roles",&obj0,&obj1,&obj2,&obj3)) goto fail; ++ 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; +- SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_p_char, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- { +- arg4 = (size_t)(SWIG_As_unsigned_SS_long(obj3)); +- if (SWIG_arg_fail(4)) SWIG_fail; ++ if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) { ++ SWIG_arg_fail(3);SWIG_fail; + } +- result = (int)semanage_user_set_roles(arg1,arg2,(char const **)arg3,arg4); ++ result = (int)semanage_user_set_name(arg1,arg2,(char const *)arg3); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -3453,101 +4225,90 @@ + } + + +-static PyObject *_wrap_semanage_user_create(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_get_mlslevel(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 ; ++ semanage_user_t *arg1 = (semanage_user_t *) 0 ; ++ char *result; + 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(!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 = (int)semanage_user_create(arg1,arg2); ++ result = (char *)semanage_user_get_mlslevel(arg1); + +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_semanage_user, 0)); +- } ++ resultobj = SWIG_FromCharPtr(result); + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_user_clone(PyObject *self, PyObject *args) { ++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 ; +- semanage_user_t **arg3 = (semanage_user_t **) 0 ; ++ char *arg3 = (char *) 0 ; + int result; +- semanage_user_t *temp3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; + +- { +- arg3 = &temp3; +- } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_user_clone",&obj0,&obj1)) goto fail; ++ 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; +- result = (int)semanage_user_clone(arg1,arg2,arg3); ++ 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)); + } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_user, 0)); +- } + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_user_free(PyObject *self, PyObject *args) { ++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_free",&obj0)) goto fail; ++ 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; +- semanage_user_free(arg1); ++ result = (char *)semanage_user_get_mlsrange(arg1); + +- Py_INCREF(Py_None); resultobj = Py_None; ++ resultobj = SWIG_FromCharPtr(result); + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_bool_query(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_set_mlsrange(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 ; ++ 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_bool_query",&obj0,&obj1,&obj2)) goto fail; ++ 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_bool_key, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); + if (SWIG_arg_fail(2)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_p_semanage_bool, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_bool_query(arg1,arg2,arg3); ++ 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)); +@@ -3558,50 +4319,45 @@ + } + + +-static PyObject *_wrap_semanage_bool_exists(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_get_num_roles(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 ; ++ semanage_user_t *arg1 = (semanage_user_t *) 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(!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; +- 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,arg2,arg3); ++ result = (int)semanage_user_get_num_roles(arg1); + + { + 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; + } + + +-static PyObject *_wrap_semanage_bool_count(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_add_role(PyObject *self, PyObject *args) { + PyObject *resultobj; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- unsigned int *arg2 = (unsigned int *) 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 *)"OO:semanage_bool_count",&obj0,&obj1)) goto fail; ++ 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_unsigned_int, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); + if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_bool_count(arg1,arg2); ++ 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)); +@@ -3612,110 +4368,115 @@ + } + + +-static PyObject *_wrap_semanage_bool_iterate(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_del_role(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int (*arg2)(semanage_bool_t *,void *) = (int (*)(semanage_bool_t *,void *)) 0 ; +- void *arg3 = (void *) 0 ; +- int result; ++ semanage_user_t *arg1 = (semanage_user_t *) 0 ; ++ char *arg2 = (char *) 0 ; + 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(!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; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_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; +- } ++ if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { ++ SWIG_arg_fail(2);SWIG_fail; + } +- result = (int)semanage_bool_iterate(arg1,arg2,arg3); ++ semanage_user_del_role(arg1,(char const *)arg2); + +- { +- resultobj = SWIG_From_int((int)(result)); +- } ++ Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_bool_list(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_has_role(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_bool_t ***arg2 = (semanage_bool_t ***) 0 ; +- size_t *arg3 = (size_t *) 0 ; ++ semanage_user_t *arg1 = (semanage_user_t *) 0 ; ++ char *arg2 = (char *) 0 ; + int result; +- size_t temp3 ; +- int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_bool_list",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 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; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_p_p_semanage_bool, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_bool_list(arg1,arg2,arg3); ++ if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { ++ SWIG_arg_fail(2);SWIG_fail; ++ } ++ result = (int)semanage_user_has_role(arg1,(char const *)arg2); + + { + resultobj = SWIG_From_int((int)(result)); + } +- resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_size_t, 0))); + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_iface_compare(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_get_roles(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; +- semanage_iface_key_t *arg2 = (semanage_iface_key_t *) 0 ; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ semanage_user_t *arg2 = (semanage_user_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 ; + +- 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); ++ { ++ 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_iface_key, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); + if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_iface_compare(arg1,arg2); ++ result = (int)semanage_user_get_roles(arg1,arg2,(char const ***)arg3,arg4); + + { + resultobj = SWIG_From_int((int)(result)); + } ++ { ++ resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_p_char, 0)); ++ } ++ 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; + } + + +-static PyObject *_wrap_semanage_iface_key_create(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_set_roles(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 ; ++ semanage_user_t *arg2 = (semanage_user_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 *)"OOO:semanage_iface_key_create",&obj0,&obj1,&obj2)) goto fail; ++ if(!PyArg_ParseTuple(args,(char *)"OOOO:semanage_user_set_roles",&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; +- } +- SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_p_semanage_iface_key, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user, SWIG_POINTER_EXCEPTION | 0); ++ if (SWIG_arg_fail(2)) SWIG_fail; ++ SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_p_char, SWIG_POINTER_EXCEPTION | 0); + if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_iface_key_create(arg1,(char const *)arg2,arg3); ++ { ++ arg4 = (size_t)(SWIG_As_unsigned_SS_long(obj3)); ++ 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)); +@@ -3726,88 +4487,101 @@ + } + + +-static PyObject *_wrap_semanage_iface_key_extract(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_create(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 ; ++ semanage_user_t **arg2 = (semanage_user_t **) 0 ; + int result; ++ semanage_user_t *temp2 ; + PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_key_extract",&obj0,&obj1,&obj2)) goto fail; ++ { ++ 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; +- 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_p_semanage_iface_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_iface_key_extract(arg1,arg2,arg3); ++ 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; + } + + +-static PyObject *_wrap_semanage_iface_key_free(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_clone(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_iface_key_t *arg1 = (semanage_iface_key_t *) 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; ++ semanage_user_t *temp3 ; + PyObject * obj0 = 0 ; ++ PyObject * obj1 = 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); ++ { ++ 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; +- semanage_iface_key_free(arg1); ++ 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,arg2,arg3); + +- Py_INCREF(Py_None); resultobj = Py_None; ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } ++ { ++ resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_user, 0)); ++ } + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_iface_get_name(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_free(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; +- char *result; ++ semanage_user_t *arg1 = (semanage_user_t *) 0 ; + 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(!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; +- result = (char *)semanage_iface_get_name(arg1); ++ semanage_user_free(arg1); + +- resultobj = SWIG_FromCharPtr(result); ++ Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_iface_set_name(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_add_local(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 ; ++ 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_iface_set_name",&obj0,&obj1,&obj2)) goto fail; ++ if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_add_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, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user_key, 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); ++ 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_add_local(arg1,arg2,arg3); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -3818,126 +4592,162 @@ + } + + +-static PyObject *_wrap_semanage_iface_get_ifcon(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_modify_local(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; +- semanage_context_t *result; ++ 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 *)"O:semanage_iface_get_ifcon",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_iface, SWIG_POINTER_EXCEPTION | 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; +- result = (semanage_context_t *)semanage_iface_get_ifcon(arg1); ++ 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,arg2,arg3); + +- resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_semanage_context, 0); ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_iface_set_ifcon(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_set_local(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; +- semanage_context_t *arg2 = (semanage_context_t *) 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; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_set_ifcon",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); ++ if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_set_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_context, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user_key, SWIG_POINTER_EXCEPTION | 0); + if (SWIG_arg_fail(2)) SWIG_fail; +- semanage_iface_set_ifcon(arg1,arg2); ++ 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_set_local(arg1,arg2,arg3); + +- Py_INCREF(Py_None); resultobj = Py_None; ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_iface_get_msgcon(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_del_local(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; +- semanage_context_t *result; ++ 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 *)"O:semanage_iface_get_msgcon",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_iface, SWIG_POINTER_EXCEPTION | 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; +- result = (semanage_context_t *)semanage_iface_get_msgcon(arg1); ++ 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,arg2); + +- resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_semanage_context, 0); ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_iface_set_msgcon(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_query_local(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; +- semanage_context_t *arg2 = (semanage_context_t *) 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; ++ semanage_user_t *temp3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_set_msgcon",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_iface, SWIG_POINTER_EXCEPTION | 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_context, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_user_key, SWIG_POINTER_EXCEPTION | 0); + if (SWIG_arg_fail(2)) SWIG_fail; +- semanage_iface_set_msgcon(arg1,arg2); ++ result = (int)semanage_user_query_local(arg1,arg2,arg3); + +- Py_INCREF(Py_None); resultobj = Py_None; ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } ++ { ++ resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_user, 0)); ++ } + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_iface_create(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_exists_local(PyObject *self, PyObject *args) { + PyObject *resultobj; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_iface_t **arg2 = (semanage_iface_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 ; + +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_create",&obj0,&obj1)) goto fail; ++ 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_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); ++ 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_iface_create(arg1,arg2); ++ result = (int)semanage_user_exists_local(arg1,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; + } + + +-static PyObject *_wrap_semanage_iface_clone(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_count_local(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 ; ++ unsigned int *arg2 = (unsigned int *) 0 ; + int result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_clone",&obj0,&obj1,&obj2)) goto fail; ++ if(!PyArg_ParseTuple(args,(char *)"OO:semanage_user_count_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, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_int, SWIG_POINTER_EXCEPTION | 0); + if (SWIG_arg_fail(2)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_iface_clone(arg1,arg2,arg3); ++ result = (int)semanage_user_count_local(arg1,arg2); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -3948,81 +4758,96 @@ + } + + +-static PyObject *_wrap_semanage_iface_free(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_iterate_local(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_iface_t *arg1 = (semanage_iface_t *) 0 ; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ int (*arg2)(semanage_user_t *,void *) = (int (*)(semanage_user_t *,void *)) 0 ; ++ void *arg3 = (void *) 0 ; ++ int result; + PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 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(!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; +- semanage_iface_free(arg1); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_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); + +- Py_INCREF(Py_None); resultobj = Py_None; ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_key_create(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_list_local(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 ; ++ semanage_user_t ***arg2 = (semanage_user_t ***) 0 ; ++ size_t *arg3 = (size_t *) 0 ; + int result; +- semanage_seuser_key_t *temp3 ; ++ semanage_user_t **temp2 ; ++ size_t temp3 ; ++ int res3 = 0 ; + PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; + + { +- arg3 = &temp3; ++ arg2 = &temp2; + } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_key_create",&obj0,&obj1)) goto fail; ++ 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; +- if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { +- SWIG_arg_fail(2);SWIG_fail; +- } +- result = (int)semanage_seuser_key_create(arg1,(char const *)arg2,arg3); ++ result = (int)semanage_user_list_local(arg1,arg2,arg3); + + { + resultobj = SWIG_From_int((int)(result)); + } + { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_seuser_key, 0)); ++ resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_p_semanage_user, 0)); + } ++ resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? ++ SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_size_t, 0))); + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_key_extract(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_query(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 ; ++ semanage_user_key_t *arg2 = (semanage_user_key_t *) 0 ; ++ semanage_user_t **arg3 = (semanage_user_t **) 0 ; + int result; +- semanage_seuser_key_t *temp3 ; ++ semanage_user_t *temp3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + { + arg3 = &temp3; + } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_key_extract",&obj0,&obj1)) goto fail; ++ 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_seuser, SWIG_POINTER_EXCEPTION | 0); ++ 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_seuser_key_extract(arg1,arg2,arg3); ++ result = (int)semanage_user_query(arg1,arg2,arg3); + + { + resultobj = SWIG_From_int((int)(result)); + } + { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_seuser_key, 0)); ++ resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_user, 0)); + } + return resultobj; + fail: +@@ -4030,84 +4855,50 @@ + } + + +-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; +-} +- +- +-static PyObject *_wrap_semanage_seuser_compare(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_exists(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_seuser_t *arg1 = (semanage_seuser_t *) 0 ; +- semanage_seuser_key_t *arg2 = (semanage_seuser_key_t *) 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; ++ int temp3 ; ++ int res3 = 0 ; + 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); ++ 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_seuser_key, SWIG_POINTER_EXCEPTION | 0); ++ 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_seuser_compare(arg1,arg2); ++ result = (int)semanage_user_exists(arg1,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; + } + + +-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(arg1); +- +- resultobj = SWIG_FromCharPtr(result); +- return resultobj; +- fail: +- return NULL; +-} +- +- +-static PyObject *_wrap_semanage_seuser_set_name(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_count(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 ; ++ unsigned int *arg2 = (unsigned int *) 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; ++ if(!PyArg_ParseTuple(args,(char *)"OO:semanage_user_count",&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); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_int, 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); ++ result = (int)semanage_user_count(arg1,arg2); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -4118,43 +4909,27 @@ + } + + +-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(arg1); +- +- resultobj = SWIG_FromCharPtr(result); +- return resultobj; +- fail: +- return NULL; +-} +- +- +-static PyObject *_wrap_semanage_seuser_set_sename(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_iterate(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 (*arg2)(semanage_user_t *,void *) = (int (*)(semanage_user_t *,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_set_sename",&obj0,&obj1,&obj2)) goto fail; ++ 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_semanage_seuser, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_struct_semanage_user_p_void__int, SWIG_POINTER_EXCEPTION | 0); + if (SWIG_arg_fail(2)) SWIG_fail; +- if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) { +- SWIG_arg_fail(3);SWIG_fail; ++ { ++ if ((SWIG_ConvertPtr(obj2,(void **)(&arg3),0,SWIG_POINTER_EXCEPTION|0))== -1) { ++ SWIG_arg_fail(3);SWIG_fail; ++ } + } +- result = (int)semanage_seuser_set_sename(arg1,arg2,(char const *)arg3); ++ result = (int)semanage_user_iterate(arg1,arg2,arg3); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -4165,43 +4940,54 @@ + } + + +-static PyObject *_wrap_semanage_seuser_get_mlsrange(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_user_list(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_seuser_t *arg1 = (semanage_seuser_t *) 0 ; +- char *result; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ semanage_user_t ***arg2 = (semanage_user_t ***) 0 ; ++ size_t *arg3 = (size_t *) 0 ; ++ int result; ++ semanage_user_t **temp2 ; ++ size_t temp3 ; ++ int res3 = 0 ; + 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); ++ { ++ 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 = (char *)semanage_seuser_get_mlsrange(arg1); ++ result = (int)semanage_user_list(arg1,arg2,arg3); + +- resultobj = SWIG_FromCharPtr(result); ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } ++ { ++ resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_p_semanage_user, 0)); ++ } ++ resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? ++ SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_size_t, 0))); + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_set_mlsrange(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_compare(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 ; ++ 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 ; +- 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(!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_seuser, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_port_key, 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); ++ result = (int)semanage_port_compare(arg1,arg2); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -4212,27 +4998,45 @@ + } + + +-static PyObject *_wrap_semanage_seuser_create(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_key_create(PyObject *self, PyObject *args) { + PyObject *resultobj; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_seuser_t **arg2 = (semanage_seuser_t **) 0 ; ++ int arg2 ; ++ int arg3 ; ++ int arg4 ; ++ semanage_port_key_t **arg5 = (semanage_port_key_t **) 0 ; + int result; +- semanage_seuser_t *temp2 ; ++ semanage_port_key_t *temp5 ; + PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; ++ PyObject * obj3 = 0 ; + + { +- arg2 = &temp2; ++ arg5 = &temp5; + } +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_create",&obj0)) goto fail; ++ 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; +- result = (int)semanage_seuser_create(arg1,arg2); ++ { ++ 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(*arg2, SWIGTYPE_p_semanage_seuser, 0)); ++ resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg5, SWIGTYPE_p_semanage_port_key, 0)); + } + return resultobj; + fail: +@@ -4240,31 +5044,31 @@ + } + + +-static PyObject *_wrap_semanage_seuser_clone(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_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_t **arg3 = (semanage_seuser_t **) 0 ; ++ semanage_port_t *arg2 = (semanage_port_t *) 0 ; ++ semanage_port_key_t **arg3 = (semanage_port_key_t **) 0 ; + int result; +- semanage_seuser_t *temp3 ; ++ semanage_port_key_t *temp3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + { + arg3 = &temp3; + } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_clone",&obj0,&obj1)) goto fail; ++ 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_seuser, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_port, SWIG_POINTER_EXCEPTION | 0); + if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_seuser_clone(arg1,arg2,arg3); ++ result = (int)semanage_port_key_extract(arg1,arg2,arg3); + + { + resultobj = SWIG_From_int((int)(result)); + } + { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_seuser, 0)); ++ resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_port_key, 0)); + } + return resultobj; + fail: +@@ -4272,15 +5076,15 @@ + } + + +-static PyObject *_wrap_semanage_seuser_free(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_key_free(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_seuser_t *arg1 = (semanage_seuser_t *) 0 ; ++ semanage_port_key_t *arg1 = (semanage_port_key_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(!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_seuser_free(arg1); ++ semanage_port_key_free(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; +@@ -4289,24 +5093,16 @@ + } + + +-static PyObject *_wrap_semanage_user_add_local(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_get_proto(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 ; ++ semanage_port_t *arg1 = (semanage_port_t *) 0 ; + int result; + PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_add_local",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 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; +- 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_add_local(arg1,arg2,arg3); ++ result = (int)semanage_port_get_proto(arg1); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -4317,52 +5113,57 @@ + } + + +-static PyObject *_wrap_semanage_user_modify_local(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_set_proto(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_port_t *arg1 = (semanage_port_t *) 0 ; ++ int arg2 ; + 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(!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; +- 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,arg2,arg3); +- + { +- resultobj = SWIG_From_int((int)(result)); ++ 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; + } + + +-static PyObject *_wrap_semanage_user_set_local(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_get_proto_str(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 ; ++ semanage_port_t *arg1 = (semanage_port_t *) 0 ; ++ char *result; ++ PyObject * obj0 = 0 ; ++ ++ if(!PyArg_ParseTuple(args,(char *)"O:semanage_port_get_proto_str",&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 = (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 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_user_set_local",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 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; +- 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_set_local(arg1,arg2,arg3); ++ result = (int)semanage_port_get_low(arg1); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -4373,20 +5174,16 @@ + } + + +-static PyObject *_wrap_semanage_user_del_local(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_get_high(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_port_t *arg1 = (semanage_port_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(!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; +- 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,arg2); ++ result = (int)semanage_port_get_high(arg1); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -4397,241 +5194,220 @@ + } + + +-static PyObject *_wrap_semanage_user_query_local(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_set_port(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 ; ++ 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; + { +- arg3 = &temp3; ++ arg2 = (int)(SWIG_As_int(obj1)); ++ if (SWIG_arg_fail(2)) SWIG_fail; + } +- 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,arg2,arg3); ++ semanage_port_set_port(arg1,arg2); ++ ++ Py_INCREF(Py_None); resultobj = Py_None; ++ 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; + { +- resultobj = SWIG_From_int((int)(result)); ++ arg2 = (int)(SWIG_As_int(obj1)); ++ if (SWIG_arg_fail(2)) SWIG_fail; + } + { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_user, 0)); ++ 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; + } + + +-static PyObject *_wrap_semanage_user_exists_local(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_get_con(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 ; ++ semanage_port_t *arg1 = (semanage_port_t *) 0 ; ++ semanage_context_t *result; + 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(!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; +- 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,arg2,arg3); ++ result = (semanage_context_t *)semanage_port_get_con(arg1); + +- { +- 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))); ++ resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_semanage_context, 0); + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_user_count_local(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_set_con(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- unsigned int *arg2 = (unsigned int *) 0 ; +- int result; ++ semanage_port_t *arg1 = (semanage_port_t *) 0 ; ++ semanage_context_t *arg2 = (semanage_context_t *) 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_user_count_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 0); ++ if(!PyArg_ParseTuple(args,(char *)"OO:semanage_port_set_con",&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_unsigned_int, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); + if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_user_count_local(arg1,arg2); ++ semanage_port_set_con(arg1,arg2); + +- { +- resultobj = SWIG_From_int((int)(result)); +- } ++ Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_user_iterate_local(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_create(PyObject *self, PyObject *args) { + PyObject *resultobj; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int (*arg2)(semanage_user_t *,void *) = (int (*)(semanage_user_t *,void *)) 0 ; +- void *arg3 = (void *) 0 ; ++ semanage_port_t **arg2 = (semanage_port_t **) 0 ; + int result; ++ semanage_port_t *temp2 ; + 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_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; +- } ++ arg2 = &temp2; + } +- result = (int)semanage_user_iterate_local(arg1,arg2,arg3); ++ 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; + } + + +-static PyObject *_wrap_semanage_user_list_local(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_clone(PyObject *self, PyObject *args) { + PyObject *resultobj; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_user_t ***arg2 = (semanage_user_t ***) 0 ; +- size_t *arg3 = (size_t *) 0 ; ++ semanage_port_t *arg2 = (semanage_port_t *) 0 ; ++ semanage_port_t **arg3 = (semanage_port_t **) 0 ; + int result; +- semanage_user_t **temp2 ; +- size_t temp3 ; +- int res3 = 0 ; ++ semanage_port_t *temp3 ; + PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; + + { +- arg2 = &temp2; ++ arg3 = &temp3; + } +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_user_list_local",&obj0)) goto fail; ++ 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; +- result = (int)semanage_user_list_local(arg1,arg2,arg3); ++ 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,arg2,arg3); + + { + resultobj = SWIG_From_int((int)(result)); + } + { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_p_semanage_user, 0)); ++ resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_port, 0)); + } +- resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_size_t, 0))); + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_context_get_user(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_free(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_context_t *arg1 = (semanage_context_t *) 0 ; +- char *result; ++ semanage_port_t *arg1 = (semanage_port_t *) 0 ; + 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(!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; +- result = (char *)semanage_context_get_user(arg1); ++ semanage_port_free(arg1); + +- resultobj = SWIG_FromCharPtr(result); ++ Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_context_set_user(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_add_local(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 ; ++ 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_context_set_user",&obj0,&obj1,&obj2)) goto fail; ++ if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_port_add_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_context, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_port_key, 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; +-} +- +- +-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(arg1); ++ 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_add_local(arg1,arg2,arg3); + +- resultobj = SWIG_FromCharPtr(result); ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_context_set_role(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_modify_local(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 ; ++ 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_context_set_role",&obj0,&obj1,&obj2)) goto fail; ++ 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_context, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_port_key, 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); ++ 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,arg2,arg3); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -4642,43 +5418,48 @@ + } + + +-static PyObject *_wrap_semanage_context_get_type(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_set_local(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_context_t *arg1 = (semanage_context_t *) 0 ; +- char *result; ++ 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 *)"O:semanage_context_get_type",&obj0)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); ++ if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_port_set_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; +- result = (char *)semanage_context_get_type(arg1); ++ 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_set_local(arg1,arg2,arg3); + +- resultobj = SWIG_FromCharPtr(result); ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_context_set_type(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_del_local(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 ; ++ semanage_port_key_t *arg2 = (semanage_port_key_t *) 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; ++ 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_context, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_port_key, 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); ++ result = (int)semanage_port_del_local(arg1,arg2); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -4689,67 +5470,82 @@ + } + + +-static PyObject *_wrap_semanage_context_get_mls(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_query_local(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_context_t *arg1 = (semanage_context_t *) 0 ; +- char *result; ++ 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 ; + +- 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); ++ { ++ 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; +- result = (char *)semanage_context_get_mls(arg1); ++ 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,arg2,arg3); + +- resultobj = SWIG_FromCharPtr(result); ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } ++ { ++ resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_port, 0)); ++ } + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_context_set_mls(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_exists_local(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 ; ++ 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 ; +- PyObject * obj2 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_context_set_mls",&obj0,&obj1,&obj2)) goto fail; ++ 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_context, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_port_key, 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); ++ result = (int)semanage_port_exists_local(arg1,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; + } + + +-static PyObject *_wrap_semanage_context_create(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_count_local(PyObject *self, PyObject *args) { + PyObject *resultobj; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_context_t **arg2 = (semanage_context_t **) 0 ; ++ unsigned int *arg2 = (unsigned int *) 0 ; + int result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_context_create",&obj0,&obj1)) goto fail; ++ if(!PyArg_ParseTuple(args,(char *)"OO:semanage_port_count_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_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_int, SWIG_POINTER_EXCEPTION | 0); + if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_context_create(arg1,arg2); ++ result = (int)semanage_port_count_local(arg1,arg2); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -4760,24 +5556,27 @@ + } + + +-static PyObject *_wrap_semanage_context_clone(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_iterate_local(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 (*arg2)(semanage_port_t *,void *) = (int (*)(semanage_port_t *,void *)) 0 ; ++ void *arg3 = (void *) 0 ; + int result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_context_clone",&obj0,&obj1,&obj2)) goto fail; ++ 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_semanage_context, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_struct_semanage_port_p_void__int, SWIG_POINTER_EXCEPTION | 0); + if (SWIG_arg_fail(2)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_context_clone(arg1,arg2,arg3); ++ { ++ 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)); +@@ -4788,98 +5587,116 @@ + } + + +-static PyObject *_wrap_semanage_context_free(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_list_local(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_context_t *arg1 = (semanage_context_t *) 0 ; ++ semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; ++ semanage_port_t ***arg2 = (semanage_port_t ***) 0 ; ++ size_t *arg3 = (size_t *) 0 ; ++ int result; ++ semanage_port_t **temp2 ; ++ size_t temp3 ; ++ int res3 = 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); ++ { ++ 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; +- semanage_context_free(arg1); ++ result = (int)semanage_port_list_local(arg1,arg2,arg3); + +- Py_INCREF(Py_None); resultobj = Py_None; ++ { ++ resultobj = SWIG_From_int((int)(result)); ++ } ++ { ++ resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_p_semanage_port, 0)); ++ } ++ resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? ++ SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_size_t, 0))); + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_context_from_string(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_query(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 ; ++ 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 ; +- PyObject * obj2 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_context_from_string",&obj0,&obj1,&obj2)) goto fail; ++ { ++ 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; +- if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) { +- SWIG_arg_fail(2);SWIG_fail; +- } +- SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_p_semanage_context, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_context_from_string(arg1,(char const *)arg2,arg3); ++ 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,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; + } + + +-static PyObject *_wrap_semanage_context_to_string(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_exists(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 ; ++ 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 ; +- PyObject * obj2 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_context_to_string",&obj0,&obj1,&obj2)) goto fail; ++ 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_context, SWIG_POINTER_EXCEPTION | 0); ++ 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_p_char, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_context_to_string(arg1,arg2,arg3); ++ result = (int)semanage_port_exists(arg1,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; + } + + +-static PyObject *_wrap_semanage_iface_add_local(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_count(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 ; ++ unsigned int *arg2 = (unsigned int *) 0 ; + int result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_add_local",&obj0,&obj1,&obj2)) goto fail; ++ if(!PyArg_ParseTuple(args,(char *)"OO:semanage_port_count",&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); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_int, 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_add_local(arg1,arg2,arg3); ++ result = (int)semanage_port_count(arg1,arg2); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -4890,24 +5707,27 @@ + } + + +-static PyObject *_wrap_semanage_iface_modify_local(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_iterate(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 (*arg2)(semanage_port_t *,void *) = (int (*)(semanage_port_t *,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_modify_local",&obj0,&obj1,&obj2)) goto fail; ++ 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_semanage_iface_key, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_struct_semanage_port_p_void__int, 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,arg2,arg3); ++ { ++ 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)); +@@ -4918,161 +5738,183 @@ + } + + +-static PyObject *_wrap_semanage_iface_set_local(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_port_list(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 ; ++ semanage_port_t ***arg2 = (semanage_port_t ***) 0 ; ++ size_t *arg3 = (size_t *) 0 ; + int result; ++ semanage_port_t **temp2 ; ++ size_t temp3 ; ++ int res3 = 0 ; + PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_set_local",&obj0,&obj1,&obj2)) goto fail; ++ { ++ 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; +- 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_set_local(arg1,arg2,arg3); ++ result = (int)semanage_port_list(arg1,arg2,arg3); + + { + resultobj = SWIG_From_int((int)(result)); + } ++ { ++ resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_p_semanage_port, 0)); ++ } ++ resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? ++ SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_size_t, 0))); + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_iface_del_local(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_seuser_key_create(PyObject *self, PyObject *args) { + PyObject *resultobj; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_iface_key_t *arg2 = (semanage_iface_key_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 ; + +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_del_local",&obj0,&obj1)) goto fail; ++ { ++ 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; +- 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,arg2); ++ 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; + } + + +-static PyObject *_wrap_semanage_iface_query_local(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_seuser_key_extract(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 ; ++ 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 ; +- PyObject * obj2 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_iface_query_local",&obj0,&obj1,&obj2)) goto fail; ++ { ++ 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_iface_key, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(3)) SWIG_fail; +- result = (int)semanage_iface_query_local(arg1,arg2,arg3); ++ 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,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; ++} ++ ++ ++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); + +- { +- resultobj = SWIG_From_int((int)(result)); +- } ++ Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_iface_exists_local(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_seuser_compare(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 ; ++ semanage_seuser_t *arg1 = (semanage_seuser_t *) 0 ; ++ semanage_seuser_key_t *arg2 = (semanage_seuser_key_t *) 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(!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_iface_key, SWIG_POINTER_EXCEPTION | 0); ++ 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_iface_exists_local(arg1,arg2,arg3); ++ result = (int)semanage_seuser_compare(arg1,arg2); + + { + 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; + } + + +-static PyObject *_wrap_semanage_iface_count_local(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_seuser_get_name(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- unsigned int *arg2 = (unsigned int *) 0 ; +- int result; ++ semanage_seuser_t *arg1 = (semanage_seuser_t *) 0 ; ++ char *result; + PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_count_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 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; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_int, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_iface_count_local(arg1,arg2); ++ result = (char *)semanage_seuser_get_name(arg1); + +- { +- resultobj = SWIG_From_int((int)(result)); +- } ++ resultobj = SWIG_FromCharPtr(result); + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_iface_iterate_local(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_seuser_set_name(PyObject *self, PyObject *args) { + PyObject *resultobj; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int (*arg2)(semanage_iface_t *,void *) = (int (*)(semanage_iface_t *,void *)) 0 ; +- void *arg3 = (void *) 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_iface_iterate_local",&obj0,&obj1,&obj2)) goto fail; ++ 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_f_p_struct_semanage_iface_p_void__int, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_seuser, 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; +- } ++ if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) { ++ SWIG_arg_fail(3);SWIG_fail; + } +- result = (int)semanage_iface_iterate_local(arg1,arg2,arg3); ++ result = (int)semanage_seuser_set_name(arg1,arg2,(char const *)arg3); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -5083,54 +5925,43 @@ + } + + +-static PyObject *_wrap_semanage_iface_list_local(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_seuser_get_sename(PyObject *self, PyObject *args) { + PyObject *resultobj; +- semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_iface_t ***arg2 = (semanage_iface_t ***) 0 ; +- size_t *arg3 = (size_t *) 0 ; +- int result; +- size_t temp3 ; +- int res3 = 0 ; ++ semanage_seuser_t *arg1 = (semanage_seuser_t *) 0 ; ++ char *result; + PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; + +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_iface_list_local",&obj0,&obj1)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 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; +- SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_p_p_semanage_iface, SWIG_POINTER_EXCEPTION | 0); +- if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_iface_list_local(arg1,arg2,arg3); ++ result = (char *)semanage_seuser_get_sename(arg1); + +- { +- resultobj = SWIG_From_int((int)(result)); +- } +- resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_size_t, 0))); ++ resultobj = SWIG_FromCharPtr(result); + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_add(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_seuser_set_sename(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 ; ++ 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_add",&obj0,&obj1,&obj2)) goto fail; ++ 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_key, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_seuser, 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_add(arg1,arg2,arg3); ++ 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)); +@@ -5141,52 +5972,43 @@ + } + + +-static PyObject *_wrap_semanage_seuser_modify(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_seuser_get_mlsrange(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 *arg1 = (semanage_seuser_t *) 0 ; ++ char *result; + PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; +- PyObject * obj2 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_seuser_modify",&obj0,&obj1,&obj2)) goto fail; +- SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_semanage_handle, SWIG_POINTER_EXCEPTION | 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; +- 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(arg1,arg2,arg3); ++ result = (char *)semanage_seuser_get_mlsrange(arg1); + +- { +- resultobj = SWIG_From_int((int)(result)); +- } ++ resultobj = SWIG_FromCharPtr(result); + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_seuser_set(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_seuser_set_mlsrange(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 ; ++ 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",&obj0,&obj1,&obj2)) goto fail; ++ 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_key, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_seuser, 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_set(arg1,arg2,arg3); ++ 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)); +@@ -5197,34 +6019,38 @@ + } + + +-static PyObject *_wrap_semanage_seuser_del(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_seuser_create(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 **arg2 = (semanage_seuser_t **) 0 ; + int result; ++ semanage_seuser_t *temp2 ; + PyObject * obj0 = 0 ; +- PyObject * obj1 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_del",&obj0,&obj1)) goto fail; ++ { ++ 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; +- 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(arg1,arg2); ++ 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; + } + + +-static PyObject *_wrap_semanage_seuser_query(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_seuser_clone(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 *arg2 = (semanage_seuser_t *) 0 ; + semanage_seuser_t **arg3 = (semanage_seuser_t **) 0 ; + int result; + semanage_seuser_t *temp3 ; +@@ -5234,12 +6060,12 @@ + { + arg3 = &temp3; + } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_query",&obj0,&obj1)) goto fail; ++ 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_key, SWIG_POINTER_EXCEPTION | 0); ++ 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_query(arg1,arg2,arg3); ++ result = (int)semanage_seuser_clone(arg1,arg2,arg3); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -5253,50 +6079,69 @@ + } + + +-static PyObject *_wrap_semanage_seuser_exists(PyObject *self, PyObject *args) { ++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; ++} ++ ++ ++static PyObject *_wrap_semanage_seuser_add(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 ; ++ semanage_seuser_t *arg3 = (semanage_seuser_t *) 0 ; + int result; +- int temp3 ; +- int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; ++ PyObject * obj2 = 0 ; + +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_exists",&obj0,&obj1)) goto fail; ++ if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_seuser_add",&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; +- result = (int)semanage_seuser_exists(arg1,arg2,arg3); ++ 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_add(arg1,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; + } + + +-static PyObject *_wrap_semanage_seuser_count(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_seuser_modify(PyObject *self, PyObject *args) { + PyObject *resultobj; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- unsigned int *arg2 = (unsigned int *) 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 *)"OO:semanage_seuser_count",&obj0,&obj1)) goto fail; ++ if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_seuser_modify",&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_unsigned_int, SWIG_POINTER_EXCEPTION | 0); ++ 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_count(arg1,arg2); ++ 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(arg1,arg2,arg3); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -5307,27 +6152,24 @@ + } + + +-static PyObject *_wrap_semanage_seuser_iterate(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_seuser_set(PyObject *self, PyObject *args) { + PyObject *resultobj; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int (*arg2)(semanage_seuser_t *,void *) = (int (*)(semanage_seuser_t *,void *)) 0 ; +- void *arg3 = (void *) 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_iterate",&obj0,&obj1,&obj2)) goto fail; ++ if(!PyArg_ParseTuple(args,(char *)"OOO:semanage_seuser_set",&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_struct_semanage_seuser_p_void__int, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_semanage_seuser_key, 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); ++ 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_set(arg1,arg2,arg3); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -5338,65 +6180,55 @@ + } + + +-static PyObject *_wrap_semanage_seuser_list(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_seuser_del(PyObject *self, PyObject *args) { + PyObject *resultobj; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_seuser_t ***arg2 = (semanage_seuser_t ***) 0 ; +- size_t *arg3 = (size_t *) 0 ; ++ semanage_seuser_key_t *arg2 = (semanage_seuser_key_t *) 0 ; + int result; +- semanage_seuser_t **temp2 ; +- size_t temp3 ; +- int res3 = 0 ; + PyObject * obj0 = 0 ; ++ PyObject * obj1 = 0 ; + +- { +- arg2 = &temp2; +- } +- arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_seuser_list",&obj0)) goto fail; ++ if(!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_del",&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; +- result = (int)semanage_seuser_list(arg1,arg2,arg3); ++ 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(arg1,arg2); + + { + resultobj = SWIG_From_int((int)(result)); + } +- { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_p_semanage_seuser, 0)); +- } +- resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? +- SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_size_t, 0))); + return resultobj; + fail: + return NULL; + } + + +-static PyObject *_wrap_semanage_user_query(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_seuser_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 ; ++ semanage_seuser_key_t *arg2 = (semanage_seuser_key_t *) 0 ; ++ semanage_seuser_t **arg3 = (semanage_seuser_t **) 0 ; + int result; +- semanage_user_t *temp3 ; ++ semanage_seuser_t *temp3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + { + arg3 = &temp3; + } +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_user_query",&obj0,&obj1)) goto fail; ++ 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_user_key, SWIG_POINTER_EXCEPTION | 0); ++ 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_user_query(arg1,arg2,arg3); ++ result = (int)semanage_seuser_query(arg1,arg2,arg3); + + { + resultobj = SWIG_From_int((int)(result)); + } + { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_user, 0)); ++ resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_semanage_seuser, 0)); + } + return resultobj; + fail: +@@ -5404,10 +6236,10 @@ + } + + +-static PyObject *_wrap_semanage_user_exists(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_seuser_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 ; ++ semanage_seuser_key_t *arg2 = (semanage_seuser_key_t *) 0 ; + int *arg3 = (int *) 0 ; + int result; + int temp3 ; +@@ -5416,12 +6248,12 @@ + PyObject * obj1 = 0 ; + + arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_user_exists",&obj0,&obj1)) goto fail; ++ 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_user_key, SWIG_POINTER_EXCEPTION | 0); ++ 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_user_exists(arg1,arg2,arg3); ++ result = (int)semanage_seuser_exists(arg1,arg2,arg3); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -5434,7 +6266,7 @@ + } + + +-static PyObject *_wrap_semanage_user_count(PyObject *self, PyObject *args) { ++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 ; +@@ -5442,12 +6274,12 @@ + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + +- if(!PyArg_ParseTuple(args,(char *)"OO:semanage_user_count",&obj0,&obj1)) goto fail; ++ if(!PyArg_ParseTuple(args,(char *)"OO:semanage_seuser_count",&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_unsigned_int, SWIG_POINTER_EXCEPTION | 0); + if (SWIG_arg_fail(2)) SWIG_fail; +- result = (int)semanage_user_count(arg1,arg2); ++ result = (int)semanage_seuser_count(arg1,arg2); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -5458,27 +6290,27 @@ + } + + +-static PyObject *_wrap_semanage_user_iterate(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_seuser_iterate(PyObject *self, PyObject *args) { + PyObject *resultobj; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- int (*arg2)(semanage_user_t *,void *) = (int (*)(semanage_user_t *,void *)) 0 ; ++ int (*arg2)(semanage_seuser_t *,void *) = (int (*)(semanage_seuser_t *,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; ++ 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_struct_semanage_user_p_void__int, SWIG_POINTER_EXCEPTION | 0); ++ SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_f_p_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_user_iterate(arg1,arg2,arg3); ++ result = (int)semanage_seuser_iterate(arg1,arg2,arg3); + + { + resultobj = SWIG_From_int((int)(result)); +@@ -5489,13 +6321,13 @@ + } + + +-static PyObject *_wrap_semanage_user_list(PyObject *self, PyObject *args) { ++static PyObject *_wrap_semanage_seuser_list(PyObject *self, PyObject *args) { + PyObject *resultobj; + semanage_handle_t *arg1 = (semanage_handle_t *) 0 ; +- semanage_user_t ***arg2 = (semanage_user_t ***) 0 ; ++ semanage_seuser_t ***arg2 = (semanage_seuser_t ***) 0 ; + size_t *arg3 = (size_t *) 0 ; + int result; +- semanage_user_t **temp2 ; ++ semanage_seuser_t **temp2 ; + size_t temp3 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; +@@ -5504,16 +6336,16 @@ + arg2 = &temp2; + } + arg3 = &temp3; res3 = SWIG_NEWOBJ; +- if(!PyArg_ParseTuple(args,(char *)"O:semanage_user_list",&obj0)) goto fail; ++ 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_user_list(arg1,arg2,arg3); ++ result = (int)semanage_seuser_list(arg1,arg2,arg3); + + { + resultobj = SWIG_From_int((int)(result)); + } + { +- resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_p_semanage_user, 0)); ++ resultobj = t_output_helper(resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_p_semanage_seuser, 0)); + } + resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ? + SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_size_t, 0))); +@@ -5528,35 +6360,10 @@ + { (char *)"semanage_seuser_by_idx", _wrap_semanage_seuser_by_idx, METH_VARARGS, NULL}, + { (char *)"semanage_port_by_idx", _wrap_semanage_port_by_idx, METH_VARARGS, NULL}, + { (char *)"char_by_idx", _wrap_char_by_idx, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_key_create", _wrap_semanage_bool_key_create, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_key_extract", _wrap_semanage_bool_key_extract, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_key_free", _wrap_semanage_bool_key_free, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_compare", _wrap_semanage_bool_compare, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_get_name", _wrap_semanage_bool_get_name, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_set_name", _wrap_semanage_bool_set_name, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_get_value", _wrap_semanage_bool_get_value, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_set_value", _wrap_semanage_bool_set_value, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_create", _wrap_semanage_bool_create, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_clone", _wrap_semanage_bool_clone, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_free", _wrap_semanage_bool_free, METH_VARARGS, NULL}, + { (char *)"semanage_msg_get_level", _wrap_semanage_msg_get_level, METH_VARARGS, NULL}, + { (char *)"semanage_msg_get_channel", _wrap_semanage_msg_get_channel, METH_VARARGS, NULL}, + { (char *)"semanage_msg_get_fname", _wrap_semanage_msg_get_fname, METH_VARARGS, NULL}, + { (char *)"semanage_msg_set_callback", _wrap_semanage_msg_set_callback, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_query", _wrap_semanage_iface_query, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_exists", _wrap_semanage_iface_exists, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_count", _wrap_semanage_iface_count, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_iterate", _wrap_semanage_iface_iterate, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_list", _wrap_semanage_iface_list, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_add_local", _wrap_semanage_bool_add_local, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_modify_local", _wrap_semanage_bool_modify_local, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_set_local", _wrap_semanage_bool_set_local, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_del_local", _wrap_semanage_bool_del_local, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_query_local", _wrap_semanage_bool_query_local, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_exists_local", _wrap_semanage_bool_exists_local, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_count_local", _wrap_semanage_bool_count_local, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_iterate_local", _wrap_semanage_bool_iterate_local, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_list_local", _wrap_semanage_bool_list_local, METH_VARARGS, NULL}, + { (char *)"semanage_handle_create", _wrap_semanage_handle_create, METH_VARARGS, NULL}, + { (char *)"semanage_handle_destroy", _wrap_semanage_handle_destroy, METH_VARARGS, NULL}, + { (char *)"semanage_select_store", _wrap_semanage_select_store, METH_VARARGS, NULL}, +@@ -5576,6 +6383,71 @@ + { (char *)"semanage_module_list_nth", _wrap_semanage_module_list_nth, METH_VARARGS, NULL}, + { (char *)"semanage_module_get_name", _wrap_semanage_module_get_name, METH_VARARGS, NULL}, + { (char *)"semanage_module_get_version", _wrap_semanage_module_get_version, METH_VARARGS, NULL}, ++ { (char *)"semanage_context_get_user", _wrap_semanage_context_get_user, METH_VARARGS, NULL}, ++ { (char *)"semanage_context_set_user", _wrap_semanage_context_set_user, METH_VARARGS, NULL}, ++ { (char *)"semanage_context_get_role", _wrap_semanage_context_get_role, METH_VARARGS, NULL}, ++ { (char *)"semanage_context_set_role", _wrap_semanage_context_set_role, METH_VARARGS, NULL}, ++ { (char *)"semanage_context_get_type", _wrap_semanage_context_get_type, METH_VARARGS, NULL}, ++ { (char *)"semanage_context_set_type", _wrap_semanage_context_set_type, METH_VARARGS, NULL}, ++ { (char *)"semanage_context_get_mls", _wrap_semanage_context_get_mls, METH_VARARGS, NULL}, ++ { (char *)"semanage_context_set_mls", _wrap_semanage_context_set_mls, METH_VARARGS, NULL}, ++ { (char *)"semanage_context_create", _wrap_semanage_context_create, METH_VARARGS, NULL}, ++ { (char *)"semanage_context_clone", _wrap_semanage_context_clone, METH_VARARGS, NULL}, ++ { (char *)"semanage_context_free", _wrap_semanage_context_free, METH_VARARGS, NULL}, ++ { (char *)"semanage_context_from_string", _wrap_semanage_context_from_string, METH_VARARGS, NULL}, ++ { (char *)"semanage_context_to_string", _wrap_semanage_context_to_string, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_key_create", _wrap_semanage_bool_key_create, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_key_extract", _wrap_semanage_bool_key_extract, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_key_free", _wrap_semanage_bool_key_free, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_compare", _wrap_semanage_bool_compare, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_get_name", _wrap_semanage_bool_get_name, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_set_name", _wrap_semanage_bool_set_name, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_get_value", _wrap_semanage_bool_get_value, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_set_value", _wrap_semanage_bool_set_value, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_create", _wrap_semanage_bool_create, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_clone", _wrap_semanage_bool_clone, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_free", _wrap_semanage_bool_free, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_query", _wrap_semanage_bool_query, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_exists", _wrap_semanage_bool_exists, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_count", _wrap_semanage_bool_count, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_iterate", _wrap_semanage_bool_iterate, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_list", _wrap_semanage_bool_list, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_add_local", _wrap_semanage_bool_add_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_modify_local", _wrap_semanage_bool_modify_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_set_local", _wrap_semanage_bool_set_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_del_local", _wrap_semanage_bool_del_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_query_local", _wrap_semanage_bool_query_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_exists_local", _wrap_semanage_bool_exists_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_count_local", _wrap_semanage_bool_count_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_iterate_local", _wrap_semanage_bool_iterate_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_bool_list_local", _wrap_semanage_bool_list_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_compare", _wrap_semanage_iface_compare, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_key_create", _wrap_semanage_iface_key_create, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_key_extract", _wrap_semanage_iface_key_extract, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_key_free", _wrap_semanage_iface_key_free, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_get_name", _wrap_semanage_iface_get_name, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_set_name", _wrap_semanage_iface_set_name, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_get_ifcon", _wrap_semanage_iface_get_ifcon, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_set_ifcon", _wrap_semanage_iface_set_ifcon, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_get_msgcon", _wrap_semanage_iface_get_msgcon, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_set_msgcon", _wrap_semanage_iface_set_msgcon, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_create", _wrap_semanage_iface_create, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_clone", _wrap_semanage_iface_clone, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_free", _wrap_semanage_iface_free, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_add_local", _wrap_semanage_iface_add_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_modify_local", _wrap_semanage_iface_modify_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_set_local", _wrap_semanage_iface_set_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_del_local", _wrap_semanage_iface_del_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_query_local", _wrap_semanage_iface_query_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_exists_local", _wrap_semanage_iface_exists_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_count_local", _wrap_semanage_iface_count_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_iterate_local", _wrap_semanage_iface_iterate_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_list_local", _wrap_semanage_iface_list_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_query", _wrap_semanage_iface_query, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_exists", _wrap_semanage_iface_exists, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_count", _wrap_semanage_iface_count, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_iterate", _wrap_semanage_iface_iterate, METH_VARARGS, NULL}, ++ { (char *)"semanage_iface_list", _wrap_semanage_iface_list, METH_VARARGS, NULL}, + { (char *)"semanage_user_key_create", _wrap_semanage_user_key_create, METH_VARARGS, NULL}, + { (char *)"semanage_user_key_extract", _wrap_semanage_user_key_extract, METH_VARARGS, NULL}, + { (char *)"semanage_user_key_free", _wrap_semanage_user_key_free, METH_VARARGS, NULL}, +@@ -5595,24 +6467,50 @@ + { (char *)"semanage_user_create", _wrap_semanage_user_create, METH_VARARGS, NULL}, + { (char *)"semanage_user_clone", _wrap_semanage_user_clone, METH_VARARGS, NULL}, + { (char *)"semanage_user_free", _wrap_semanage_user_free, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_query", _wrap_semanage_bool_query, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_exists", _wrap_semanage_bool_exists, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_count", _wrap_semanage_bool_count, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_iterate", _wrap_semanage_bool_iterate, METH_VARARGS, NULL}, +- { (char *)"semanage_bool_list", _wrap_semanage_bool_list, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_compare", _wrap_semanage_iface_compare, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_key_create", _wrap_semanage_iface_key_create, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_key_extract", _wrap_semanage_iface_key_extract, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_key_free", _wrap_semanage_iface_key_free, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_get_name", _wrap_semanage_iface_get_name, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_set_name", _wrap_semanage_iface_set_name, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_get_ifcon", _wrap_semanage_iface_get_ifcon, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_set_ifcon", _wrap_semanage_iface_set_ifcon, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_get_msgcon", _wrap_semanage_iface_get_msgcon, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_set_msgcon", _wrap_semanage_iface_set_msgcon, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_create", _wrap_semanage_iface_create, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_clone", _wrap_semanage_iface_clone, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_free", _wrap_semanage_iface_free, METH_VARARGS, NULL}, ++ { (char *)"semanage_user_add_local", _wrap_semanage_user_add_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_user_modify_local", _wrap_semanage_user_modify_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_user_set_local", _wrap_semanage_user_set_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_user_del_local", _wrap_semanage_user_del_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_user_query_local", _wrap_semanage_user_query_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_user_exists_local", _wrap_semanage_user_exists_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_user_count_local", _wrap_semanage_user_count_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_user_iterate_local", _wrap_semanage_user_iterate_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_user_list_local", _wrap_semanage_user_list_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_user_query", _wrap_semanage_user_query, METH_VARARGS, NULL}, ++ { (char *)"semanage_user_exists", _wrap_semanage_user_exists, METH_VARARGS, NULL}, ++ { (char *)"semanage_user_count", _wrap_semanage_user_count, METH_VARARGS, NULL}, ++ { (char *)"semanage_user_iterate", _wrap_semanage_user_iterate, METH_VARARGS, NULL}, ++ { (char *)"semanage_user_list", _wrap_semanage_user_list, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_compare", _wrap_semanage_port_compare, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_key_create", _wrap_semanage_port_key_create, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_key_extract", _wrap_semanage_port_key_extract, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_key_free", _wrap_semanage_port_key_free, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_get_proto", _wrap_semanage_port_get_proto, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_set_proto", _wrap_semanage_port_set_proto, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_get_proto_str", _wrap_semanage_port_get_proto_str, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_get_low", _wrap_semanage_port_get_low, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_get_high", _wrap_semanage_port_get_high, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_set_port", _wrap_semanage_port_set_port, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_set_range", _wrap_semanage_port_set_range, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_get_con", _wrap_semanage_port_get_con, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_set_con", _wrap_semanage_port_set_con, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_create", _wrap_semanage_port_create, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_clone", _wrap_semanage_port_clone, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_free", _wrap_semanage_port_free, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_add_local", _wrap_semanage_port_add_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_modify_local", _wrap_semanage_port_modify_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_set_local", _wrap_semanage_port_set_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_del_local", _wrap_semanage_port_del_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_query_local", _wrap_semanage_port_query_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_exists_local", _wrap_semanage_port_exists_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_count_local", _wrap_semanage_port_count_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_iterate_local", _wrap_semanage_port_iterate_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_list_local", _wrap_semanage_port_list_local, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_query", _wrap_semanage_port_query, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_exists", _wrap_semanage_port_exists, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_count", _wrap_semanage_port_count, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_iterate", _wrap_semanage_port_iterate, METH_VARARGS, NULL}, ++ { (char *)"semanage_port_list", _wrap_semanage_port_list, METH_VARARGS, NULL}, + { (char *)"semanage_seuser_key_create", _wrap_semanage_seuser_key_create, METH_VARARGS, NULL}, + { (char *)"semanage_seuser_key_extract", _wrap_semanage_seuser_key_extract, METH_VARARGS, NULL}, + { (char *)"semanage_seuser_key_free", _wrap_semanage_seuser_key_free, METH_VARARGS, NULL}, +@@ -5626,37 +6524,6 @@ + { (char *)"semanage_seuser_create", _wrap_semanage_seuser_create, METH_VARARGS, NULL}, + { (char *)"semanage_seuser_clone", _wrap_semanage_seuser_clone, METH_VARARGS, NULL}, + { (char *)"semanage_seuser_free", _wrap_semanage_seuser_free, METH_VARARGS, NULL}, +- { (char *)"semanage_user_add_local", _wrap_semanage_user_add_local, METH_VARARGS, NULL}, +- { (char *)"semanage_user_modify_local", _wrap_semanage_user_modify_local, METH_VARARGS, NULL}, +- { (char *)"semanage_user_set_local", _wrap_semanage_user_set_local, METH_VARARGS, NULL}, +- { (char *)"semanage_user_del_local", _wrap_semanage_user_del_local, METH_VARARGS, NULL}, +- { (char *)"semanage_user_query_local", _wrap_semanage_user_query_local, METH_VARARGS, NULL}, +- { (char *)"semanage_user_exists_local", _wrap_semanage_user_exists_local, METH_VARARGS, NULL}, +- { (char *)"semanage_user_count_local", _wrap_semanage_user_count_local, METH_VARARGS, NULL}, +- { (char *)"semanage_user_iterate_local", _wrap_semanage_user_iterate_local, METH_VARARGS, NULL}, +- { (char *)"semanage_user_list_local", _wrap_semanage_user_list_local, METH_VARARGS, NULL}, +- { (char *)"semanage_context_get_user", _wrap_semanage_context_get_user, METH_VARARGS, NULL}, +- { (char *)"semanage_context_set_user", _wrap_semanage_context_set_user, METH_VARARGS, NULL}, +- { (char *)"semanage_context_get_role", _wrap_semanage_context_get_role, METH_VARARGS, NULL}, +- { (char *)"semanage_context_set_role", _wrap_semanage_context_set_role, METH_VARARGS, NULL}, +- { (char *)"semanage_context_get_type", _wrap_semanage_context_get_type, METH_VARARGS, NULL}, +- { (char *)"semanage_context_set_type", _wrap_semanage_context_set_type, METH_VARARGS, NULL}, +- { (char *)"semanage_context_get_mls", _wrap_semanage_context_get_mls, METH_VARARGS, NULL}, +- { (char *)"semanage_context_set_mls", _wrap_semanage_context_set_mls, METH_VARARGS, NULL}, +- { (char *)"semanage_context_create", _wrap_semanage_context_create, METH_VARARGS, NULL}, +- { (char *)"semanage_context_clone", _wrap_semanage_context_clone, METH_VARARGS, NULL}, +- { (char *)"semanage_context_free", _wrap_semanage_context_free, METH_VARARGS, NULL}, +- { (char *)"semanage_context_from_string", _wrap_semanage_context_from_string, METH_VARARGS, NULL}, +- { (char *)"semanage_context_to_string", _wrap_semanage_context_to_string, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_add_local", _wrap_semanage_iface_add_local, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_modify_local", _wrap_semanage_iface_modify_local, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_set_local", _wrap_semanage_iface_set_local, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_del_local", _wrap_semanage_iface_del_local, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_query_local", _wrap_semanage_iface_query_local, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_exists_local", _wrap_semanage_iface_exists_local, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_count_local", _wrap_semanage_iface_count_local, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_iterate_local", _wrap_semanage_iface_iterate_local, METH_VARARGS, NULL}, +- { (char *)"semanage_iface_list_local", _wrap_semanage_iface_list_local, METH_VARARGS, NULL}, + { (char *)"semanage_seuser_add", _wrap_semanage_seuser_add, METH_VARARGS, NULL}, + { (char *)"semanage_seuser_modify", _wrap_semanage_seuser_modify, METH_VARARGS, NULL}, + { (char *)"semanage_seuser_set", _wrap_semanage_seuser_set, METH_VARARGS, NULL}, +@@ -5666,26 +6533,22 @@ + { (char *)"semanage_seuser_count", _wrap_semanage_seuser_count, METH_VARARGS, NULL}, + { (char *)"semanage_seuser_iterate", _wrap_semanage_seuser_iterate, METH_VARARGS, NULL}, + { (char *)"semanage_seuser_list", _wrap_semanage_seuser_list, METH_VARARGS, NULL}, +- { (char *)"semanage_user_query", _wrap_semanage_user_query, METH_VARARGS, NULL}, +- { (char *)"semanage_user_exists", _wrap_semanage_user_exists, METH_VARARGS, NULL}, +- { (char *)"semanage_user_count", _wrap_semanage_user_count, METH_VARARGS, NULL}, +- { (char *)"semanage_user_iterate", _wrap_semanage_user_iterate, METH_VARARGS, NULL}, +- { (char *)"semanage_user_list", _wrap_semanage_user_list, METH_VARARGS, NULL}, + { NULL, NULL, 0, NULL } + }; + + + /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + +-static swig_type_info _swigt__p_f_p_struct_semanage_bool_p_void__int[] = {{"_p_f_p_struct_semanage_bool_p_void__int", 0, "int (*)(struct semanage_bool *,void *)|int (*)(semanage_bool_t *,void *)", 0, 0, 0, 0},{"_p_f_p_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_f_p_struct_semanage_iface_p_void__int[] = {{"_p_f_p_struct_semanage_iface_p_void__int", 0, "int (*)(struct semanage_iface *,void *)|int (*)(semanage_iface_t *,void *)", 0, 0, 0, 0},{"_p_f_p_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_struct_semanage_bool_p_void__int[] = {{"_p_f_p_struct_semanage_bool_p_void__int", 0, "int (*)(struct semanage_bool *,void *)|int (*)(semanage_bool_t *,void *)", 0, 0, 0, 0},{"_p_f_p_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_f_p_struct_semanage_user_p_void__int[] = {{"_p_f_p_struct_semanage_user_p_void__int", 0, "int (*)(struct semanage_user *,void *)|int (*)(semanage_user_t *,void *)", 0, 0, 0, 0},{"_p_f_p_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_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_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_f_p_struct_semanage_port_p_void__int[] = {{"_p_f_p_struct_semanage_port_p_void__int", 0, "int (*)(struct semanage_port *,void *)|int (*)(semanage_port_t *,void *)", 0, 0, 0, 0},{"_p_f_p_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_struct_semanage_seuser_p_void__int[] = {{"_p_f_p_struct_semanage_seuser_p_void__int", 0, "int (*)(struct semanage_seuser *,void *)|int (*)(semanage_seuser_t *,void *)", 0, 0, 0, 0},{"_p_f_p_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_p_semanage_port_t[] = {{"_p_p_semanage_port_t", 0, "semanage_port_t **", 0, 0, 0, 0},{"_p_p_semanage_port_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +-static swig_type_info _swigt__p_semanage_port_t[] = {{"_p_semanage_port_t", 0, "semanage_port_t *", 0, 0, 0, 0},{"_p_semanage_port_t", 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_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_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}}; +@@ -5697,37 +6560,41 @@ + 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__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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_f_p_struct_semanage_bool_p_void__int, + _swigt__p_f_p_struct_semanage_iface_p_void__int, ++_swigt__p_f_p_struct_semanage_bool_p_void__int, + _swigt__p_p_p_char, + _swigt__p_char, + _swigt__p_p_char, + _swigt__p_f_p_struct_semanage_user_p_void__int, ++_swigt__p_semanage_port_key, ++_swigt__p_p_semanage_port_key, ++_swigt__p_f_p_struct_semanage_port_p_void__int, + _swigt__p_f_p_struct_semanage_seuser_p_void__int, +-_swigt__p_p_semanage_port_t, +-_swigt__p_semanage_port_t, + _swigt__p_p_semanage_seuser, + _swigt__p_semanage_seuser, + _swigt__p_p_p_semanage_seuser, +@@ -5739,24 +6606,27 @@ + _swigt__p_size_t, + _swigt__size_t, + _swigt__p_p_p_semanage_user, +-_swigt__p_semanage_seuser_key, + _swigt__p_p_semanage_user_key, + _swigt__p_semanage_user_key, ++_swigt__p_semanage_seuser_key, + _swigt__p_p_semanage_seuser_key, +-_swigt__p_semanage_iface, + _swigt__p_p_p_semanage_iface, + _swigt__p_p_semanage_iface, +-_swigt__p_semanage_bool_key, ++_swigt__p_semanage_iface, + _swigt__p_p_semanage_bool_key, ++_swigt__p_semanage_bool_key, + _swigt__p_unsigned_int, +-_swigt__p_semanage_context, + _swigt__p_p_semanage_context, +-_swigt__p_p_semanage_module_info, ++_swigt__p_semanage_context, + _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_p_semanage_port, ++_swigt__p_semanage_port, ++_swigt__p_p_p_semanage_port, + _swigt__p_int, + _swigt__p_semanage_handle, + 0 +@@ -6130,5 +7000,11 @@ + { + PyDict_SetItemString(d,"SEMANAGE_CON_POLSERV_REMOTE", SWIG_From_int((int)(SEMANAGE_CON_POLSERV_REMOTE))); + } ++ { ++ PyDict_SetItemString(d,"SEMANAGE_PROTO_UDP", SWIG_From_int((int)(0))); ++ } ++ { ++ PyDict_SetItemString(d,"SEMANAGE_PROTO_TCP", SWIG_From_int((int)(1))); ++ } + } - if (!sh->do_reload) - goto skip_reload; diff --git a/libsemanage.spec b/libsemanage.spec index 0d45ea1..e69a819 100644 --- a/libsemanage.spec +++ b/libsemanage.spec @@ -2,10 +2,12 @@ Summary: SELinux binary policy manipulation library Name: libsemanage Version: 1.5.3 -Release: 2 +Release: 3 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} @@ -36,6 +38,7 @@ needed for developing applications that manipulate binary policies. %prep %setup -q +%patch -p1 -b .rhat %build make clean @@ -71,6 +74,9 @@ rm -rf ${RPM_BUILD_ROOT} %{_includedir}/semanage/*.h %changelog +* Tue Dec 27 2005 Dan Walsh 1.5.3-3 +- Add Ivans patch to turn on ports + * Wed Dec 14 2005 Dan Walsh 1.5.3-2 - Remove patch since upstream does the right thing