Blob Blame Raw
diff --exclude-from=exclude -N -u -r nsalibselinux/include/selinux/selinux.h libselinux-2.0.79/include/selinux/selinux.h
--- nsalibselinux/include/selinux/selinux.h	2009-03-06 14:41:44.000000000 -0500
+++ libselinux-2.0.79/include/selinux/selinux.h	2009-03-27 11:38:27.000000000 -0400
@@ -457,8 +457,11 @@
 extern const char *selinux_file_context_path(void);
 extern const char *selinux_file_context_homedir_path(void);
 extern const char *selinux_file_context_local_path(void);
+extern const char *selinux_file_context_subs_path(void);
 extern const char *selinux_homedir_context_path(void);
 extern const char *selinux_media_context_path(void);
+extern const char *selinux_virtual_domain_context_path(void);
+extern const char *selinux_virtual_image_context_path(void);
 extern const char *selinux_x_context_path(void);
 extern const char *selinux_contexts_path(void);
 extern const char *selinux_securetty_types_path(void);
@@ -520,6 +523,14 @@
    Caller must free the returned strings via free. */
 extern int getseuserbyname(const char *linuxuser, char **seuser, char **level);
 
+/* Get the SELinux username and level to use for a given Linux username and service. 
+   These values may then be passed into the get_ordered_context_list*
+   and get_default_context* functions to obtain a context for the user.
+   Returns 0 on success or -1 otherwise.
+   Caller must free the returned strings via free. */
+extern int getseuser(const char *username, const char *service, 
+		     char **r_seuser, char **r_level);
+
 /* Compare two file contexts, return 0 if equivalent. */
 int selinux_file_context_cmp(const security_context_t a,
 			     const security_context_t b);
diff --exclude-from=exclude -N -u -r nsalibselinux/man/man8/selinuxconlist.8 libselinux-2.0.79/man/man8/selinuxconlist.8
--- nsalibselinux/man/man8/selinuxconlist.8	1969-12-31 19:00:00.000000000 -0500
+++ libselinux-2.0.79/man/man8/selinuxconlist.8	2009-03-27 10:09:31.000000000 -0400
@@ -0,0 +1,18 @@
+.TH "selinuxconlist" "1" "7 May 2008" "dwalsh@redhat.com" "SELinux Command Line documentation"
+.SH "NAME"
+selinuxconlist \- list all SELinux context reachable for user
+.SH "SYNOPSIS"
+.B selinuxconlist [-l level] user [context]
+
+.SH "DESCRIPTION"
+.B selinuxconlist
+reports the list of context reachable for user from the current context or specified context
+
+.B \-l level
+mcs/mls level
+
+.SH AUTHOR	
+This manual page was written by Dan Walsh <dwalsh@redhat.com>.
+
+.SH "SEE ALSO"
+secon(8), selinuxdefcon(8)
diff --exclude-from=exclude -N -u -r nsalibselinux/man/man8/selinuxdefcon.8 libselinux-2.0.79/man/man8/selinuxdefcon.8
--- nsalibselinux/man/man8/selinuxdefcon.8	1969-12-31 19:00:00.000000000 -0500
+++ libselinux-2.0.79/man/man8/selinuxdefcon.8	2009-03-27 10:09:31.000000000 -0400
@@ -0,0 +1,19 @@
+.TH "selinuxdefcon" "1" "7 May 2008" "dwalsh@redhat.com" "SELinux Command Line documentation"
+.SH "NAME"
+selinuxdefcon \- list default SELinux context for user 
+
+.SH "SYNOPSIS"
+.B selinuxdefcon [-l level] user [fromcon]
+
+.SH "DESCRIPTION"
+.B seconlist
+reports the default context for the specified user from current context or specified context
+
+.B \-l level
+mcs/mls level
+
+.SH AUTHOR	
+This manual page was written by Dan Walsh <dwalsh@redhat.com>.
+
+.SH "SEE ALSO"
+secon(8), selinuxconlist(8)
diff --exclude-from=exclude -N -u -r nsalibselinux/src/callbacks.c libselinux-2.0.79/src/callbacks.c
--- nsalibselinux/src/callbacks.c	2009-03-06 14:41:45.000000000 -0500
+++ libselinux-2.0.79/src/callbacks.c	2009-03-27 10:09:31.000000000 -0400
@@ -16,6 +16,7 @@
 {
 	int rc;
 	va_list ap;
+	if (is_selinux_enabled() == 0) return 0;
 	va_start(ap, fmt);
 	rc = vfprintf(stderr, fmt, ap);
 	va_end(ap);
diff --exclude-from=exclude -N -u -r nsalibselinux/src/d libselinux-2.0.79/src/d
--- nsalibselinux/src/d	1969-12-31 19:00:00.000000000 -0500
+++ libselinux-2.0.79/src/d	2009-03-27 11:32:04.000000000 -0400
@@ -0,0 +1,801 @@
+
+%exception is_selinux_enabled {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception is_selinux_mls_enabled {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception getcon {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception getcon_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception setcon {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception setcon_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception getpidcon {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception getpidcon_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception getprevcon {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception getprevcon_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception getexeccon {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception getexeccon_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception setexeccon {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception setexeccon_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception getfscreatecon {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception getfscreatecon_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception setfscreatecon {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception setfscreatecon_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception getkeycreatecon {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception getkeycreatecon_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception setkeycreatecon {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception setkeycreatecon_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception getsockcreatecon {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception getsockcreatecon_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception setsockcreatecon {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception setsockcreatecon_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception getfilecon {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception getfilecon_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception lgetfilecon {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception lgetfilecon_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception fgetfilecon {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception fgetfilecon_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception setfilecon {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception setfilecon_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception lsetfilecon {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception lsetfilecon_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception fsetfilecon {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception fsetfilecon_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception getpeercon {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception getpeercon_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_compute_av {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_compute_av_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_compute_create {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_compute_create_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_compute_relabel {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_compute_relabel_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_compute_member {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_compute_member_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_compute_user {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_compute_user_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_load_policy {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_get_initial_context {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_get_initial_context_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception selinux_mkload_policy {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception selinux_init_load_policy {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_set_boolean_list {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_load_booleans {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_check_context {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_check_context_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_canonicalize_context {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_canonicalize_context_raw {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_getenforce {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_setenforce {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_disable {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_policyvers {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_get_boolean_names {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_get_boolean_pending {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_get_boolean_active {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_set_boolean {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_commit_booleans {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception security_av_string {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception matchpathcon_init {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception matchpathcon_init_prefix {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception matchpathcon {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception matchpathcon_index {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception matchpathcon_filespec_add {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception matchmediacon {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception selinux_getenforcemode {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception selinux_getpolicytype {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception selinux_check_passwd_access {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception checkPasswdAccess {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception selinux_check_securetty_context {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception rpm_execcon {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception is_context_customizable {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception selinux_trans_to_raw_context {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception selinux_raw_to_trans_context {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception selinux_raw_context_to_color {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception getseuserbyname {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
+
+%exception getseuser {
+   
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+
diff --exclude-from=exclude -N -u -r nsalibselinux/src/exception.h libselinux-2.0.79/src/exception.h
--- nsalibselinux/src/exception.h	1969-12-31 19:00:00.000000000 -0500
+++ libselinux-2.0.79/src/exception.h	2009-03-27 11:32:14.000000000 -0400
@@ -0,0 +1,12 @@
+function except() {
+echo "
+%exception $1 {
+  $action 
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+"
+}
+for i in `grep "extern *int" ../include/selinux/selinux.h | awk '{ print $3 }' | cut -d '(' -f 1`; do except $i ; done 
diff --exclude-from=exclude -N -u -r nsalibselinux/src/exception.sh libselinux-2.0.79/src/exception.sh
--- nsalibselinux/src/exception.sh	1969-12-31 19:00:00.000000000 -0500
+++ libselinux-2.0.79/src/exception.sh	2009-03-27 14:20:10.000000000 -0400
@@ -0,0 +1,12 @@
+function except() {
+echo "
+%exception $1 {
+  \$action 
+  if (result < 0) {
+     PyErr_SetFromErrno(PyExc_OSError);
+     return NULL;
+  }
+}
+"
+}
+for i in `grep "extern *int" ../include/selinux/selinux.h | awk '{ print $3 }' | cut -d '(' -f 1`; do except $i ; done 
diff --exclude-from=exclude -N -u -r nsalibselinux/src/file_path_suffixes.h libselinux-2.0.79/src/file_path_suffixes.h
--- nsalibselinux/src/file_path_suffixes.h	2009-03-06 14:41:45.000000000 -0500
+++ libselinux-2.0.79/src/file_path_suffixes.h	2009-03-27 10:09:31.000000000 -0400
@@ -20,3 +20,6 @@
     S_(FILE_CONTEXTS_LOCAL, "/contexts/files/file_contexts.local")
     S_(X_CONTEXTS, "/contexts/x_contexts")
     S_(COLORS, "/secolor.conf")
+    S_(VIRTUAL_DOMAIN, "/contexts/virtual_domain_context")
+    S_(VIRTUAL_IMAGE, "/contexts/virtual_image_context")
+    S_(FILE_CONTEXT_SUBS, "/contexts/files/file_contexts.subs")
diff --exclude-from=exclude -N -u -r nsalibselinux/src/label.c libselinux-2.0.79/src/label.c
--- nsalibselinux/src/label.c	2009-03-06 14:41:45.000000000 -0500
+++ libselinux-2.0.79/src/label.c	2009-03-27 10:09:31.000000000 -0400
@@ -5,10 +5,12 @@
  */
 
 #include <sys/types.h>
+#include <ctype.h>
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <selinux/selinux.h>
 #include "callbacks.h"
 #include "label_internal.h"
 
@@ -23,6 +25,96 @@
 	&selabel_x_init
 };
 
+typedef struct selabel_sub {
+	char *src;
+	int slen;
+	char *dst;
+	struct selabel_sub *next;
+} SELABELSUB;
+
+SELABELSUB *selabelsublist = NULL;
+
+static void selabel_subs_fini(void)
+{
+	SELABELSUB *ptr = selabelsublist;
+	SELABELSUB *next = NULL;
+	while (ptr) {
+		next = ptr->next;
+		free(ptr->src);
+		free(ptr->dst);
+		free(ptr);
+		ptr = next;
+	}
+	selabelsublist = NULL;
+}
+
+static char *selabel_sub(const char *src) 
+{
+	char *dst = NULL;
+	SELABELSUB *ptr = selabelsublist;
+	while (ptr) {
+		if (strncmp(src, ptr->src, ptr->slen) == 0 ) {
+			if (src[ptr->slen] == '/' || 
+			    src[ptr->slen] == 0) {
+				asprintf(&dst, "%s%s", ptr->dst, &src[ptr->slen]);
+				return dst;
+			}
+		}
+		ptr = ptr->next;
+	}
+	return NULL;
+}
+
+static int selabel_subs_init(void)
+{
+	char buf[1024];
+	FILE *cfg = fopen(selinux_file_context_subs_path(), "r");
+	if (cfg) {
+		while (fgets_unlocked(buf, sizeof(buf) - 1, cfg)) {
+			char *ptr = NULL;
+			char *src = buf;
+			char *dst = NULL;
+
+			while (*src && isspace(*src))
+				src++;
+			if (src[0] == '#') continue;
+			ptr = src;
+			while (*ptr && ! isspace(*ptr))
+				ptr++;
+			*ptr++ = 0;
+			if (! *src) continue;
+
+			dst = ptr;
+			while (*dst && isspace(*dst))
+				dst++;
+			ptr=dst;
+			while (*ptr && ! isspace(*ptr))
+				ptr++;
+			*ptr=0;
+			if (! *dst) continue;
+
+			SELABELSUB *sub = (SELABELSUB*) malloc(sizeof(SELABELSUB));
+			if (! sub) return -1;
+			sub->src=strdup(src);
+			if (! sub->src) {
+				free(sub);
+				return -1;
+			}
+			sub->dst=strdup(dst);
+			if (! sub->dst) {
+				free(sub);
+				free(sub->src);
+				return -1;
+			}
+			sub->slen = strlen(src);
+			sub->next = selabelsublist;
+			selabelsublist = sub;
+		}
+		fclose(cfg);
+	}
+	return 0;
+}
+
 /*
  * Validation functions
  */
@@ -67,6 +159,8 @@
 		goto out;
 	}
 
+	selabel_subs_init();
+
 	rec = (struct selabel_handle *)malloc(sizeof(*rec));
 	if (!rec)
 		goto out;
@@ -88,7 +182,14 @@
 selabel_lookup_common(struct selabel_handle *rec, int translating,
 		      const char *key, int type)
 {
-	struct selabel_lookup_rec *lr = rec->func_lookup(rec, key, type);
+	struct selabel_lookup_rec *lr;
+	char *ptr = selabel_sub(key);
+	if (ptr) {
+		lr = rec->func_lookup(rec, ptr, type); 
+		free(ptr);
+	} else {
+		lr = rec->func_lookup(rec, key, type); 
+	}
 	if (!lr)
 		return NULL;
 
@@ -132,6 +233,8 @@
 {
 	rec->func_close(rec);
 	free(rec);
+
+	selabel_subs_fini();
 }
 
 void selabel_stats(struct selabel_handle *rec)
diff --exclude-from=exclude -N -u -r nsalibselinux/src/Makefile libselinux-2.0.79/src/Makefile
--- nsalibselinux/src/Makefile	2009-03-06 14:41:45.000000000 -0500
+++ libselinux-2.0.79/src/Makefile	2009-03-27 14:21:35.000000000 -0400
@@ -82,6 +82,9 @@
 	$(CC) $(CFLAGS) $(LDFLAGS) -shared -o $@ $^ -ldl -L$(LIBDIR) -Wl,-soname,$(LIBSO),-z,defs,-z,relro
 	ln -sf $@ $(TARGET) 
 
+selinuxswig_exception.i: ../include/selinux/selinux.h
+	sh exception.sh > $@ 
+
 audit2why.lo: audit2why.c
 	$(CC) $(CFLAGS) -I$(PYINC) -fPIC -DSHARED -c -o $@ $<
 
@@ -100,8 +103,8 @@
 $(SWIGRUBYCOUT): $(SWIGRUBYIF)
 	$(SWIGRUBY) $^
 
-swigify: $(SWIGIF)
-	$(SWIG) $^
+swigify: $(SWIGIF) selinuxswig_exception.i
+	$(SWIG) $<
 
 install: all 
 	test -d $(LIBDIR) || install -m 755 -d $(LIBDIR)
@@ -124,7 +127,7 @@
 	/sbin/restorecon $(SHLIBDIR)/$(LIBSO)
 
 clean: 
-	-rm -f $(OBJS) $(LOBJS) $(LIBA) $(LIBSO) $(SWIGLOBJ) $(SWIGSO) $(TARGET) $(AUDIT2WHYSO) *.o *.lo *~
+	-rm -f $(OBJS) $(LOBJS) $(LIBA) $(LIBSO) $(SWIGLOBJ) $(SWIGSO) $(TARGET) $(AUDIT2WHYSO) *.o *.lo *~ selinuxswig_exception.i
 
 distclean: clean
 	rm -f $(GENERATED) $(SWIGFILES)
diff --exclude-from=exclude -N -u -r nsalibselinux/src/matchpathcon.c libselinux-2.0.79/src/matchpathcon.c
--- nsalibselinux/src/matchpathcon.c	2009-03-06 14:41:45.000000000 -0500
+++ libselinux-2.0.79/src/matchpathcon.c	2009-03-27 10:09:31.000000000 -0400
@@ -2,6 +2,7 @@
 #include <string.h>
 #include <errno.h>
 #include <stdio.h>
+#include <syslog.h>
 #include "selinux_internal.h"
 #include "label_internal.h"
 #include "callbacks.h"
@@ -57,7 +58,7 @@
 {
 	va_list ap;
 	va_start(ap, fmt);
-	vfprintf(stderr, fmt, ap);
+	vsyslog(LOG_ERR, fmt, ap);
 	va_end(ap);
 }
 
diff --exclude-from=exclude -N -u -r nsalibselinux/src/selinux_config.c libselinux-2.0.79/src/selinux_config.c
--- nsalibselinux/src/selinux_config.c	2009-03-06 14:41:45.000000000 -0500
+++ libselinux-2.0.79/src/selinux_config.c	2009-03-27 10:09:31.000000000 -0400
@@ -40,7 +40,10 @@
 #define SECURETTY_TYPES   18
 #define X_CONTEXTS        19
 #define COLORS            20
-#define NEL               21
+#define VIRTUAL_DOMAIN    21
+#define VIRTUAL_IMAGE     22
+#define FILE_CONTEXT_SUBS 23
+#define NEL               24
 
 /* New layout is relative to SELINUXDIR/policytype. */
 static char *file_paths[NEL];
@@ -391,3 +394,24 @@
 }
 
 hidden_def(selinux_x_context_path)
+
+const char *selinux_virtual_domain_context_path()
+{
+	return get_path(VIRTUAL_DOMAIN);
+}
+
+hidden_def(selinux_virtual_domain_context_path)
+
+const char *selinux_virtual_image_context_path()
+{
+	return get_path(VIRTUAL_IMAGE);
+}
+
+hidden_def(selinux_virtual_image_context_path)
+
+const char * selinux_file_context_subs_path(void) {
+	return get_path(FILE_CONTEXT_SUBS);
+}
+
+hidden_def(selinux_file_context_subs_path)
+
diff --exclude-from=exclude -N -u -r nsalibselinux/src/selinux_internal.h libselinux-2.0.79/src/selinux_internal.h
--- nsalibselinux/src/selinux_internal.h	2009-03-06 14:41:45.000000000 -0500
+++ libselinux-2.0.79/src/selinux_internal.h	2009-03-27 10:09:31.000000000 -0400
@@ -56,9 +56,12 @@
     hidden_proto(selinux_securetty_types_path)
     hidden_proto(selinux_failsafe_context_path)
     hidden_proto(selinux_removable_context_path)
+    hidden_proto(selinux_virtual_domain_context_path)
+    hidden_proto(selinux_virtual_image_context_path)
     hidden_proto(selinux_file_context_path)
     hidden_proto(selinux_file_context_homedir_path)
     hidden_proto(selinux_file_context_local_path)
+    hidden_proto(selinux_file_context_subs_path)
     hidden_proto(selinux_netfilter_context_path)
     hidden_proto(selinux_homedir_context_path)
     hidden_proto(selinux_user_contexts_path)
diff --exclude-from=exclude -N -u -r nsalibselinux/src/selinux.py libselinux-2.0.79/src/selinux.py
--- nsalibselinux/src/selinux.py	2009-03-06 14:41:45.000000000 -0500
+++ libselinux-2.0.79/src/selinux.py	2009-03-27 14:21:40.000000000 -0400
@@ -1,12 +1,26 @@
 # This file was automatically generated by SWIG (http://www.swig.org).
-# Version 1.3.35
+# Version 1.3.38
 #
-# Don't modify this file, modify the SWIG interface instead.
+# Do not make changes to this file unless you know what you are doing--modify
+# the SWIG interface file instead.
 # This file is compatible with both classic and new-style classes.
 
-import _selinux
-import new
-new_instancemethod = new.instancemethod
+from sys import version_info
+if version_info >= (2,6,0):
+    def swig_import_helper():
+        from os.path import dirname
+        import imp
+        try:
+            fp, pathname, description = imp.find_module('_selinux', [dirname(__file__)])
+            _mod = imp.load_module('_selinux', fp, pathname, description)
+        finally:
+            if fp is not None: fp.close()
+        return _mod
+    _selinux = swig_import_helper()
+    del swig_import_helper
+else:
+    import _selinux
+del version_info
 try:
     _swig_property = property
 except NameError:
@@ -14,7 +28,7 @@
 def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
     if (name == "thisown"): return self.this.own(value)
     if (name == "this"):
-        if type(value).__name__ == 'PySwigObject':
+        if type(value).__name__ == 'SwigPyObject':
             self.__dict__[name] = value
             return
     method = class_type.__swig_setmethods__.get(name,None)
@@ -31,21 +45,19 @@
     if (name == "thisown"): return self.this.own()
     method = class_type.__swig_getmethods__.get(name,None)
     if method: return method(self)
-    raise AttributeError,name
+    raise AttributeError(name)
 
 def _swig_repr(self):
     try: strthis = "proxy of " + self.this.__repr__()
     except: strthis = ""
     return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
 
-import types
 try:
-    _object = types.ObjectType
+    _object = object
     _newclass = 1
 except AttributeError:
     class _object : pass
     _newclass = 0
-del types
 
 
 import shutil, os, stat
@@ -61,46 +73,175 @@
                              map(restorecon, [os.path.join(dirname, fname)
                                               for fname in fnames]), None)
 
+def copytree(src, dest):
+    """ An SELinux-friendly shutil.copytree method """
+    shutil.copytree(src, dest)
+    restorecon(dest, recursive=True)
+
+def install(src, dest):
+    """ An SELinux-friendly shutil.move method """
+    shutil.move(src, dest)
+    restorecon(dest, recursive=True)
 
+
+def is_selinux_enabled():
+  return _selinux.is_selinux_enabled()
 is_selinux_enabled = _selinux.is_selinux_enabled
+
+def is_selinux_mls_enabled():
+  return _selinux.is_selinux_mls_enabled()
 is_selinux_mls_enabled = _selinux.is_selinux_mls_enabled
+
+def getcon():
+  return _selinux.getcon()
 getcon = _selinux.getcon
+
+def getcon_raw():
+  return _selinux.getcon_raw()
 getcon_raw = _selinux.getcon_raw
+
+def setcon(*args):
+  return _selinux.setcon(*args)
 setcon = _selinux.setcon
+
+def setcon_raw(*args):
+  return _selinux.setcon_raw(*args)
 setcon_raw = _selinux.setcon_raw
+
+def getpidcon(*args):
+  return _selinux.getpidcon(*args)
 getpidcon = _selinux.getpidcon
+
+def getpidcon_raw(*args):
+  return _selinux.getpidcon_raw(*args)
 getpidcon_raw = _selinux.getpidcon_raw
+
+def getprevcon():
+  return _selinux.getprevcon()
 getprevcon = _selinux.getprevcon
+
+def getprevcon_raw():
+  return _selinux.getprevcon_raw()
 getprevcon_raw = _selinux.getprevcon_raw
+
+def getexeccon():
+  return _selinux.getexeccon()
 getexeccon = _selinux.getexeccon
+
+def getexeccon_raw():
+  return _selinux.getexeccon_raw()
 getexeccon_raw = _selinux.getexeccon_raw
+
+def setexeccon(*args):
+  return _selinux.setexeccon(*args)
 setexeccon = _selinux.setexeccon
+
+def setexeccon_raw(*args):
+  return _selinux.setexeccon_raw(*args)
 setexeccon_raw = _selinux.setexeccon_raw
+
+def getfscreatecon():
+  return _selinux.getfscreatecon()
 getfscreatecon = _selinux.getfscreatecon
+
+def getfscreatecon_raw():
+  return _selinux.getfscreatecon_raw()
 getfscreatecon_raw = _selinux.getfscreatecon_raw
+
+def setfscreatecon(*args):
+  return _selinux.setfscreatecon(*args)
 setfscreatecon = _selinux.setfscreatecon
+
+def setfscreatecon_raw(*args):
+  return _selinux.setfscreatecon_raw(*args)
 setfscreatecon_raw = _selinux.setfscreatecon_raw
+
+def getkeycreatecon():
+  return _selinux.getkeycreatecon()
 getkeycreatecon = _selinux.getkeycreatecon
+
+def getkeycreatecon_raw():
+  return _selinux.getkeycreatecon_raw()
 getkeycreatecon_raw = _selinux.getkeycreatecon_raw
+
+def setkeycreatecon(*args):
+  return _selinux.setkeycreatecon(*args)
 setkeycreatecon = _selinux.setkeycreatecon
+
+def setkeycreatecon_raw(*args):
+  return _selinux.setkeycreatecon_raw(*args)
 setkeycreatecon_raw = _selinux.setkeycreatecon_raw
+
+def getsockcreatecon():
+  return _selinux.getsockcreatecon()
 getsockcreatecon = _selinux.getsockcreatecon
+
+def getsockcreatecon_raw():
+  return _selinux.getsockcreatecon_raw()
 getsockcreatecon_raw = _selinux.getsockcreatecon_raw
+
+def setsockcreatecon(*args):
+  return _selinux.setsockcreatecon(*args)
 setsockcreatecon = _selinux.setsockcreatecon
+
+def setsockcreatecon_raw(*args):
+  return _selinux.setsockcreatecon_raw(*args)
 setsockcreatecon_raw = _selinux.setsockcreatecon_raw
+
+def getfilecon(*args):
+  return _selinux.getfilecon(*args)
 getfilecon = _selinux.getfilecon
+
+def getfilecon_raw(*args):
+  return _selinux.getfilecon_raw(*args)
 getfilecon_raw = _selinux.getfilecon_raw
+
+def lgetfilecon(*args):
+  return _selinux.lgetfilecon(*args)
 lgetfilecon = _selinux.lgetfilecon
+
+def lgetfilecon_raw(*args):
+  return _selinux.lgetfilecon_raw(*args)
 lgetfilecon_raw = _selinux.lgetfilecon_raw
+
+def fgetfilecon(*args):
+  return _selinux.fgetfilecon(*args)
 fgetfilecon = _selinux.fgetfilecon
+
+def fgetfilecon_raw(*args):
+  return _selinux.fgetfilecon_raw(*args)
 fgetfilecon_raw = _selinux.fgetfilecon_raw
+
+def setfilecon(*args):
+  return _selinux.setfilecon(*args)
 setfilecon = _selinux.setfilecon
+
+def setfilecon_raw(*args):
+  return _selinux.setfilecon_raw(*args)
 setfilecon_raw = _selinux.setfilecon_raw
+
+def lsetfilecon(*args):
+  return _selinux.lsetfilecon(*args)
 lsetfilecon = _selinux.lsetfilecon
+
+def lsetfilecon_raw(*args):
+  return _selinux.lsetfilecon_raw(*args)
 lsetfilecon_raw = _selinux.lsetfilecon_raw
+
+def fsetfilecon(*args):
+  return _selinux.fsetfilecon(*args)
 fsetfilecon = _selinux.fsetfilecon
+
+def fsetfilecon_raw(*args):
+  return _selinux.fsetfilecon_raw(*args)
 fsetfilecon_raw = _selinux.fsetfilecon_raw
+
+def getpeercon(*args):
+  return _selinux.getpeercon(*args)
 getpeercon = _selinux.getpeercon
+
+def getpeercon_raw(*args):
+  return _selinux.getpeercon_raw(*args)
 getpeercon_raw = _selinux.getpeercon_raw
 class av_decision(_object):
     __swig_setmethods__ = {}
@@ -123,8 +264,8 @@
     __swig_setmethods__["seqno"] = _selinux.av_decision_seqno_set
     __swig_getmethods__["seqno"] = _selinux.av_decision_seqno_get
     if _newclass:seqno = _swig_property(_selinux.av_decision_seqno_get, _selinux.av_decision_seqno_set)
-    def __init__(self, *args): 
-        this = _selinux.new_av_decision(*args)
+    def __init__(self): 
+        this = _selinux.new_av_decision()
         try: self.this.append(this)
         except: self.this = this
     __swig_destroy__ = _selinux.delete_av_decision
@@ -144,8 +285,8 @@
     __swig_setmethods__["value"] = _selinux.selinux_opt_value_set
     __swig_getmethods__["value"] = _selinux.selinux_opt_value_get
     if _newclass:value = _swig_property(_selinux.selinux_opt_value_get, _selinux.selinux_opt_value_set)
-    def __init__(self, *args): 
-        this = _selinux.new_selinux_opt(*args)
+    def __init__(self): 
+        this = _selinux.new_selinux_opt()
         try: self.this.append(this)
         except: self.this = this
     __swig_destroy__ = _selinux.delete_selinux_opt
@@ -153,53 +294,72 @@
 selinux_opt_swigregister = _selinux.selinux_opt_swigregister
 selinux_opt_swigregister(selinux_opt)
 
-class selinux_callback(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, selinux_callback, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, selinux_callback, name)
-    __repr__ = _swig_repr
-    __swig_setmethods__["func_log"] = _selinux.selinux_callback_func_log_set
-    __swig_getmethods__["func_log"] = _selinux.selinux_callback_func_log_get
-    if _newclass:func_log = _swig_property(_selinux.selinux_callback_func_log_get, _selinux.selinux_callback_func_log_set)
-    __swig_setmethods__["func_audit"] = _selinux.selinux_callback_func_audit_set
-    __swig_getmethods__["func_audit"] = _selinux.selinux_callback_func_audit_get
-    if _newclass:func_audit = _swig_property(_selinux.selinux_callback_func_audit_get, _selinux.selinux_callback_func_audit_set)
-    __swig_setmethods__["func_validate"] = _selinux.selinux_callback_func_validate_set
-    __swig_getmethods__["func_validate"] = _selinux.selinux_callback_func_validate_get
-    if _newclass:func_validate = _swig_property(_selinux.selinux_callback_func_validate_get, _selinux.selinux_callback_func_validate_set)
-    def __init__(self, *args): 
-        this = _selinux.new_selinux_callback(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _selinux.delete_selinux_callback
-    __del__ = lambda self : None;
-selinux_callback_swigregister = _selinux.selinux_callback_swigregister
-selinux_callback_swigregister(selinux_callback)
-
 SELINUX_CB_LOG = _selinux.SELINUX_CB_LOG
 SELINUX_CB_AUDIT = _selinux.SELINUX_CB_AUDIT
 SELINUX_CB_VALIDATE = _selinux.SELINUX_CB_VALIDATE
-selinux_get_callback = _selinux.selinux_get_callback
-selinux_set_callback = _selinux.selinux_set_callback
 SELINUX_ERROR = _selinux.SELINUX_ERROR
 SELINUX_WARNING = _selinux.SELINUX_WARNING
 SELINUX_INFO = _selinux.SELINUX_INFO
 SELINUX_AVC = _selinux.SELINUX_AVC
+
+def security_compute_av(*args):
+  return _selinux.security_compute_av(*args)
 security_compute_av = _selinux.security_compute_av
+
+def security_compute_av_raw(*args):
+  return _selinux.security_compute_av_raw(*args)
 security_compute_av_raw = _selinux.security_compute_av_raw
+
+def security_compute_create(*args):
+  return _selinux.security_compute_create(*args)
 security_compute_create = _selinux.security_compute_create
+
+def security_compute_create_raw(*args):
+  return _selinux.security_compute_create_raw(*args)
 security_compute_create_raw = _selinux.security_compute_create_raw
+
+def security_compute_relabel(*args):
+  return _selinux.security_compute_relabel(*args)
 security_compute_relabel = _selinux.security_compute_relabel
+
+def security_compute_relabel_raw(*args):
+  return _selinux.security_compute_relabel_raw(*args)
 security_compute_relabel_raw = _selinux.security_compute_relabel_raw
+
+def security_compute_member(*args):
+  return _selinux.security_compute_member(*args)
 security_compute_member = _selinux.security_compute_member
+
+def security_compute_member_raw(*args):
+  return _selinux.security_compute_member_raw(*args)
 security_compute_member_raw = _selinux.security_compute_member_raw
+
+def security_compute_user(*args):
+  return _selinux.security_compute_user(*args)
 security_compute_user = _selinux.security_compute_user
+
+def security_compute_user_raw(*args):
+  return _selinux.security_compute_user_raw(*args)
 security_compute_user_raw = _selinux.security_compute_user_raw
+
+def security_load_policy(*args):
+  return _selinux.security_load_policy(*args)
 security_load_policy = _selinux.security_load_policy
+
+def security_get_initial_context(*args):
+  return _selinux.security_get_initial_context(*args)
 security_get_initial_context = _selinux.security_get_initial_context
+
+def security_get_initial_context_raw(*args):
+  return _selinux.security_get_initial_context_raw(*args)
 security_get_initial_context_raw = _selinux.security_get_initial_context_raw
+
+def selinux_mkload_policy(*args):
+  return _selinux.selinux_mkload_policy(*args)
 selinux_mkload_policy = _selinux.selinux_mkload_policy
+
+def selinux_init_load_policy():
+  return _selinux.selinux_init_load_policy()
 selinux_init_load_policy = _selinux.selinux_init_load_policy
 class SELboolean(_object):
     __swig_setmethods__ = {}
@@ -213,8 +373,8 @@
     __swig_setmethods__["value"] = _selinux.SELboolean_value_set
     __swig_getmethods__["value"] = _selinux.SELboolean_value_get
     if _newclass:value = _swig_property(_selinux.SELboolean_value_get, _selinux.SELboolean_value_set)
-    def __init__(self, *args): 
-        this = _selinux.new_SELboolean(*args)
+    def __init__(self): 
+        this = _selinux.new_SELboolean()
         try: self.this.append(this)
         except: self.this = this
     __swig_destroy__ = _selinux.delete_SELboolean
@@ -222,20 +382,65 @@
 SELboolean_swigregister = _selinux.SELboolean_swigregister
 SELboolean_swigregister(SELboolean)
 
+
+def security_set_boolean_list(*args):
+  return _selinux.security_set_boolean_list(*args)
 security_set_boolean_list = _selinux.security_set_boolean_list
+
+def security_load_booleans(*args):
+  return _selinux.security_load_booleans(*args)
 security_load_booleans = _selinux.security_load_booleans
+
+def security_check_context(*args):
+  return _selinux.security_check_context(*args)
 security_check_context = _selinux.security_check_context
+
+def security_check_context_raw(*args):
+  return _selinux.security_check_context_raw(*args)
 security_check_context_raw = _selinux.security_check_context_raw
+
+def security_canonicalize_context(*args):
+  return _selinux.security_canonicalize_context(*args)
 security_canonicalize_context = _selinux.security_canonicalize_context
+
+def security_canonicalize_context_raw(*args):
+  return _selinux.security_canonicalize_context_raw(*args)
 security_canonicalize_context_raw = _selinux.security_canonicalize_context_raw
+
+def security_getenforce():
+  return _selinux.security_getenforce()
 security_getenforce = _selinux.security_getenforce
+
+def security_setenforce(*args):
+  return _selinux.security_setenforce(*args)
 security_setenforce = _selinux.security_setenforce
+
+def security_disable():
+  return _selinux.security_disable()
 security_disable = _selinux.security_disable
+
+def security_policyvers():
+  return _selinux.security_policyvers()
 security_policyvers = _selinux.security_policyvers
+
+def security_get_boolean_names():
+  return _selinux.security_get_boolean_names()
 security_get_boolean_names = _selinux.security_get_boolean_names
+
+def security_get_boolean_pending(*args):
+  return _selinux.security_get_boolean_pending(*args)
 security_get_boolean_pending = _selinux.security_get_boolean_pending
+
+def security_get_boolean_active(*args):
+  return _selinux.security_get_boolean_active(*args)
 security_get_boolean_active = _selinux.security_get_boolean_active
+
+def security_set_boolean(*args):
+  return _selinux.security_set_boolean(*args)
 security_set_boolean = _selinux.security_set_boolean
+
+def security_commit_booleans():
+  return _selinux.security_commit_booleans()
 security_commit_booleans = _selinux.security_commit_booleans
 class security_class_mapping(_object):
     __swig_setmethods__ = {}
@@ -249,8 +454,8 @@
     __swig_setmethods__["perms"] = _selinux.security_class_mapping_perms_set
     __swig_getmethods__["perms"] = _selinux.security_class_mapping_perms_get
     if _newclass:perms = _swig_property(_selinux.security_class_mapping_perms_get, _selinux.security_class_mapping_perms_set)
-    def __init__(self, *args): 
-        this = _selinux.new_security_class_mapping(*args)
+    def __init__(self): 
+        this = _selinux.new_security_class_mapping()
         try: self.this.append(this)
         except: self.this = this
     __swig_destroy__ = _selinux.delete_security_class_mapping
@@ -258,211 +463,270 @@
 security_class_mapping_swigregister = _selinux.security_class_mapping_swigregister
 security_class_mapping_swigregister(security_class_mapping)
 
-selinux_set_mapping = _selinux.selinux_set_mapping
+
+def string_to_security_class(*args):
+  return _selinux.string_to_security_class(*args)
 string_to_security_class = _selinux.string_to_security_class
+
+def security_class_to_string(*args):
+  return _selinux.security_class_to_string(*args)
 security_class_to_string = _selinux.security_class_to_string
+
+def security_av_perm_to_string(*args):
+  return _selinux.security_av_perm_to_string(*args)
 security_av_perm_to_string = _selinux.security_av_perm_to_string
+
+def string_to_av_perm(*args):
+  return _selinux.string_to_av_perm(*args)
 string_to_av_perm = _selinux.string_to_av_perm
+
+def security_av_string(*args):
+  return _selinux.security_av_string(*args)
 security_av_string = _selinux.security_av_string
-print_access_vector = _selinux.print_access_vector
 MATCHPATHCON_BASEONLY = _selinux.MATCHPATHCON_BASEONLY
 MATCHPATHCON_NOTRANS = _selinux.MATCHPATHCON_NOTRANS
 MATCHPATHCON_VALIDATE = _selinux.MATCHPATHCON_VALIDATE
-set_matchpathcon_flags = _selinux.set_matchpathcon_flags
+
+def matchpathcon_init(*args):
+  return _selinux.matchpathcon_init(*args)
 matchpathcon_init = _selinux.matchpathcon_init
+
+def matchpathcon_init_prefix(*args):
+  return _selinux.matchpathcon_init_prefix(*args)
 matchpathcon_init_prefix = _selinux.matchpathcon_init_prefix
-matchpathcon_fini = _selinux.matchpathcon_fini
+
+def matchpathcon(*args):
+  return _selinux.matchpathcon(*args)
 matchpathcon = _selinux.matchpathcon
+
+def matchpathcon_index(*args):
+  return _selinux.matchpathcon_index(*args)
 matchpathcon_index = _selinux.matchpathcon_index
+
+def matchpathcon_filespec_add(*args):
+  return _selinux.matchpathcon_filespec_add(*args)
 matchpathcon_filespec_add = _selinux.matchpathcon_filespec_add
-matchpathcon_filespec_destroy = _selinux.matchpathcon_filespec_destroy
-matchpathcon_filespec_eval = _selinux.matchpathcon_filespec_eval
-matchpathcon_checkmatches = _selinux.matchpathcon_checkmatches
+
+def matchmediacon(*args):
+  return _selinux.matchmediacon(*args)
 matchmediacon = _selinux.matchmediacon
+
+def selinux_getenforcemode():
+  return _selinux.selinux_getenforcemode()
 selinux_getenforcemode = _selinux.selinux_getenforcemode
+
+def selinux_getpolicytype():
+  return _selinux.selinux_getpolicytype()
 selinux_getpolicytype = _selinux.selinux_getpolicytype
+
+def selinux_policy_root():
+  return _selinux.selinux_policy_root()
 selinux_policy_root = _selinux.selinux_policy_root
+
+def selinux_binary_policy_path():
+  return _selinux.selinux_binary_policy_path()
 selinux_binary_policy_path = _selinux.selinux_binary_policy_path
+
+def selinux_failsafe_context_path():
+  return _selinux.selinux_failsafe_context_path()
 selinux_failsafe_context_path = _selinux.selinux_failsafe_context_path
+
+def selinux_removable_context_path():
+  return _selinux.selinux_removable_context_path()
 selinux_removable_context_path = _selinux.selinux_removable_context_path
+
+def selinux_default_context_path():
+  return _selinux.selinux_default_context_path()
 selinux_default_context_path = _selinux.selinux_default_context_path
+
+def selinux_user_contexts_path():
+  return _selinux.selinux_user_contexts_path()
 selinux_user_contexts_path = _selinux.selinux_user_contexts_path
+
+def selinux_file_context_path():
+  return _selinux.selinux_file_context_path()
 selinux_file_context_path = _selinux.selinux_file_context_path
+
+def selinux_file_context_homedir_path():
+  return _selinux.selinux_file_context_homedir_path()
 selinux_file_context_homedir_path = _selinux.selinux_file_context_homedir_path
+
+def selinux_file_context_local_path():
+  return _selinux.selinux_file_context_local_path()
 selinux_file_context_local_path = _selinux.selinux_file_context_local_path
+
+def selinux_file_context_subs_path():
+  return _selinux.selinux_file_context_subs_path()
+selinux_file_context_subs_path = _selinux.selinux_file_context_subs_path
+
+def selinux_homedir_context_path():
+  return _selinux.selinux_homedir_context_path()
 selinux_homedir_context_path = _selinux.selinux_homedir_context_path
+
+def selinux_media_context_path():
+  return _selinux.selinux_media_context_path()
 selinux_media_context_path = _selinux.selinux_media_context_path
+
+def selinux_virtual_domain_context_path():
+  return _selinux.selinux_virtual_domain_context_path()
+selinux_virtual_domain_context_path = _selinux.selinux_virtual_domain_context_path
+
+def selinux_virtual_image_context_path():
+  return _selinux.selinux_virtual_image_context_path()
+selinux_virtual_image_context_path = _selinux.selinux_virtual_image_context_path
+
+def selinux_x_context_path():
+  return _selinux.selinux_x_context_path()
 selinux_x_context_path = _selinux.selinux_x_context_path
+
+def selinux_contexts_path():
+  return _selinux.selinux_contexts_path()
 selinux_contexts_path = _selinux.selinux_contexts_path
+
+def selinux_securetty_types_path():
+  return _selinux.selinux_securetty_types_path()
 selinux_securetty_types_path = _selinux.selinux_securetty_types_path
+
+def selinux_booleans_path():
+  return _selinux.selinux_booleans_path()
 selinux_booleans_path = _selinux.selinux_booleans_path
+
+def selinux_customizable_types_path():
+  return _selinux.selinux_customizable_types_path()
 selinux_customizable_types_path = _selinux.selinux_customizable_types_path
+
+def selinux_users_path():
+  return _selinux.selinux_users_path()
 selinux_users_path = _selinux.selinux_users_path
+
+def selinux_usersconf_path():
+  return _selinux.selinux_usersconf_path()
 selinux_usersconf_path = _selinux.selinux_usersconf_path
+
+def selinux_translations_path():
+  return _selinux.selinux_translations_path()
 selinux_translations_path = _selinux.selinux_translations_path
+
+def selinux_colors_path():
+  return _selinux.selinux_colors_path()
 selinux_colors_path = _selinux.selinux_colors_path
+
+def selinux_netfilter_context_path():
+  return _selinux.selinux_netfilter_context_path()
 selinux_netfilter_context_path = _selinux.selinux_netfilter_context_path
+
+def selinux_path():
+  return _selinux.selinux_path()
 selinux_path = _selinux.selinux_path
+
+def selinux_check_passwd_access(*args):
+  return _selinux.selinux_check_passwd_access(*args)
 selinux_check_passwd_access = _selinux.selinux_check_passwd_access
+
+def checkPasswdAccess(*args):
+  return _selinux.checkPasswdAccess(*args)
 checkPasswdAccess = _selinux.checkPasswdAccess
+
+def selinux_check_securetty_context(*args):
+  return _selinux.selinux_check_securetty_context(*args)
 selinux_check_securetty_context = _selinux.selinux_check_securetty_context
-set_selinuxmnt = _selinux.set_selinuxmnt
+
+def rpm_execcon(*args):
+  return _selinux.rpm_execcon(*args)
 rpm_execcon = _selinux.rpm_execcon
+
+def is_context_customizable(*args):
+  return _selinux.is_context_customizable(*args)
 is_context_customizable = _selinux.is_context_customizable
+
+def selinux_trans_to_raw_context(*args):
+  return _selinux.selinux_trans_to_raw_context(*args)
 selinux_trans_to_raw_context = _selinux.selinux_trans_to_raw_context
+
+def selinux_raw_to_trans_context(*args):
+  return _selinux.selinux_raw_to_trans_context(*args)
 selinux_raw_to_trans_context = _selinux.selinux_raw_to_trans_context
+
+def selinux_raw_context_to_color(*args):
+  return _selinux.selinux_raw_context_to_color(*args)
 selinux_raw_context_to_color = _selinux.selinux_raw_context_to_color
+
+def getseuserbyname(*args):
+  return _selinux.getseuserbyname(*args)
 getseuserbyname = _selinux.getseuserbyname
+
+def getseuser(*args):
+  return _selinux.getseuser(*args)
+getseuser = _selinux.getseuser
+
+def selinux_file_context_cmp(*args):
+  return _selinux.selinux_file_context_cmp(*args)
 selinux_file_context_cmp = _selinux.selinux_file_context_cmp
+
+def selinux_file_context_verify(*args):
+  return _selinux.selinux_file_context_verify(*args)
 selinux_file_context_verify = _selinux.selinux_file_context_verify
+
+def selinux_lsetfilecon_default(*args):
+  return _selinux.selinux_lsetfilecon_default(*args)
 selinux_lsetfilecon_default = _selinux.selinux_lsetfilecon_default
-class security_id(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, security_id, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, security_id, name)
-    __repr__ = _swig_repr
-    __swig_setmethods__["ctx"] = _selinux.security_id_ctx_set
-    __swig_getmethods__["ctx"] = _selinux.security_id_ctx_get
-    if _newclass:ctx = _swig_property(_selinux.security_id_ctx_get, _selinux.security_id_ctx_set)
-    __swig_setmethods__["refcnt"] = _selinux.security_id_refcnt_set
-    __swig_getmethods__["refcnt"] = _selinux.security_id_refcnt_get
-    if _newclass:refcnt = _swig_property(_selinux.security_id_refcnt_get, _selinux.security_id_refcnt_set)
-    def __init__(self, *args): 
-        this = _selinux.new_security_id(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _selinux.delete_security_id
-    __del__ = lambda self : None;
-security_id_swigregister = _selinux.security_id_swigregister
-security_id_swigregister(security_id)
 
+def avc_sid_to_context(*args):
+  return _selinux.avc_sid_to_context(*args)
 avc_sid_to_context = _selinux.avc_sid_to_context
+
+def avc_sid_to_context_raw(*args):
+  return _selinux.avc_sid_to_context_raw(*args)
 avc_sid_to_context_raw = _selinux.avc_sid_to_context_raw
-avc_context_to_sid = _selinux.avc_context_to_sid
-avc_context_to_sid_raw = _selinux.avc_context_to_sid_raw
-sidget = _selinux.sidget
-sidput = _selinux.sidput
-avc_get_initial_sid = _selinux.avc_get_initial_sid
-class avc_entry_ref(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, avc_entry_ref, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, avc_entry_ref, name)
-    __repr__ = _swig_repr
-    __swig_setmethods__["ae"] = _selinux.avc_entry_ref_ae_set
-    __swig_getmethods__["ae"] = _selinux.avc_entry_ref_ae_get
-    if _newclass:ae = _swig_property(_selinux.avc_entry_ref_ae_get, _selinux.avc_entry_ref_ae_set)
-    def __init__(self, *args): 
-        this = _selinux.new_avc_entry_ref(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _selinux.delete_avc_entry_ref
-    __del__ = lambda self : None;
-avc_entry_ref_swigregister = _selinux.avc_entry_ref_swigregister
-avc_entry_ref_swigregister(avc_entry_ref)
 
-class avc_memory_callback(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, avc_memory_callback, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, avc_memory_callback, name)
-    __repr__ = _swig_repr
-    __swig_setmethods__["func_malloc"] = _selinux.avc_memory_callback_func_malloc_set
-    __swig_getmethods__["func_malloc"] = _selinux.avc_memory_callback_func_malloc_get
-    if _newclass:func_malloc = _swig_property(_selinux.avc_memory_callback_func_malloc_get, _selinux.avc_memory_callback_func_malloc_set)
-    __swig_setmethods__["func_free"] = _selinux.avc_memory_callback_func_free_set
-    __swig_getmethods__["func_free"] = _selinux.avc_memory_callback_func_free_get
-    if _newclass:func_free = _swig_property(_selinux.avc_memory_callback_func_free_get, _selinux.avc_memory_callback_func_free_set)
-    def __init__(self, *args): 
-        this = _selinux.new_avc_memory_callback(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _selinux.delete_avc_memory_callback
-    __del__ = lambda self : None;
-avc_memory_callback_swigregister = _selinux.avc_memory_callback_swigregister
-avc_memory_callback_swigregister(avc_memory_callback)
+def avc_context_to_sid(*args):
+  return _selinux.avc_context_to_sid(*args)
+avc_context_to_sid = _selinux.avc_context_to_sid
 
-class avc_log_callback(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, avc_log_callback, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, avc_log_callback, name)
-    __repr__ = _swig_repr
-    __swig_setmethods__["func_log"] = _selinux.avc_log_callback_func_log_set
-    __swig_getmethods__["func_log"] = _selinux.avc_log_callback_func_log_get
-    if _newclass:func_log = _swig_property(_selinux.avc_log_callback_func_log_get, _selinux.avc_log_callback_func_log_set)
-    __swig_setmethods__["func_audit"] = _selinux.avc_log_callback_func_audit_set
-    __swig_getmethods__["func_audit"] = _selinux.avc_log_callback_func_audit_get
-    if _newclass:func_audit = _swig_property(_selinux.avc_log_callback_func_audit_get, _selinux.avc_log_callback_func_audit_set)
-    def __init__(self, *args): 
-        this = _selinux.new_avc_log_callback(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _selinux.delete_avc_log_callback
-    __del__ = lambda self : None;
-avc_log_callback_swigregister = _selinux.avc_log_callback_swigregister
-avc_log_callback_swigregister(avc_log_callback)
+def avc_context_to_sid_raw(*args):
+  return _selinux.avc_context_to_sid_raw(*args)
+avc_context_to_sid_raw = _selinux.avc_context_to_sid_raw
 
-class avc_thread_callback(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, avc_thread_callback, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, avc_thread_callback, name)
-    __repr__ = _swig_repr
-    __swig_setmethods__["func_create_thread"] = _selinux.avc_thread_callback_func_create_thread_set
-    __swig_getmethods__["func_create_thread"] = _selinux.avc_thread_callback_func_create_thread_get
-    if _newclass:func_create_thread = _swig_property(_selinux.avc_thread_callback_func_create_thread_get, _selinux.avc_thread_callback_func_create_thread_set)
-    __swig_setmethods__["func_stop_thread"] = _selinux.avc_thread_callback_func_stop_thread_set
-    __swig_getmethods__["func_stop_thread"] = _selinux.avc_thread_callback_func_stop_thread_get
-    if _newclass:func_stop_thread = _swig_property(_selinux.avc_thread_callback_func_stop_thread_get, _selinux.avc_thread_callback_func_stop_thread_set)
-    def __init__(self, *args): 
-        this = _selinux.new_avc_thread_callback(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _selinux.delete_avc_thread_callback
-    __del__ = lambda self : None;
-avc_thread_callback_swigregister = _selinux.avc_thread_callback_swigregister
-avc_thread_callback_swigregister(avc_thread_callback)
+def sidget(*args):
+  return _selinux.sidget(*args)
+sidget = _selinux.sidget
 
-class avc_lock_callback(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, avc_lock_callback, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, avc_lock_callback, name)
-    __repr__ = _swig_repr
-    __swig_setmethods__["func_alloc_lock"] = _selinux.avc_lock_callback_func_alloc_lock_set
-    __swig_getmethods__["func_alloc_lock"] = _selinux.avc_lock_callback_func_alloc_lock_get
-    if _newclass:func_alloc_lock = _swig_property(_selinux.avc_lock_callback_func_alloc_lock_get, _selinux.avc_lock_callback_func_alloc_lock_set)
-    __swig_setmethods__["func_get_lock"] = _selinux.avc_lock_callback_func_get_lock_set
-    __swig_getmethods__["func_get_lock"] = _selinux.avc_lock_callback_func_get_lock_get
-    if _newclass:func_get_lock = _swig_property(_selinux.avc_lock_callback_func_get_lock_get, _selinux.avc_lock_callback_func_get_lock_set)
-    __swig_setmethods__["func_release_lock"] = _selinux.avc_lock_callback_func_release_lock_set
-    __swig_getmethods__["func_release_lock"] = _selinux.avc_lock_callback_func_release_lock_get
-    if _newclass:func_release_lock = _swig_property(_selinux.avc_lock_callback_func_release_lock_get, _selinux.avc_lock_callback_func_release_lock_set)
-    __swig_setmethods__["func_free_lock"] = _selinux.avc_lock_callback_func_free_lock_set
-    __swig_getmethods__["func_free_lock"] = _selinux.avc_lock_callback_func_free_lock_get
-    if _newclass:func_free_lock = _swig_property(_selinux.avc_lock_callback_func_free_lock_get, _selinux.avc_lock_callback_func_free_lock_set)
-    def __init__(self, *args): 
-        this = _selinux.new_avc_lock_callback(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _selinux.delete_avc_lock_callback
-    __del__ = lambda self : None;
-avc_lock_callback_swigregister = _selinux.avc_lock_callback_swigregister
-avc_lock_callback_swigregister(avc_lock_callback)
+def sidput(*args):
+  return _selinux.sidput(*args)
+sidput = _selinux.sidput
 
+def avc_get_initial_sid(*args):
+  return _selinux.avc_get_initial_sid(*args)
+avc_get_initial_sid = _selinux.avc_get_initial_sid
 AVC_OPT_UNUSED = _selinux.AVC_OPT_UNUSED
 AVC_OPT_SETENFORCE = _selinux.AVC_OPT_SETENFORCE
+
+def avc_init(*args):
+  return _selinux.avc_init(*args)
 avc_init = _selinux.avc_init
+
+def avc_open(*args):
+  return _selinux.avc_open(*args)
 avc_open = _selinux.avc_open
-avc_cleanup = _selinux.avc_cleanup
+
+def avc_reset():
+  return _selinux.avc_reset()
 avc_reset = _selinux.avc_reset
-avc_destroy = _selinux.avc_destroy
+
+def avc_has_perm_noaudit(*args):
+  return _selinux.avc_has_perm_noaudit(*args)
 avc_has_perm_noaudit = _selinux.avc_has_perm_noaudit
+
+def avc_has_perm(*args):
+  return _selinux.avc_has_perm(*args)
 avc_has_perm = _selinux.avc_has_perm
-avc_audit = _selinux.avc_audit
+
+def avc_compute_create(*args):
+  return _selinux.avc_compute_create(*args)
 avc_compute_create = _selinux.avc_compute_create
+
+def avc_compute_member(*args):
+  return _selinux.avc_compute_member(*args)
 avc_compute_member = _selinux.avc_compute_member
 AVC_CALLBACK_GRANT = _selinux.AVC_CALLBACK_GRANT
 AVC_CALLBACK_TRY_REVOKE = _selinux.AVC_CALLBACK_TRY_REVOKE
@@ -473,57 +737,46 @@
 AVC_CALLBACK_AUDITDENY_ENABLE = _selinux.AVC_CALLBACK_AUDITDENY_ENABLE
 AVC_CALLBACK_AUDITDENY_DISABLE = _selinux.AVC_CALLBACK_AUDITDENY_DISABLE
 AVC_CACHE_STATS = _selinux.AVC_CACHE_STATS
-class avc_cache_stats(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, avc_cache_stats, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, avc_cache_stats, name)
-    __repr__ = _swig_repr
-    __swig_setmethods__["entry_lookups"] = _selinux.avc_cache_stats_entry_lookups_set
-    __swig_getmethods__["entry_lookups"] = _selinux.avc_cache_stats_entry_lookups_get
-    if _newclass:entry_lookups = _swig_property(_selinux.avc_cache_stats_entry_lookups_get, _selinux.avc_cache_stats_entry_lookups_set)
-    __swig_setmethods__["entry_hits"] = _selinux.avc_cache_stats_entry_hits_set
-    __swig_getmethods__["entry_hits"] = _selinux.avc_cache_stats_entry_hits_get
-    if _newclass:entry_hits = _swig_property(_selinux.avc_cache_stats_entry_hits_get, _selinux.avc_cache_stats_entry_hits_set)
-    __swig_setmethods__["entry_misses"] = _selinux.avc_cache_stats_entry_misses_set
-    __swig_getmethods__["entry_misses"] = _selinux.avc_cache_stats_entry_misses_get
-    if _newclass:entry_misses = _swig_property(_selinux.avc_cache_stats_entry_misses_get, _selinux.avc_cache_stats_entry_misses_set)
-    __swig_setmethods__["entry_discards"] = _selinux.avc_cache_stats_entry_discards_set
-    __swig_getmethods__["entry_discards"] = _selinux.avc_cache_stats_entry_discards_get
-    if _newclass:entry_discards = _swig_property(_selinux.avc_cache_stats_entry_discards_get, _selinux.avc_cache_stats_entry_discards_set)
-    __swig_setmethods__["cav_lookups"] = _selinux.avc_cache_stats_cav_lookups_set
-    __swig_getmethods__["cav_lookups"] = _selinux.avc_cache_stats_cav_lookups_get
-    if _newclass:cav_lookups = _swig_property(_selinux.avc_cache_stats_cav_lookups_get, _selinux.avc_cache_stats_cav_lookups_set)
-    __swig_setmethods__["cav_hits"] = _selinux.avc_cache_stats_cav_hits_set
-    __swig_getmethods__["cav_hits"] = _selinux.avc_cache_stats_cav_hits_get
-    if _newclass:cav_hits = _swig_property(_selinux.avc_cache_stats_cav_hits_get, _selinux.avc_cache_stats_cav_hits_set)
-    __swig_setmethods__["cav_probes"] = _selinux.avc_cache_stats_cav_probes_set
-    __swig_getmethods__["cav_probes"] = _selinux.avc_cache_stats_cav_probes_get
-    if _newclass:cav_probes = _swig_property(_selinux.avc_cache_stats_cav_probes_get, _selinux.avc_cache_stats_cav_probes_set)
-    __swig_setmethods__["cav_misses"] = _selinux.avc_cache_stats_cav_misses_set
-    __swig_getmethods__["cav_misses"] = _selinux.avc_cache_stats_cav_misses_get
-    if _newclass:cav_misses = _swig_property(_selinux.avc_cache_stats_cav_misses_get, _selinux.avc_cache_stats_cav_misses_set)
-    def __init__(self, *args): 
-        this = _selinux.new_avc_cache_stats(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _selinux.delete_avc_cache_stats
-    __del__ = lambda self : None;
-avc_cache_stats_swigregister = _selinux.avc_cache_stats_swigregister
-avc_cache_stats_swigregister(avc_cache_stats)
 
-avc_av_stats = _selinux.avc_av_stats
-avc_sid_stats = _selinux.avc_sid_stats
+def selinux_default_type_path():
+  return _selinux.selinux_default_type_path()
 selinux_default_type_path = _selinux.selinux_default_type_path
+
+def get_default_type(*args):
+  return _selinux.get_default_type(*args)
 get_default_type = _selinux.get_default_type
 SELINUX_DEFAULTUSER = _selinux.SELINUX_DEFAULTUSER
+
+def get_ordered_context_list(*args):
+  return _selinux.get_ordered_context_list(*args)
 get_ordered_context_list = _selinux.get_ordered_context_list
+
+def get_ordered_context_list_with_level(*args):
+  return _selinux.get_ordered_context_list_with_level(*args)
 get_ordered_context_list_with_level = _selinux.get_ordered_context_list_with_level
+
+def get_default_context(*args):
+  return _selinux.get_default_context(*args)
 get_default_context = _selinux.get_default_context
+
+def get_default_context_with_level(*args):
+  return _selinux.get_default_context_with_level(*args)
 get_default_context_with_level = _selinux.get_default_context_with_level
+
+def get_default_context_with_role(*args):
+  return _selinux.get_default_context_with_role(*args)
 get_default_context_with_role = _selinux.get_default_context_with_role
+
+def get_default_context_with_rolelevel(*args):
+  return _selinux.get_default_context_with_rolelevel(*args)
 get_default_context_with_rolelevel = _selinux.get_default_context_with_rolelevel
+
+def query_user_context():
+  return _selinux.query_user_context()
 query_user_context = _selinux.query_user_context
+
+def manual_user_enter_context(*args):
+  return _selinux.manual_user_enter_context(*args)
 manual_user_enter_context = _selinux.manual_user_enter_context
 
 
Binary files nsalibselinux/src/selinux.pyc and libselinux-2.0.79/src/selinux.pyc differ
diff --exclude-from=exclude -N -u -r nsalibselinux/src/selinuxswig.i libselinux-2.0.79/src/selinuxswig.i
--- nsalibselinux/src/selinuxswig.i	2009-03-12 08:48:48.000000000 -0400
+++ libselinux-2.0.79/src/selinuxswig.i	2009-03-27 11:40:39.000000000 -0400
@@ -47,8 +47,32 @@
 %ignore set_matchpathcon_printf;
 %ignore set_matchpathcon_invalidcon;
 %ignore set_matchpathcon_canoncon;
-
+%ignore set_selinuxmnt; 
+%ignore avc_entry_ref_init;
+%ignore avc_entry_ref;
+%ignore avc_memory_callback;
+%ignore avc_log_callback;
+%ignore avc_thread_callback;
+%ignore avc_lock_callback;
+%ignore avc_cache_stats;
+%ignore selinux_callback;
+%ignore selinux_get_callback;
+%ignore selinux_set_callback;
+%ignore print_access_vector;
+%ignore set_matchpathcon_flags;
+%ignore matchpathcon_fini;
+%ignore matchpathcon_filespec_destroy;
+%ignore matchpathcon_filespec_eval;
+%ignore matchpathcon_checkmatches;
 %ignore avc_add_callback;
+%ignore avc_sid_stats;
+%ignore avc_av_stats;
+%ignore avc_audit;
+%ignore avc_destroy;
+%ignore avc_cleanup;
+%ignore avc_computer_member;
+%ignore selinux_set_mapping;
+%ignore security_id;
 
 /* Ignore netlink stuff for now */
 %ignore avc_netlink_acquire_fd;
diff --exclude-from=exclude -N -u -r nsalibselinux/src/selinuxswig_python.i libselinux-2.0.79/src/selinuxswig_python.i
--- nsalibselinux/src/selinuxswig_python.i	2009-03-06 14:41:45.000000000 -0500
+++ libselinux-2.0.79/src/selinuxswig_python.i	2009-03-27 14:07:34.000000000 -0400
@@ -21,6 +21,15 @@
                              map(restorecon, [os.path.join(dirname, fname)
                                               for fname in fnames]), None)
 
+def copytree(src, dest):
+    """ An SELinux-friendly shutil.copytree method """
+    shutil.copytree(src, dest)
+    restorecon(dest, recursive=True)
+
+def install(src, dest):
+    """ An SELinux-friendly shutil.move method """
+    shutil.move(src, dest)
+    restorecon(dest, recursive=True)
 %}
 
 /* security_get_boolean_names() typemap */
@@ -150,4 +159,10 @@
 	free($1);
 }
 
+%include "selinuxswig_exception.i"
 %include "selinuxswig.i"
+
+
+
+
+
diff --exclude-from=exclude -N -u -r nsalibselinux/src/selinuxswig_wrap.c libselinux-2.0.79/src/selinuxswig_wrap.c
--- nsalibselinux/src/selinuxswig_wrap.c	2009-03-06 14:41:45.000000000 -0500
+++ libselinux-2.0.79/src/selinuxswig_wrap.c	2009-03-27 14:21:40.000000000 -0400
@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------------
  * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.3.35
+ * Version 1.3.38
  * 
  * This file is not intended to be easily readable and contains a number of 
  * coding conventions designed to improve portability and efficiency. Do not make
@@ -10,6 +10,7 @@
 
 #define SWIGPYTHON
 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
+
 /* -----------------------------------------------------------------------------
  *  This section contains generic SWIG labels for method/variable
  *  declarations/attributes, and other compiler dependent labels.
@@ -52,6 +53,12 @@
 # endif
 #endif
 
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif 
+#endif
+
 #ifndef SWIGUNUSEDPARM
 # ifdef __cplusplus
 #   define SWIGUNUSEDPARM(p)
@@ -120,7 +127,7 @@
 /* -----------------------------------------------------------------------------
  * swigrun.swg
  *
- * This file contains generic CAPI SWIG runtime support for pointer
+ * This file contains generic C API SWIG runtime support for pointer
  * type checking.
  * ----------------------------------------------------------------------------- */
 
@@ -139,11 +146,11 @@
 
 /*
   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
-  creating a static or dynamic library from the swig runtime code.
-  In 99.9% of the cases, swig just needs to declare them as 'static'.
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
   
-  But only do this if is strictly necessary, ie, if you have problems
-  with your compiler or so.
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
 */
 
 #ifndef SWIGRUNTIME
@@ -170,14 +177,14 @@
 /* 
    Flags/methods for returning states.
    
-   The swig conversion methods, as ConvertPtr, return and integer 
+   The SWIG conversion methods, as ConvertPtr, return and integer 
    that tells if the conversion was successful or not. And if not,
    an error code can be returned (see swigerrors.swg for the codes).
    
    Use the following macros/flags to set or process the returning
    states.
    
-   In old swig versions, you usually write code as:
+   In old versions of SWIG, code such as the following was usually written:
 
      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
        // success code
@@ -185,7 +192,7 @@
        //fail code
      }
 
-   Now you can be more explicit as:
+   Now you can be more explicit:
 
     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
     if (SWIG_IsOK(res)) {
@@ -194,7 +201,7 @@
       // fail code
     }
 
-   that seems to be the same, but now you can also do
+   which is the same really, but now you can also do
 
     Type *ptr;
     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
@@ -212,7 +219,7 @@
     
    I.e., now SWIG_ConvertPtr can return new objects and you can
    identify the case and take care of the deallocation. Of course that
-   requires also to SWIG_ConvertPtr to return new result values, as
+   also requires SWIG_ConvertPtr to return new result values, such as
 
       int SWIG_ConvertPtr(obj, ptr,...) {         
         if (<obj is ok>) {			       
@@ -230,7 +237,7 @@
 
    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
-   swig errors code.
+   SWIG errors code.
 
    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
    allows to return the 'cast rank', for example, if you have this
@@ -244,9 +251,8 @@
       fooi(1)   // cast rank '0'
 
    just use the SWIG_AddCast()/SWIG_CheckState()
+*/
 
-
- */
 #define SWIG_OK                    (0) 
 #define SWIG_ERROR                 (-1)
 #define SWIG_IsOK(r)               (r >= 0)
@@ -271,7 +277,6 @@
 #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
 #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
 
-
 /* Cast-Rank Mode */
 #if defined(SWIG_CASTRANK_MODE)
 #  ifndef SWIG_TypeRank
@@ -294,8 +299,6 @@
 #endif
 
 
-
-
 #include <string.h>
 
 #ifdef __cplusplus
@@ -392,40 +395,58 @@
 }
 
 
-/* think of this as a c++ template<> or a scheme macro */
-#define SWIG_TypeCheck_Template(comparison, ty)         \
-  if (ty) {                                             \
-    swig_cast_info *iter = ty->cast;                    \
-    while (iter) {                                      \
-      if (comparison) {                                 \
-        if (iter == ty->cast) return iter;              \
-        /* Move iter to the top of the linked list */   \
-        iter->prev->next = iter->next;                  \
-        if (iter->next)                                 \
-          iter->next->prev = iter->prev;                \
-        iter->next = ty->cast;                          \
-        iter->prev = 0;                                 \
-        if (ty->cast) ty->cast->prev = iter;            \
-        ty->cast = iter;                                \
-        return iter;                                    \
-      }                                                 \
-      iter = iter->next;                                \
-    }                                                   \
-  }                                                     \
-  return 0
-
 /*
   Check the typename
 */
 SWIGRUNTIME swig_cast_info *
 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
-  SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
 }
 
-/* Same as previous function, except strcmp is replaced with a pointer comparison */
+/* 
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
 SWIGRUNTIME swig_cast_info *
-SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
-  SWIG_TypeCheck_Template(iter->type == from, into);
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
 }
 
 /*
@@ -704,6 +725,49 @@
 
 
 
+/* Compatibility marcos for Python 3 */
+#if PY_VERSION_HEX >= 0x03000000
+
+#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
+#define PyInt_Check(x) PyLong_Check(x)
+#define PyInt_AsLong(x) PyLong_AsLong(x)
+#define PyInt_FromLong(x) PyLong_FromLong(x)
+#define PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)
+
+#endif
+
+#ifndef Py_TYPE
+#  define Py_TYPE(op) ((op)->ob_type)
+#endif
+
+/* SWIG APIs for compatibility of both Python 2 & 3 */
+
+#if PY_VERSION_HEX >= 0x03000000
+#  define SWIG_Python_str_FromFormat PyUnicode_FromFormat
+#else
+#  define SWIG_Python_str_FromFormat PyString_FromFormat
+#endif
+
+SWIGINTERN char*
+SWIG_Python_str_AsChar(PyObject *str)
+{
+#if PY_VERSION_HEX >= 0x03000000
+  str = PyUnicode_AsUTF8String(str);
+  return PyBytes_AsString(str);
+#else
+  return PyString_AsString(str);
+#endif
+}
+
+SWIGINTERN PyObject*
+SWIG_Python_str_FromChar(const char *c)
+{
+#if PY_VERSION_HEX >= 0x03000000
+  return PyUnicode_FromString(c); 
+#else
+  return PyString_FromString(c);
+#endif
+}
 
 /* Add PyOS_snprintf for old Pythons */
 #if PY_VERSION_HEX < 0x02020000
@@ -750,6 +814,7 @@
 #  define PyObject_GenericGetAttr 0
 # endif
 #endif
+
 /* Py_NotImplemented is defined in 2.1 and up. */
 #if PY_VERSION_HEX < 0x02010000
 # ifndef Py_NotImplemented
@@ -757,7 +822,6 @@
 # endif
 #endif
 
-
 /* A crude PyString_AsStringAndSize implementation for old Pythons */
 #if PY_VERSION_HEX < 0x02010000
 # ifndef PyString_AsStringAndSize
@@ -772,7 +836,6 @@
 # endif
 #endif
 
-
 /* PyBool_FromLong for old Pythons */
 #if PY_VERSION_HEX < 0x02030000
 static
@@ -853,7 +916,8 @@
     PyObject *old_str = PyObject_Str(value);
     PyErr_Clear();
     Py_XINCREF(type);
-    PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
+
+    PyErr_Format(type, "%s %s", SWIG_Python_str_AsChar(old_str), mesg);
     Py_DECREF(old_str);
     Py_DECREF(value);
   } else {
@@ -861,8 +925,6 @@
   }
 }
 
-
-
 #if defined(SWIG_PYTHON_NO_THREADS)
 #  if defined(SWIG_PYTHON_THREADS)
 #    undef SWIG_PYTHON_THREADS
@@ -959,6 +1021,20 @@
   swig_type_info **ptype;
 } swig_const_info;
 
+
+/* -----------------------------------------------------------------------------
+ * Wrapper of PyInstanceMethod_New() used in Python 3
+ * It is exported to the generated module, used for -fastproxy
+ * ----------------------------------------------------------------------------- */
+SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *self, PyObject *func)
+{
+#if PY_VERSION_HEX >= 0x03000000
+  return PyInstanceMethod_New(func);
+#else
+  return NULL;
+#endif
+}
+
 #ifdef __cplusplus
 #if 0
 { /* cc-mode */
@@ -1011,7 +1087,7 @@
 
 #define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule()
 #define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
-#define SWIG_NewClientData(obj)                         PySwigClientData_New(obj)
+#define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)
 
 #define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
 #define SWIG_SetErrorMsg                        	SWIG_Python_SetErrorMsg				   
@@ -1207,7 +1283,7 @@
   return none;
 }
 
-/* PySwigClientData */
+/* SwigPyClientData */
 
 typedef struct {
   PyObject *klass;
@@ -1216,30 +1292,30 @@
   PyObject *destroy;
   int delargs;
   int implicitconv;
-} PySwigClientData;
+} SwigPyClientData;
 
 SWIGRUNTIMEINLINE int 
 SWIG_Python_CheckImplicit(swig_type_info *ty)
 {
-  PySwigClientData *data = (PySwigClientData *)ty->clientdata;
+  SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
   return data ? data->implicitconv : 0;
 }
 
 SWIGRUNTIMEINLINE PyObject *
 SWIG_Python_ExceptionType(swig_type_info *desc) {
-  PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
+  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
   PyObject *klass = data ? data->klass : 0;
   return (klass ? klass : PyExc_RuntimeError);
 }
 
 
-SWIGRUNTIME PySwigClientData * 
-PySwigClientData_New(PyObject* obj)
+SWIGRUNTIME SwigPyClientData * 
+SwigPyClientData_New(PyObject* obj)
 {
   if (!obj) {
     return 0;
   } else {
-    PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
+    SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
     /* the klass element */
     data->klass = obj;
     Py_INCREF(data->klass);
@@ -1287,14 +1363,14 @@
 }
 
 SWIGRUNTIME void 
-PySwigClientData_Del(PySwigClientData* data)
+SwigPyClientData_Del(SwigPyClientData* data)
 {
   Py_XDECREF(data->newraw);
   Py_XDECREF(data->newargs);
   Py_XDECREF(data->destroy);
 }
 
-/* =============== PySwigObject =====================*/
+/* =============== SwigPyObject =====================*/
 
 typedef struct {
   PyObject_HEAD
@@ -1302,24 +1378,28 @@
   swig_type_info *ty;
   int own;
   PyObject *next;
-} PySwigObject;
+} SwigPyObject;
 
 SWIGRUNTIME PyObject *
-PySwigObject_long(PySwigObject *v)
+SwigPyObject_long(SwigPyObject *v)
 {
   return PyLong_FromVoidPtr(v->ptr);
 }
 
 SWIGRUNTIME PyObject *
-PySwigObject_format(const char* fmt, PySwigObject *v)
+SwigPyObject_format(const char* fmt, SwigPyObject *v)
 {
   PyObject *res = NULL;
   PyObject *args = PyTuple_New(1);
   if (args) {
-    if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
-      PyObject *ofmt = PyString_FromString(fmt);
+    if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
+      PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
       if (ofmt) {
+#if PY_VERSION_HEX >= 0x03000000
+	res = PyUnicode_Format(ofmt,args);
+#else
 	res = PyString_Format(ofmt,args);
+#endif
 	Py_DECREF(ofmt);
       }
       Py_DECREF(args);
@@ -1329,49 +1409,56 @@
 }
 
 SWIGRUNTIME PyObject *
-PySwigObject_oct(PySwigObject *v)
+SwigPyObject_oct(SwigPyObject *v)
 {
-  return PySwigObject_format("%o",v);
+  return SwigPyObject_format("%o",v);
 }
 
 SWIGRUNTIME PyObject *
-PySwigObject_hex(PySwigObject *v)
+SwigPyObject_hex(SwigPyObject *v)
 {
-  return PySwigObject_format("%x",v);
+  return SwigPyObject_format("%x",v);
 }
 
 SWIGRUNTIME PyObject *
 #ifdef METH_NOARGS
-PySwigObject_repr(PySwigObject *v)
+SwigPyObject_repr(SwigPyObject *v)
 #else
-PySwigObject_repr(PySwigObject *v, PyObject *args)
+SwigPyObject_repr(SwigPyObject *v, PyObject *args)
 #endif
 {
   const char *name = SWIG_TypePrettyName(v->ty);
-  PyObject *hex = PySwigObject_hex(v);    
-  PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
+  PyObject *hex = SwigPyObject_hex(v);    
+  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", name, hex);
   Py_DECREF(hex);
   if (v->next) {
 #ifdef METH_NOARGS
-    PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
+    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
 #else
-    PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
+    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
 #endif
+#if PY_VERSION_HEX >= 0x03000000
+    PyObject *joined = PyUnicode_Concat(repr, nrep);
+    Py_DecRef(repr);
+    Py_DecRef(nrep);
+    repr = joined;
+#else
     PyString_ConcatAndDel(&repr,nrep);
+#endif
   }
   return repr;  
 }
 
 SWIGRUNTIME int
-PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
+SwigPyObject_print(SwigPyObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
 {
 #ifdef METH_NOARGS
-  PyObject *repr = PySwigObject_repr(v);
+  PyObject *repr = SwigPyObject_repr(v);
 #else
-  PyObject *repr = PySwigObject_repr(v, NULL);
+  PyObject *repr = SwigPyObject_repr(v, NULL);
 #endif
   if (repr) {
-    fputs(PyString_AsString(repr), fp);
+    fputs(SWIG_Python_str_AsChar(repr), fp);
     Py_DECREF(repr);
     return 0; 
   } else {
@@ -1380,53 +1467,71 @@
 }
 
 SWIGRUNTIME PyObject *
-PySwigObject_str(PySwigObject *v)
+SwigPyObject_str(SwigPyObject *v)
 {
   char result[SWIG_BUFFER_SIZE];
   return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
-    PyString_FromString(result) : 0;
+    SWIG_Python_str_FromChar(result) : 0;
 }
 
 SWIGRUNTIME int
-PySwigObject_compare(PySwigObject *v, PySwigObject *w)
+SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
 {
   void *i = v->ptr;
   void *j = w->ptr;
   return (i < j) ? -1 : ((i > j) ? 1 : 0);
 }
 
+/* Added for Python 3.x, whould it also useful for Python 2.x? */
+SWIGRUNTIME PyObject*
+SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
+{
+  PyObject* res;
+  if( op != Py_EQ && op != Py_NE ) {
+    Py_INCREF(Py_NotImplemented);
+    return Py_NotImplemented;
+  }
+  if( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) )
+    res = Py_True;
+  else
+    res = Py_False;
+  Py_INCREF(res);
+  return res;  
+}
+
+
 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
 
 SWIGRUNTIME PyTypeObject*
-PySwigObject_type(void) {
+SwigPyObject_type(void) {
   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
   return type;
 }
 
 SWIGRUNTIMEINLINE int
-PySwigObject_Check(PyObject *op) {
-  return ((op)->ob_type == PySwigObject_type())
-    || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
+SwigPyObject_Check(PyObject *op) {
+  return (Py_TYPE(op) == SwigPyObject_type())
+    || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
 }
 
 SWIGRUNTIME PyObject *
-PySwigObject_New(void *ptr, swig_type_info *ty, int own);
+SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
 
 SWIGRUNTIME void
-PySwigObject_dealloc(PyObject *v)
+SwigPyObject_dealloc(PyObject *v)
 {
-  PySwigObject *sobj = (PySwigObject *) v;
+  SwigPyObject *sobj = (SwigPyObject *) v;
   PyObject *next = sobj->next;
   if (sobj->own == SWIG_POINTER_OWN) {
     swig_type_info *ty = sobj->ty;
-    PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
+    SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
     PyObject *destroy = data ? data->destroy : 0;
     if (destroy) {
       /* destroy is always a VARARGS method */
       PyObject *res;
       if (data->delargs) {
 	/* we need to create a temporal object to carry the destroy operation */
-	PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
+	PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
 	res = SWIG_Python_CallFunctor(destroy, tmp);
 	Py_DECREF(tmp);
       } else {
@@ -1448,15 +1553,15 @@
 }
 
 SWIGRUNTIME PyObject* 
-PySwigObject_append(PyObject* v, PyObject* next)
+SwigPyObject_append(PyObject* v, PyObject* next)
 {
-  PySwigObject *sobj = (PySwigObject *) v;
+  SwigPyObject *sobj = (SwigPyObject *) v;
 #ifndef METH_O
   PyObject *tmp = 0;
   if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
   next = tmp;
 #endif
-  if (!PySwigObject_Check(next)) {
+  if (!SwigPyObject_Check(next)) {
     return NULL;
   }
   sobj->next = next;
@@ -1466,12 +1571,12 @@
 
 SWIGRUNTIME PyObject* 
 #ifdef METH_NOARGS
-PySwigObject_next(PyObject* v)
+SwigPyObject_next(PyObject* v)
 #else
-PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
+SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
 #endif
 {
-  PySwigObject *sobj = (PySwigObject *) v;
+  SwigPyObject *sobj = (SwigPyObject *) v;
   if (sobj->next) {    
     Py_INCREF(sobj->next);
     return sobj->next;
@@ -1482,30 +1587,30 @@
 
 SWIGINTERN PyObject*
 #ifdef METH_NOARGS
-PySwigObject_disown(PyObject *v)
+SwigPyObject_disown(PyObject *v)
 #else
-PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
+SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
 #endif
 {
-  PySwigObject *sobj = (PySwigObject *)v;
+  SwigPyObject *sobj = (SwigPyObject *)v;
   sobj->own = 0;
   return SWIG_Py_Void();
 }
 
 SWIGINTERN PyObject*
 #ifdef METH_NOARGS
-PySwigObject_acquire(PyObject *v)
+SwigPyObject_acquire(PyObject *v)
 #else
-PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
+SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
 #endif
 {
-  PySwigObject *sobj = (PySwigObject *)v;
+  SwigPyObject *sobj = (SwigPyObject *)v;
   sobj->own = SWIG_POINTER_OWN;
   return SWIG_Py_Void();
 }
 
 SWIGINTERN PyObject*
-PySwigObject_own(PyObject *v, PyObject *args)
+SwigPyObject_own(PyObject *v, PyObject *args)
 {
   PyObject *val = 0;
 #if (PY_VERSION_HEX < 0x02020000)
@@ -1518,20 +1623,20 @@
     } 
   else
     {
-      PySwigObject *sobj = (PySwigObject *)v;
+      SwigPyObject *sobj = (SwigPyObject *)v;
       PyObject *obj = PyBool_FromLong(sobj->own);
       if (val) {
 #ifdef METH_NOARGS
 	if (PyObject_IsTrue(val)) {
-	  PySwigObject_acquire(v);
+	  SwigPyObject_acquire(v);
 	} else {
-	  PySwigObject_disown(v);
+	  SwigPyObject_disown(v);
 	}
 #else
 	if (PyObject_IsTrue(val)) {
-	  PySwigObject_acquire(v,args);
+	  SwigPyObject_acquire(v,args);
 	} else {
-	  PySwigObject_disown(v,args);
+	  SwigPyObject_disown(v,args);
 	}
 #endif
       } 
@@ -1542,30 +1647,30 @@
 #ifdef METH_O
 static PyMethodDef
 swigobject_methods[] = {
-  {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
-  {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
-  {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
-  {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_O,       (char *)"appends another 'this' object"},
-  {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
-  {(char *)"__repr__",(PyCFunction)PySwigObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
+  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
+  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
+  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
+  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)"appends another 'this' object"},
+  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
+  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
   {0, 0, 0, 0}  
 };
 #else
 static PyMethodDef
 swigobject_methods[] = {
-  {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
-  {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
-  {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
-  {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
-  {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
-  {(char *)"__repr__",(PyCFunction)PySwigObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
+  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
+  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
+  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
+  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
+  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
+  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
   {0, 0, 0, 0}  
 };
 #endif
 
 #if PY_VERSION_HEX < 0x02020000
 SWIGINTERN PyObject *
-PySwigObject_getattr(PySwigObject *sobj,char *name)
+SwigPyObject_getattr(SwigPyObject *sobj,char *name)
 {
   return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
 }
@@ -1575,11 +1680,14 @@
 _PySwigObject_type(void) {
   static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
   
-  static PyNumberMethods PySwigObject_as_number = {
+  static PyNumberMethods SwigPyObject_as_number = {
     (binaryfunc)0, /*nb_add*/
     (binaryfunc)0, /*nb_subtract*/
     (binaryfunc)0, /*nb_multiply*/
+    /* nb_divide removed in Python 3 */
+#if PY_VERSION_HEX < 0x03000000
     (binaryfunc)0, /*nb_divide*/
+#endif
     (binaryfunc)0, /*nb_remainder*/
     (binaryfunc)0, /*nb_divmod*/
     (ternaryfunc)0,/*nb_power*/
@@ -1593,13 +1701,19 @@
     0,		   /*nb_and*/
     0,		   /*nb_xor*/
     0,		   /*nb_or*/
-    (coercion)0,   /*nb_coerce*/
-    (unaryfunc)PySwigObject_long, /*nb_int*/
-    (unaryfunc)PySwigObject_long, /*nb_long*/
+#if PY_VERSION_HEX < 0x03000000
+    0,   /*nb_coerce*/
+#endif
+    (unaryfunc)SwigPyObject_long, /*nb_int*/
+    (unaryfunc)SwigPyObject_long, /*nb_long*/
     (unaryfunc)0,                 /*nb_float*/
-    (unaryfunc)PySwigObject_oct,  /*nb_oct*/
-    (unaryfunc)PySwigObject_hex,  /*nb_hex*/
-#if PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
+#if PY_VERSION_HEX < 0x03000000
+    (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
+    (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
+#endif
+#if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
+#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
@@ -1608,32 +1722,37 @@
 #endif
   };
 
-  static PyTypeObject pyswigobject_type;  
+  static PyTypeObject swigpyobject_type;  
   static int type_init = 0;
   if (!type_init) {
     const PyTypeObject tmp
       = {
+	/* PyOjbect header changed in Python 3 */
+#if PY_VERSION_HEX >= 0x03000000
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
+#else    
 	PyObject_HEAD_INIT(NULL)
 	0,				    /* ob_size */
-	(char *)"PySwigObject",		    /* tp_name */
-	sizeof(PySwigObject),		    /* tp_basicsize */
+#endif
+	(char *)"SwigPyObject",		    /* tp_name */
+	sizeof(SwigPyObject),		    /* tp_basicsize */
 	0,			            /* tp_itemsize */
-	(destructor)PySwigObject_dealloc,   /* tp_dealloc */
-	(printfunc)PySwigObject_print,	    /* tp_print */
+	(destructor)SwigPyObject_dealloc,   /* tp_dealloc */
+	(printfunc)SwigPyObject_print,	    /* tp_print */
 #if PY_VERSION_HEX < 0x02020000
-	(getattrfunc)PySwigObject_getattr,  /* tp_getattr */ 
+	(getattrfunc)SwigPyObject_getattr,  /* tp_getattr */ 
 #else
 	(getattrfunc)0,			    /* tp_getattr */ 
 #endif
 	(setattrfunc)0,			    /* tp_setattr */ 
-	(cmpfunc)PySwigObject_compare,	    /* tp_compare */ 
-	(reprfunc)PySwigObject_repr,	    /* tp_repr */    
-	&PySwigObject_as_number,	    /* tp_as_number */
+	(cmpfunc)SwigPyObject_compare,	    /* tp_compare */ 
+	(reprfunc)SwigPyObject_repr,	    /* tp_repr */    
+	&SwigPyObject_as_number,	    /* tp_as_number */
 	0,				    /* tp_as_sequence */
 	0,				    /* tp_as_mapping */
 	(hashfunc)0,			    /* tp_hash */
 	(ternaryfunc)0,			    /* tp_call */
-	(reprfunc)PySwigObject_str,	    /* tp_str */
+	(reprfunc)SwigPyObject_str,	    /* tp_str */
 	PyObject_GenericGetAttr,            /* tp_getattro */
 	0,				    /* tp_setattro */
 	0,		                    /* tp_as_buffer */
@@ -1641,7 +1760,7 @@
 	swigobject_doc, 	            /* tp_doc */        
 	0,                                  /* tp_traverse */
 	0,                                  /* tp_clear */
-	0,                                  /* tp_richcompare */
+	(richcmpfunc)SwigPyObject_richcompare,           /* tp_richcompare */
 	0,                                  /* tp_weaklistoffset */
 #if PY_VERSION_HEX >= 0x02020000
 	0,                                  /* tp_iter */
@@ -1658,11 +1777,11 @@
 	0,				    /* tp_alloc */	    	
 	0,			            /* tp_new */	    	
 	0,	                            /* tp_free */	   
-        0,                                  /* tp_is_gc */  
+	0,                                  /* tp_is_gc */  
 	0,				    /* tp_bases */   
 	0,				    /* tp_mro */
 	0,				    /* tp_cache */   
- 	0,				    /* tp_subclasses */
+	0,				    /* tp_subclasses */
 	0,				    /* tp_weaklist */
 #endif
 #if PY_VERSION_HEX >= 0x02030000
@@ -1672,17 +1791,20 @@
 	0,0,0,0                             /* tp_alloc -> tp_next */
 #endif
       };
-    pyswigobject_type = tmp;
-    pyswigobject_type.ob_type = &PyType_Type;
+    swigpyobject_type = tmp;
+    /* for Python 3 we already assigned the ob_type in PyVarObject_HEAD_INIT() */
+#if PY_VERSION_HEX < 0x03000000
+    swigpyobject_type.ob_type = &PyType_Type;
+#endif
     type_init = 1;
   }
-  return &pyswigobject_type;
+  return &swigpyobject_type;
 }
 
 SWIGRUNTIME PyObject *
-PySwigObject_New(void *ptr, swig_type_info *ty, int own)
+SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
 {
-  PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
+  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
   if (sobj) {
     sobj->ptr  = ptr;
     sobj->ty   = ty;
@@ -1701,10 +1823,10 @@
   void *pack;
   swig_type_info *ty;
   size_t size;
-} PySwigPacked;
+} SwigPyPacked;
 
 SWIGRUNTIME int
-PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
+SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
 {
   char result[SWIG_BUFFER_SIZE];
   fputs("<Swig Packed ", fp); 
@@ -1718,29 +1840,29 @@
 }
   
 SWIGRUNTIME PyObject *
-PySwigPacked_repr(PySwigPacked *v)
+SwigPyPacked_repr(SwigPyPacked *v)
 {
   char result[SWIG_BUFFER_SIZE];
   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
-    return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
+    return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
   } else {
-    return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
+    return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
   }  
 }
 
 SWIGRUNTIME PyObject *
-PySwigPacked_str(PySwigPacked *v)
+SwigPyPacked_str(SwigPyPacked *v)
 {
   char result[SWIG_BUFFER_SIZE];
   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
-    return PyString_FromFormat("%s%s", result, v->ty->name);
+    return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
   } else {
-    return PyString_FromString(v->ty->name);
+    return SWIG_Python_str_FromChar(v->ty->name);
   }  
 }
 
 SWIGRUNTIME int
-PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
+SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
 {
   size_t i = v->size;
   size_t j = w->size;
@@ -1751,22 +1873,22 @@
 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
 
 SWIGRUNTIME PyTypeObject*
-PySwigPacked_type(void) {
+SwigPyPacked_type(void) {
   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
   return type;
 }
 
 SWIGRUNTIMEINLINE int
-PySwigPacked_Check(PyObject *op) {
+SwigPyPacked_Check(PyObject *op) {
   return ((op)->ob_type == _PySwigPacked_type()) 
-    || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
+    || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
 }
 
 SWIGRUNTIME void
-PySwigPacked_dealloc(PyObject *v)
+SwigPyPacked_dealloc(PyObject *v)
 {
-  if (PySwigPacked_Check(v)) {
-    PySwigPacked *sobj = (PySwigPacked *) v;
+  if (SwigPyPacked_Check(v)) {
+    SwigPyPacked *sobj = (SwigPyPacked *) v;
     free(sobj->pack);
   }
   PyObject_DEL(v);
@@ -1775,28 +1897,33 @@
 SWIGRUNTIME PyTypeObject*
 _PySwigPacked_type(void) {
   static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
-  static PyTypeObject pyswigpacked_type;
+  static PyTypeObject swigpypacked_type;
   static int type_init = 0;  
   if (!type_init) {
     const PyTypeObject tmp
       = {
+    /* PyObject header changed in Python 3 */
+#if PY_VERSION_HEX>=0x03000000
+    PyVarObject_HEAD_INIT(&PyType_Type, 0)
+#else
 	PyObject_HEAD_INIT(NULL)
-	0,				    /* ob_size */	
-	(char *)"PySwigPacked",		    /* tp_name */	
-	sizeof(PySwigPacked),		    /* tp_basicsize */	
+    0,				    /* ob_size */	
+#endif
+	(char *)"SwigPyPacked",		    /* tp_name */	
+	sizeof(SwigPyPacked),		    /* tp_basicsize */	
 	0,				    /* tp_itemsize */	
-	(destructor)PySwigPacked_dealloc,   /* tp_dealloc */	
-	(printfunc)PySwigPacked_print,	    /* tp_print */   	
+	(destructor)SwigPyPacked_dealloc,   /* tp_dealloc */	
+	(printfunc)SwigPyPacked_print,	    /* tp_print */   	
 	(getattrfunc)0,			    /* tp_getattr */ 	
 	(setattrfunc)0,			    /* tp_setattr */ 	
-	(cmpfunc)PySwigPacked_compare,	    /* tp_compare */ 	
-	(reprfunc)PySwigPacked_repr,	    /* tp_repr */    	
+	(cmpfunc)SwigPyPacked_compare,	    /* tp_compare */ 	
+	(reprfunc)SwigPyPacked_repr,	    /* tp_repr */    	
 	0,	                            /* tp_as_number */	
 	0,				    /* tp_as_sequence */
 	0,				    /* tp_as_mapping */	
 	(hashfunc)0,			    /* tp_hash */	
 	(ternaryfunc)0,			    /* tp_call */	
-	(reprfunc)PySwigPacked_str,	    /* tp_str */	
+	(reprfunc)SwigPyPacked_str,	    /* tp_str */	
 	PyObject_GenericGetAttr,            /* tp_getattro */
 	0,				    /* tp_setattro */
 	0,		                    /* tp_as_buffer */
@@ -1835,17 +1962,20 @@
 	0,0,0,0                             /* tp_alloc -> tp_next */
 #endif
       };
-    pyswigpacked_type = tmp;
-    pyswigpacked_type.ob_type = &PyType_Type;
+    swigpypacked_type = tmp;
+    /* for Python 3 the ob_type already assigned in PyVarObject_HEAD_INIT() */
+#if PY_VERSION_HEX < 0x03000000
+    swigpypacked_type.ob_type = &PyType_Type;
+#endif
     type_init = 1;
   }
-  return &pyswigpacked_type;
+  return &swigpypacked_type;
 }
 
 SWIGRUNTIME PyObject *
-PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
+SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
 {
-  PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
+  SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
   if (sobj) {
     void *pack = malloc(size);
     if (pack) {
@@ -1862,10 +1992,10 @@
 }
 
 SWIGRUNTIME swig_type_info *
-PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
+SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
 {
-  if (PySwigPacked_Check(obj)) {
-    PySwigPacked *sobj = (PySwigPacked *)obj;
+  if (SwigPyPacked_Check(obj)) {
+    SwigPyPacked *sobj = (SwigPyPacked *)obj;
     if (sobj->size != size) return 0;
     memcpy(ptr, sobj->pack, size);
     return sobj->ty;
@@ -1881,7 +2011,7 @@
 SWIGRUNTIMEINLINE PyObject *
 _SWIG_This(void)
 {
-  return PyString_FromString("this");
+    return SWIG_Python_str_FromChar("this");
 }
 
 SWIGRUNTIME PyObject *
@@ -1893,11 +2023,16 @@
 
 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
 
-SWIGRUNTIME PySwigObject *
+/* TODO: I don't know how to implement the fast getset in Python 3 right now */
+#if PY_VERSION_HEX>=0x03000000
+#define SWIG_PYTHON_SLOW_GETSET_THIS 
+#endif
+
+SWIGRUNTIME SwigPyObject *
 SWIG_Python_GetSwigThis(PyObject *pyobj) 
 {
-  if (PySwigObject_Check(pyobj)) {
-    return (PySwigObject *) pyobj;
+  if (SwigPyObject_Check(pyobj)) {
+    return (SwigPyObject *) pyobj;
   } else {
     PyObject *obj = 0;
 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
@@ -1933,12 +2068,12 @@
       return 0;
     }
 #endif
-    if (obj && !PySwigObject_Check(obj)) {
+    if (obj && !SwigPyObject_Check(obj)) {
       /* a PyObject is called 'this', try to get the 'real this'
-	 PySwigObject from it */ 
+	 SwigPyObject from it */ 
       return SWIG_Python_GetSwigThis(obj);
     }
-    return (PySwigObject *)obj;
+    return (SwigPyObject *)obj;
   }
 }
 
@@ -1947,7 +2082,7 @@
 SWIGRUNTIME int
 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
   if (own == SWIG_POINTER_OWN) {
-    PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
+    SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
     if (sobj) {
       int oldown = sobj->own;
       sobj->own = own;
@@ -1966,7 +2101,7 @@
     if (ptr) *ptr = 0;
     return SWIG_OK;
   } else {
-    PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
+    SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
     if (own)
       *own = 0;
     while (sobj) {
@@ -1980,7 +2115,7 @@
 	} else {
 	  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
 	  if (!tc) {
-	    sobj = (PySwigObject *)sobj->next;
+	    sobj = (SwigPyObject *)sobj->next;
 	  } else {
 	    if (ptr) {
               int newmemory = 0;
@@ -2009,7 +2144,7 @@
     } else {
       int res = SWIG_ERROR;
       if (flags & SWIG_POINTER_IMPLICIT_CONV) {
-	PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
+	SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
 	if (data && !data->implicitconv) {
 	  PyObject *klass = data->klass;
 	  if (klass) {
@@ -2022,7 +2157,7 @@
 	      impconv = 0;
 	    }
 	    if (impconv) {
-	      PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
+	      SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
 	      if (iobj) {
 		void *vptr;
 		res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
@@ -2084,7 +2219,7 @@
 
 SWIGRUNTIME int
 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
-  swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
+  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
   if (!to) return SWIG_ERROR;
   if (ty) {
     if (to != ty) {
@@ -2106,7 +2241,7 @@
 */
 
 SWIGRUNTIME PyObject* 
-SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
+SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
 {
 #if (PY_VERSION_HEX >= 0x02020000)
   PyObject *inst = 0;
@@ -2130,10 +2265,17 @@
 #endif
     }
   } else {
+#if PY_VERSION_HEX >= 0x03000000
+    inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
+    Py_INCREF(data->newargs);
+    PyObject_SetAttr(inst, SWIG_This(), swig_this);
+    Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
+#else
     PyObject *dict = PyDict_New();
     PyDict_SetItem(dict, SWIG_This(), swig_this);
     inst = PyInstance_NewRaw(data->newargs, dict);
     Py_DECREF(dict);
+#endif
   }
   return inst;
 #else
@@ -2196,9 +2338,9 @@
   if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
     return NULL;
   } else {
-    PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
+    SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
     if (sthis) {
-      PySwigObject_append((PyObject*) sthis, obj[1]);
+      SwigPyObject_append((PyObject*) sthis, obj[1]);
     } else {
       SWIG_Python_SetSwigThis(obj[0], obj[1]);
     }
@@ -2214,8 +2356,8 @@
     return SWIG_Py_Void();
   } else {
     int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
-    PyObject *robj = PySwigObject_New(ptr, type, own);
-    PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
+    PyObject *robj = SwigPyObject_New(ptr, type, own);
+    SwigPyClientData *clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
     if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
       PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
       if (inst) {
@@ -2231,7 +2373,7 @@
 
 SWIGRUNTIMEINLINE PyObject *
 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
-  return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
+  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
 }
 
 /* -----------------------------------------------------------------------------*
@@ -2302,8 +2444,8 @@
   for (i =0; i < swig_module->size; ++i) {
     swig_type_info *ty = types[i];
     if (ty->owndata) {
-      PySwigClientData *data = (PySwigClientData *) ty->clientdata;
-      if (data) PySwigClientData_Del(data);
+      SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
+      if (data) SwigPyClientData_Del(data);
     }
   }
   Py_DECREF(SWIG_This());
@@ -2313,8 +2455,13 @@
 SWIG_Python_SetModule(swig_module_info *swig_module) {
   static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
 
+#if PY_VERSION_HEX >= 0x03000000
+ /* Add a dummy module object into sys.modules */
+  PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
+#else
   PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
 				   swig_empty_runtime_method_table);
+#endif
   PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
   if (pointer && module) {
     PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
@@ -2334,7 +2481,7 @@
 SWIG_Python_TypeQuery(const char *type)
 {
   PyObject *cache = SWIG_Python_TypeCache();
-  PyObject *key = PyString_FromString(type); 
+  PyObject *key = SWIG_Python_str_FromChar(type); 
   PyObject *obj = PyDict_GetItem(cache, key);
   swig_type_info *descriptor;
   if (obj) {
@@ -2372,9 +2519,9 @@
       Py_XINCREF(type);
       PyErr_Clear();
       if (infront) {
-	PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
+	PyErr_Format(type, "%s %s", mesg, SWIG_Python_str_AsChar(old_str));
       } else {
-	PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
+	PyErr_Format(type, "%s %s", SWIG_Python_str_AsChar(old_str), mesg);
       }
       Py_DECREF(old_str);
     }
@@ -2398,9 +2545,9 @@
 }
 
 SWIGRUNTIMEINLINE const char *
-PySwigObject_GetDesc(PyObject *self)
+SwigPyObject_GetDesc(PyObject *self)
 {
-  PySwigObject *v = (PySwigObject *)self;
+  SwigPyObject *v = (SwigPyObject *)self;
   swig_type_info *ty = v ? v->ty : 0;
   return ty ? ty->str : (char*)"";
 }
@@ -2410,10 +2557,10 @@
 {
   if (type) {
 #if defined(SWIG_COBJECT_TYPES)
-    if (obj && PySwigObject_Check(obj)) {
-      const char *otype = (const char *) PySwigObject_GetDesc(obj);
+    if (obj && SwigPyObject_Check(obj)) {
+      const char *otype = (const char *) SwigPyObject_GetDesc(obj);
       if (otype) {
-	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
+	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
 		     type, otype);
 	return;
       }
@@ -2423,7 +2570,7 @@
       const char *otype = (obj ? obj->ob_type->tp_name : 0); 
       if (otype) {
 	PyObject *str = PyObject_Str(obj);
-	const char *cstr = str ? PyString_AsString(str) : 0;
+	const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
 	if (cstr) {
 	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
 		       type, otype, cstr);
@@ -2476,36 +2623,24 @@
 
 #define SWIGTYPE_p_SELboolean swig_types[0]
 #define SWIGTYPE_p_av_decision swig_types[1]
-#define SWIGTYPE_p_avc_cache_stats swig_types[2]
-#define SWIGTYPE_p_avc_entry swig_types[3]
-#define SWIGTYPE_p_avc_entry_ref swig_types[4]
-#define SWIGTYPE_p_avc_lock_callback swig_types[5]
-#define SWIGTYPE_p_avc_log_callback swig_types[6]
-#define SWIGTYPE_p_avc_memory_callback swig_types[7]
-#define SWIGTYPE_p_avc_thread_callback swig_types[8]
-#define SWIGTYPE_p_char swig_types[9]
-#define SWIGTYPE_p_f_int_p_q_const__char_v_______int swig_types[10]
-#define SWIGTYPE_p_f_p_f_void__void__p_void swig_types[11]
-#define SWIGTYPE_p_f_p_p_char__int swig_types[12]
-#define SWIGTYPE_p_f_p_q_const__char_v_______void swig_types[13]
-#define SWIGTYPE_p_f_p_void__void swig_types[14]
-#define SWIGTYPE_p_f_p_void_unsigned_short_p_char_size_t__int swig_types[15]
-#define SWIGTYPE_p_f_p_void_unsigned_short_p_char_size_t__void swig_types[16]
-#define SWIGTYPE_p_f_size_t__p_void swig_types[17]
-#define SWIGTYPE_p_f_void__p_void swig_types[18]
-#define SWIGTYPE_p_ino_t swig_types[19]
-#define SWIGTYPE_p_int swig_types[20]
-#define SWIGTYPE_p_p_char swig_types[21]
-#define SWIGTYPE_p_p_p_char swig_types[22]
-#define SWIGTYPE_p_p_security_id swig_types[23]
-#define SWIGTYPE_p_security_class_mapping swig_types[24]
-#define SWIGTYPE_p_security_id swig_types[25]
-#define SWIGTYPE_p_selinux_callback swig_types[26]
-#define SWIGTYPE_p_selinux_opt swig_types[27]
-#define SWIGTYPE_p_unsigned_int swig_types[28]
-#define SWIGTYPE_p_unsigned_short swig_types[29]
-static swig_type_info *swig_types[31];
-static swig_module_info swig_module = {swig_types, 30, 0, 0, 0, 0};
+#define SWIGTYPE_p_avc_entry_ref swig_types[2]
+#define SWIGTYPE_p_avc_lock_callback swig_types[3]
+#define SWIGTYPE_p_avc_log_callback swig_types[4]
+#define SWIGTYPE_p_avc_memory_callback swig_types[5]
+#define SWIGTYPE_p_avc_thread_callback swig_types[6]
+#define SWIGTYPE_p_char swig_types[7]
+#define SWIGTYPE_p_ino_t swig_types[8]
+#define SWIGTYPE_p_int swig_types[9]
+#define SWIGTYPE_p_p_char swig_types[10]
+#define SWIGTYPE_p_p_p_char swig_types[11]
+#define SWIGTYPE_p_p_security_id swig_types[12]
+#define SWIGTYPE_p_security_class_mapping swig_types[13]
+#define SWIGTYPE_p_security_id swig_types[14]
+#define SWIGTYPE_p_selinux_opt swig_types[15]
+#define SWIGTYPE_p_unsigned_int swig_types[16]
+#define SWIGTYPE_p_unsigned_short swig_types[17]
+static swig_type_info *swig_types[19];
+static swig_module_info swig_module = {swig_types, 18, 0, 0, 0, 0};
 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
 
@@ -2520,11 +2655,16 @@
 /*-----------------------------------------------
               @(target):= _selinux.so
   ------------------------------------------------*/
-#define SWIG_init    init_selinux
+#if PY_VERSION_HEX >= 0x03000000
+#  define SWIG_init    PyInit__selinux
+
+#else
+#  define SWIG_init    init_selinux
 
+#endif
 #define SWIG_name    "_selinux"
 
-#define SWIGVERSION 0x010335 
+#define SWIGVERSION 0x010338 
 #define SWIG_VERSION SWIGVERSION
 
 
@@ -2568,10 +2708,20 @@
 SWIGINTERN int
 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
 {
-  if (PyString_Check(obj)) {
+#if PY_VERSION_HEX>=0x03000000
+  if (PyUnicode_Check(obj)) 
+#else  
+  if (PyString_Check(obj)) 
+#endif
+  {
     char *cstr; Py_ssize_t len;
+#if PY_VERSION_HEX>=0x03000000
+    obj = PyUnicode_AsUTF8String(obj);
+    PyBytes_AsStringAndSize(obj, &cstr, &len);
+#else
     PyString_AsStringAndSize(obj, &cstr, &len);
-    if (cptr)  {
+#endif
+    if (cptr) { 
       if (alloc) {
 	/* 
 	   In python the user should not be able to modify the inner
@@ -2596,7 +2746,7 @@
 	  *alloc = SWIG_OLDOBJ;
 	}
       } else {
-	*cptr = PyString_AsString(obj);
+	*cptr = SWIG_Python_str_AsChar(obj);
       }
     }
     if (psize) *psize = len + 1;
@@ -2849,7 +2999,11 @@
       return pchar_descriptor ? 
 	SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
     } else {
+#if PY_VERSION_HEX >= 0x03000000
+      return PyUnicode_FromStringAndSize(carray, (int)(size));
+#else
       return PyString_FromStringAndSize(carray, (int)(size));
+#endif
     }
   } else {
     return SWIG_Py_Void();
@@ -2904,7 +3058,13 @@
   int result;
   
   if (!PyArg_ParseTuple(args,(char *)":is_selinux_enabled")) SWIG_fail;
-  result = (int)is_selinux_enabled();
+  {
+    result = (int)is_selinux_enabled(); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -2917,7 +3077,13 @@
   int result;
   
   if (!PyArg_ParseTuple(args,(char *)":is_selinux_mls_enabled")) SWIG_fail;
-  result = (int)is_selinux_mls_enabled();
+  {
+    result = (int)is_selinux_mls_enabled(); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -2928,12 +3094,18 @@
 SWIGINTERN PyObject *_wrap_getcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t *arg1 = (security_context_t *) 0 ;
-  int result;
   security_context_t temp1 = 0 ;
+  int result;
   
   arg1 = &temp1;
   if (!PyArg_ParseTuple(args,(char *)":getcon")) SWIG_fail;
-  result = (int)getcon(arg1);
+  {
+    result = (int)getcon(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg1) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1));
@@ -2952,12 +3124,18 @@
 SWIGINTERN PyObject *_wrap_getcon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t *arg1 = (security_context_t *) 0 ;
-  int result;
   security_context_t temp1 = 0 ;
+  int result;
   
   arg1 = &temp1;
   if (!PyArg_ParseTuple(args,(char *)":getcon_raw")) SWIG_fail;
-  result = (int)getcon_raw(arg1);
+  {
+    result = (int)getcon_raw(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg1) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1));
@@ -2976,11 +3154,11 @@
 SWIGINTERN PyObject *_wrap_setcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:setcon",&obj0)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -2988,7 +3166,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setcon" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
-  result = (int)setcon(arg1);
+  {
+    result = (int)setcon(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   return resultobj;
@@ -3001,11 +3185,11 @@
 SWIGINTERN PyObject *_wrap_setcon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:setcon_raw",&obj0)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -3013,7 +3197,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setcon_raw" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
-  result = (int)setcon_raw(arg1);
+  {
+    result = (int)setcon_raw(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   return resultobj;
@@ -3027,11 +3217,11 @@
   PyObject *resultobj = 0;
   pid_t arg1 ;
   security_context_t *arg2 = (security_context_t *) 0 ;
-  int result;
   unsigned int val1 ;
   int ecode1 = 0 ;
   security_context_t temp2 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   arg2 = &temp2;
   if (!PyArg_ParseTuple(args,(char *)"O:getpidcon",&obj0)) SWIG_fail;
@@ -3040,7 +3230,13 @@
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "getpidcon" "', argument " "1"" of type '" "pid_t""'");
   } 
   arg1 = (pid_t)(val1);
-  result = (int)getpidcon(arg1,arg2);
+  {
+    result = (int)getpidcon(arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg2) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg2));
@@ -3060,11 +3256,11 @@
   PyObject *resultobj = 0;
   pid_t arg1 ;
   security_context_t *arg2 = (security_context_t *) 0 ;
-  int result;
   unsigned int val1 ;
   int ecode1 = 0 ;
   security_context_t temp2 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   arg2 = &temp2;
   if (!PyArg_ParseTuple(args,(char *)"O:getpidcon_raw",&obj0)) SWIG_fail;
@@ -3073,7 +3269,13 @@
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "getpidcon_raw" "', argument " "1"" of type '" "pid_t""'");
   } 
   arg1 = (pid_t)(val1);
-  result = (int)getpidcon_raw(arg1,arg2);
+  {
+    result = (int)getpidcon_raw(arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg2) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg2));
@@ -3092,12 +3294,18 @@
 SWIGINTERN PyObject *_wrap_getprevcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t *arg1 = (security_context_t *) 0 ;
-  int result;
   security_context_t temp1 = 0 ;
+  int result;
   
   arg1 = &temp1;
   if (!PyArg_ParseTuple(args,(char *)":getprevcon")) SWIG_fail;
-  result = (int)getprevcon(arg1);
+  {
+    result = (int)getprevcon(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg1) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1));
@@ -3116,12 +3324,18 @@
 SWIGINTERN PyObject *_wrap_getprevcon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t *arg1 = (security_context_t *) 0 ;
-  int result;
   security_context_t temp1 = 0 ;
+  int result;
   
   arg1 = &temp1;
   if (!PyArg_ParseTuple(args,(char *)":getprevcon_raw")) SWIG_fail;
-  result = (int)getprevcon_raw(arg1);
+  {
+    result = (int)getprevcon_raw(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg1) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1));
@@ -3140,12 +3354,18 @@
 SWIGINTERN PyObject *_wrap_getexeccon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t *arg1 = (security_context_t *) 0 ;
-  int result;
   security_context_t temp1 = 0 ;
+  int result;
   
   arg1 = &temp1;
   if (!PyArg_ParseTuple(args,(char *)":getexeccon")) SWIG_fail;
-  result = (int)getexeccon(arg1);
+  {
+    result = (int)getexeccon(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg1) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1));
@@ -3164,12 +3384,18 @@
 SWIGINTERN PyObject *_wrap_getexeccon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t *arg1 = (security_context_t *) 0 ;
-  int result;
   security_context_t temp1 = 0 ;
+  int result;
   
   arg1 = &temp1;
   if (!PyArg_ParseTuple(args,(char *)":getexeccon_raw")) SWIG_fail;
-  result = (int)getexeccon_raw(arg1);
+  {
+    result = (int)getexeccon_raw(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg1) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1));
@@ -3188,11 +3414,11 @@
 SWIGINTERN PyObject *_wrap_setexeccon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:setexeccon",&obj0)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -3200,7 +3426,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setexeccon" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
-  result = (int)setexeccon(arg1);
+  {
+    result = (int)setexeccon(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   return resultobj;
@@ -3213,11 +3445,11 @@
 SWIGINTERN PyObject *_wrap_setexeccon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:setexeccon_raw",&obj0)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -3225,7 +3457,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setexeccon_raw" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
-  result = (int)setexeccon_raw(arg1);
+  {
+    result = (int)setexeccon_raw(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   return resultobj;
@@ -3238,12 +3476,18 @@
 SWIGINTERN PyObject *_wrap_getfscreatecon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t *arg1 = (security_context_t *) 0 ;
-  int result;
   security_context_t temp1 = 0 ;
+  int result;
   
   arg1 = &temp1;
   if (!PyArg_ParseTuple(args,(char *)":getfscreatecon")) SWIG_fail;
-  result = (int)getfscreatecon(arg1);
+  {
+    result = (int)getfscreatecon(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg1) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1));
@@ -3262,12 +3506,18 @@
 SWIGINTERN PyObject *_wrap_getfscreatecon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t *arg1 = (security_context_t *) 0 ;
-  int result;
   security_context_t temp1 = 0 ;
+  int result;
   
   arg1 = &temp1;
   if (!PyArg_ParseTuple(args,(char *)":getfscreatecon_raw")) SWIG_fail;
-  result = (int)getfscreatecon_raw(arg1);
+  {
+    result = (int)getfscreatecon_raw(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg1) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1));
@@ -3286,11 +3536,11 @@
 SWIGINTERN PyObject *_wrap_setfscreatecon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:setfscreatecon",&obj0)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -3298,7 +3548,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setfscreatecon" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
-  result = (int)setfscreatecon(arg1);
+  {
+    result = (int)setfscreatecon(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   return resultobj;
@@ -3311,11 +3567,11 @@
 SWIGINTERN PyObject *_wrap_setfscreatecon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:setfscreatecon_raw",&obj0)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -3323,7 +3579,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setfscreatecon_raw" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
-  result = (int)setfscreatecon_raw(arg1);
+  {
+    result = (int)setfscreatecon_raw(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   return resultobj;
@@ -3336,12 +3598,18 @@
 SWIGINTERN PyObject *_wrap_getkeycreatecon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t *arg1 = (security_context_t *) 0 ;
-  int result;
   security_context_t temp1 = 0 ;
+  int result;
   
   arg1 = &temp1;
   if (!PyArg_ParseTuple(args,(char *)":getkeycreatecon")) SWIG_fail;
-  result = (int)getkeycreatecon(arg1);
+  {
+    result = (int)getkeycreatecon(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg1) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1));
@@ -3360,12 +3628,18 @@
 SWIGINTERN PyObject *_wrap_getkeycreatecon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t *arg1 = (security_context_t *) 0 ;
-  int result;
   security_context_t temp1 = 0 ;
+  int result;
   
   arg1 = &temp1;
   if (!PyArg_ParseTuple(args,(char *)":getkeycreatecon_raw")) SWIG_fail;
-  result = (int)getkeycreatecon_raw(arg1);
+  {
+    result = (int)getkeycreatecon_raw(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg1) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1));
@@ -3384,11 +3658,11 @@
 SWIGINTERN PyObject *_wrap_setkeycreatecon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:setkeycreatecon",&obj0)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -3396,7 +3670,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setkeycreatecon" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
-  result = (int)setkeycreatecon(arg1);
+  {
+    result = (int)setkeycreatecon(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   return resultobj;
@@ -3409,11 +3689,11 @@
 SWIGINTERN PyObject *_wrap_setkeycreatecon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:setkeycreatecon_raw",&obj0)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -3421,7 +3701,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setkeycreatecon_raw" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
-  result = (int)setkeycreatecon_raw(arg1);
+  {
+    result = (int)setkeycreatecon_raw(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   return resultobj;
@@ -3434,12 +3720,18 @@
 SWIGINTERN PyObject *_wrap_getsockcreatecon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t *arg1 = (security_context_t *) 0 ;
-  int result;
   security_context_t temp1 = 0 ;
+  int result;
   
   arg1 = &temp1;
   if (!PyArg_ParseTuple(args,(char *)":getsockcreatecon")) SWIG_fail;
-  result = (int)getsockcreatecon(arg1);
+  {
+    result = (int)getsockcreatecon(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg1) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1));
@@ -3458,12 +3750,18 @@
 SWIGINTERN PyObject *_wrap_getsockcreatecon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t *arg1 = (security_context_t *) 0 ;
-  int result;
   security_context_t temp1 = 0 ;
+  int result;
   
   arg1 = &temp1;
   if (!PyArg_ParseTuple(args,(char *)":getsockcreatecon_raw")) SWIG_fail;
-  result = (int)getsockcreatecon_raw(arg1);
+  {
+    result = (int)getsockcreatecon_raw(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg1) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1));
@@ -3482,11 +3780,11 @@
 SWIGINTERN PyObject *_wrap_setsockcreatecon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:setsockcreatecon",&obj0)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -3494,7 +3792,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setsockcreatecon" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
-  result = (int)setsockcreatecon(arg1);
+  {
+    result = (int)setsockcreatecon(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   return resultobj;
@@ -3507,11 +3811,11 @@
 SWIGINTERN PyObject *_wrap_setsockcreatecon_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:setsockcreatecon_raw",&obj0)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -3519,7 +3823,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setsockcreatecon_raw" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
-  result = (int)setsockcreatecon_raw(arg1);
+  {
+    result = (int)setsockcreatecon_raw(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   return resultobj;
@@ -3533,12 +3843,12 @@
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
   security_context_t *arg2 = (security_context_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   security_context_t temp2 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   arg2 = &temp2;
   if (!PyArg_ParseTuple(args,(char *)"O:getfilecon",&obj0)) SWIG_fail;
@@ -3547,7 +3857,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getfilecon" "', argument " "1"" of type '" "char const *""'");
   }
   arg1 = (char *)(buf1);
-  result = (int)getfilecon((char const *)arg1,arg2);
+  {
+    result = (int)getfilecon((char const *)arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg2) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg2));
@@ -3569,12 +3885,12 @@
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
   security_context_t *arg2 = (security_context_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   security_context_t temp2 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   arg2 = &temp2;
   if (!PyArg_ParseTuple(args,(char *)"O:getfilecon_raw",&obj0)) SWIG_fail;
@@ -3583,8 +3899,14 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getfilecon_raw" "', argument " "1"" of type '" "char const *""'");
   }
   arg1 = (char *)(buf1);
-  result = (int)getfilecon_raw((char const *)arg1,arg2);
-  resultobj = SWIG_From_int((int)(result));
+  {
+    result = (int)getfilecon_raw((char const *)arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
+  resultobj = SWIG_From_int((int)(result));
   if (*arg2) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg2));
     freecon(*arg2);
@@ -3605,12 +3927,12 @@
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
   security_context_t *arg2 = (security_context_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   security_context_t temp2 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   arg2 = &temp2;
   if (!PyArg_ParseTuple(args,(char *)"O:lgetfilecon",&obj0)) SWIG_fail;
@@ -3619,7 +3941,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lgetfilecon" "', argument " "1"" of type '" "char const *""'");
   }
   arg1 = (char *)(buf1);
-  result = (int)lgetfilecon((char const *)arg1,arg2);
+  {
+    result = (int)lgetfilecon((char const *)arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg2) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg2));
@@ -3641,12 +3969,12 @@
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
   security_context_t *arg2 = (security_context_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   security_context_t temp2 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   arg2 = &temp2;
   if (!PyArg_ParseTuple(args,(char *)"O:lgetfilecon_raw",&obj0)) SWIG_fail;
@@ -3655,7 +3983,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lgetfilecon_raw" "', argument " "1"" of type '" "char const *""'");
   }
   arg1 = (char *)(buf1);
-  result = (int)lgetfilecon_raw((char const *)arg1,arg2);
+  {
+    result = (int)lgetfilecon_raw((char const *)arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg2) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg2));
@@ -3677,11 +4011,11 @@
   PyObject *resultobj = 0;
   int arg1 ;
   security_context_t *arg2 = (security_context_t *) 0 ;
-  int result;
   int val1 ;
   int ecode1 = 0 ;
   security_context_t temp2 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   arg2 = &temp2;
   if (!PyArg_ParseTuple(args,(char *)"O:fgetfilecon",&obj0)) SWIG_fail;
@@ -3690,7 +4024,13 @@
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fgetfilecon" "', argument " "1"" of type '" "int""'");
   } 
   arg1 = (int)(val1);
-  result = (int)fgetfilecon(arg1,arg2);
+  {
+    result = (int)fgetfilecon(arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg2) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg2));
@@ -3710,11 +4050,11 @@
   PyObject *resultobj = 0;
   int arg1 ;
   security_context_t *arg2 = (security_context_t *) 0 ;
-  int result;
   int val1 ;
   int ecode1 = 0 ;
   security_context_t temp2 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   arg2 = &temp2;
   if (!PyArg_ParseTuple(args,(char *)"O:fgetfilecon_raw",&obj0)) SWIG_fail;
@@ -3723,7 +4063,13 @@
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fgetfilecon_raw" "', argument " "1"" of type '" "int""'");
   } 
   arg1 = (int)(val1);
-  result = (int)fgetfilecon_raw(arg1,arg2);
+  {
+    result = (int)fgetfilecon_raw(arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg2) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg2));
@@ -3743,7 +4089,6 @@
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
   security_context_t arg2 = (security_context_t) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
@@ -3752,6 +4097,7 @@
   int alloc2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:setfilecon",&obj0,&obj1)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -3764,7 +4110,13 @@
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "setfilecon" "', argument " "2"" of type '" "security_context_t""'");
   }
   arg2 = (security_context_t)(buf2);
-  result = (int)setfilecon((char const *)arg1,arg2);
+  {
+    result = (int)setfilecon((char const *)arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
@@ -3780,7 +4132,6 @@
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
   security_context_t arg2 = (security_context_t) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
@@ -3789,6 +4140,7 @@
   int alloc2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:setfilecon_raw",&obj0,&obj1)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -3801,7 +4153,13 @@
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "setfilecon_raw" "', argument " "2"" of type '" "security_context_t""'");
   }
   arg2 = (security_context_t)(buf2);
-  result = (int)setfilecon_raw((char const *)arg1,arg2);
+  {
+    result = (int)setfilecon_raw((char const *)arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
@@ -3817,7 +4175,6 @@
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
   security_context_t arg2 = (security_context_t) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
@@ -3826,6 +4183,7 @@
   int alloc2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:lsetfilecon",&obj0,&obj1)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -3838,7 +4196,13 @@
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lsetfilecon" "', argument " "2"" of type '" "security_context_t""'");
   }
   arg2 = (security_context_t)(buf2);
-  result = (int)lsetfilecon((char const *)arg1,arg2);
+  {
+    result = (int)lsetfilecon((char const *)arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
@@ -3854,7 +4218,6 @@
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
   security_context_t arg2 = (security_context_t) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
@@ -3863,6 +4226,7 @@
   int alloc2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:lsetfilecon_raw",&obj0,&obj1)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -3875,7 +4239,13 @@
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lsetfilecon_raw" "', argument " "2"" of type '" "security_context_t""'");
   }
   arg2 = (security_context_t)(buf2);
-  result = (int)lsetfilecon_raw((char const *)arg1,arg2);
+  {
+    result = (int)lsetfilecon_raw((char const *)arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
@@ -3891,7 +4261,6 @@
   PyObject *resultobj = 0;
   int arg1 ;
   security_context_t arg2 = (security_context_t) 0 ;
-  int result;
   int val1 ;
   int ecode1 = 0 ;
   int res2 ;
@@ -3899,6 +4268,7 @@
   int alloc2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:fsetfilecon",&obj0,&obj1)) SWIG_fail;
   ecode1 = SWIG_AsVal_int(obj0, &val1);
@@ -3911,7 +4281,13 @@
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fsetfilecon" "', argument " "2"" of type '" "security_context_t""'");
   }
   arg2 = (security_context_t)(buf2);
-  result = (int)fsetfilecon(arg1,arg2);
+  {
+    result = (int)fsetfilecon(arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return resultobj;
@@ -3925,7 +4301,6 @@
   PyObject *resultobj = 0;
   int arg1 ;
   security_context_t arg2 = (security_context_t) 0 ;
-  int result;
   int val1 ;
   int ecode1 = 0 ;
   int res2 ;
@@ -3933,6 +4308,7 @@
   int alloc2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:fsetfilecon_raw",&obj0,&obj1)) SWIG_fail;
   ecode1 = SWIG_AsVal_int(obj0, &val1);
@@ -3945,7 +4321,13 @@
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fsetfilecon_raw" "', argument " "2"" of type '" "security_context_t""'");
   }
   arg2 = (security_context_t)(buf2);
-  result = (int)fsetfilecon_raw(arg1,arg2);
+  {
+    result = (int)fsetfilecon_raw(arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return resultobj;
@@ -3959,11 +4341,11 @@
   PyObject *resultobj = 0;
   int arg1 ;
   security_context_t *arg2 = (security_context_t *) 0 ;
-  int result;
   int val1 ;
   int ecode1 = 0 ;
   security_context_t temp2 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   arg2 = &temp2;
   if (!PyArg_ParseTuple(args,(char *)"O:getpeercon",&obj0)) SWIG_fail;
@@ -3972,7 +4354,13 @@
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "getpeercon" "', argument " "1"" of type '" "int""'");
   } 
   arg1 = (int)(val1);
-  result = (int)getpeercon(arg1,arg2);
+  {
+    result = (int)getpeercon(arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg2) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg2));
@@ -3992,11 +4380,11 @@
   PyObject *resultobj = 0;
   int arg1 ;
   security_context_t *arg2 = (security_context_t *) 0 ;
-  int result;
   int val1 ;
   int ecode1 = 0 ;
   security_context_t temp2 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   arg2 = &temp2;
   if (!PyArg_ParseTuple(args,(char *)"O:getpeercon_raw",&obj0)) SWIG_fail;
@@ -4005,7 +4393,13 @@
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "getpeercon_raw" "', argument " "1"" of type '" "int""'");
   } 
   arg1 = (int)(val1);
-  result = (int)getpeercon_raw(arg1,arg2);
+  {
+    result = (int)getpeercon_raw(arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg2) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg2));
@@ -4044,7 +4438,6 @@
   } 
   arg2 = (access_vector_t)(val2);
   if (arg1) (arg1)->allowed = arg2;
-  
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -4055,10 +4448,10 @@
 SWIGINTERN PyObject *_wrap_av_decision_allowed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct av_decision *arg1 = (struct av_decision *) 0 ;
-  access_vector_t result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
+  access_vector_t result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:av_decision_allowed_get",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_av_decision, 0 |  0 );
@@ -4097,7 +4490,6 @@
   } 
   arg2 = (access_vector_t)(val2);
   if (arg1) (arg1)->decided = arg2;
-  
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -4108,10 +4500,10 @@
 SWIGINTERN PyObject *_wrap_av_decision_decided_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct av_decision *arg1 = (struct av_decision *) 0 ;
-  access_vector_t result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
+  access_vector_t result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:av_decision_decided_get",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_av_decision, 0 |  0 );
@@ -4150,7 +4542,6 @@
   } 
   arg2 = (access_vector_t)(val2);
   if (arg1) (arg1)->auditallow = arg2;
-  
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -4161,10 +4552,10 @@
 SWIGINTERN PyObject *_wrap_av_decision_auditallow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct av_decision *arg1 = (struct av_decision *) 0 ;
-  access_vector_t result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
+  access_vector_t result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:av_decision_auditallow_get",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_av_decision, 0 |  0 );
@@ -4203,7 +4594,6 @@
   } 
   arg2 = (access_vector_t)(val2);
   if (arg1) (arg1)->auditdeny = arg2;
-  
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -4214,10 +4604,10 @@
 SWIGINTERN PyObject *_wrap_av_decision_auditdeny_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct av_decision *arg1 = (struct av_decision *) 0 ;
-  access_vector_t result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
+  access_vector_t result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:av_decision_auditdeny_get",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_av_decision, 0 |  0 );
@@ -4256,7 +4646,6 @@
   } 
   arg2 = (unsigned int)(val2);
   if (arg1) (arg1)->seqno = arg2;
-  
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -4267,10 +4656,10 @@
 SWIGINTERN PyObject *_wrap_av_decision_seqno_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct av_decision *arg1 = (struct av_decision *) 0 ;
-  unsigned int result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
+  unsigned int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:av_decision_seqno_get",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_av_decision, 0 |  0 );
@@ -4313,7 +4702,6 @@
   }
   arg1 = (struct av_decision *)(argp1);
   free((char *) arg1);
-  
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -4351,7 +4739,6 @@
   } 
   arg2 = (int)(val2);
   if (arg1) (arg1)->type = arg2;
-  
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -4362,10 +4749,10 @@
 SWIGINTERN PyObject *_wrap_selinux_opt_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct selinux_opt *arg1 = (struct selinux_opt *) 0 ;
-  int result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:selinux_opt_type_get",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_selinux_opt, 0 |  0 );
@@ -4422,10 +4809,10 @@
 SWIGINTERN PyObject *_wrap_selinux_opt_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct selinux_opt *arg1 = (struct selinux_opt *) 0 ;
-  char *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
+  char *result = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:selinux_opt_value_get",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_selinux_opt, 0 |  0 );
@@ -4468,7 +4855,6 @@
   }
   arg1 = (struct selinux_opt *)(argp1);
   free((char *) arg1);
-  
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -4483,270 +4869,215 @@
   return SWIG_Py_Void();
 }
 
-SWIGINTERN PyObject *_wrap_selinux_callback_func_log_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_security_compute_av(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  union selinux_callback *arg1 = (union selinux_callback *) 0 ;
-  int (*arg2)(int,char const *,...) = (int (*)(int,char const *,...)) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  security_context_t arg1 = (security_context_t) 0 ;
+  security_context_t arg2 = (security_context_t) 0 ;
+  security_class_t arg3 ;
+  access_vector_t arg4 ;
+  struct av_decision *arg5 = (struct av_decision *) 0 ;
+  int res1 ;
+  char *buf1 = 0 ;
+  int alloc1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  unsigned short val3 ;
+  int ecode3 = 0 ;
+  unsigned int val4 ;
+  int ecode4 = 0 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  int result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:selinux_callback_func_log_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_selinux_callback, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:security_compute_av",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_callback_func_log_set" "', argument " "1"" of type '" "union selinux_callback *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_av" "', argument " "1"" of type '" "security_context_t""'");
+  }
+  arg1 = (security_context_t)(buf1);
+  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_av" "', argument " "2"" of type '" "security_context_t""'");
+  }
+  arg2 = (security_context_t)(buf2);
+  ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_av" "', argument " "3"" of type '" "security_class_t""'");
+  } 
+  arg3 = (security_class_t)(val3);
+  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "security_compute_av" "', argument " "4"" of type '" "access_vector_t""'");
+  } 
+  arg4 = (access_vector_t)(val4);
+  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_av_decision, 0 |  0 );
+  if (!SWIG_IsOK(res5)) {
+    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "security_compute_av" "', argument " "5"" of type '" "struct av_decision *""'"); 
   }
-  arg1 = (union selinux_callback *)(argp1);
+  arg5 = (struct av_decision *)(argp5);
   {
-    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_int_p_q_const__char_v_______int);
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "selinux_callback_func_log_set" "', argument " "2"" of type '" "int (*)(int,char const *,...)""'"); 
+    result = (int)security_compute_av(arg1,arg2,arg3,arg4,arg5); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
     }
   }
-  if (arg1) (arg1)->func_log = arg2;
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_selinux_callback_func_log_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  union selinux_callback *arg1 = (union selinux_callback *) 0 ;
-  int (*result)(int,char const *,...) = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:selinux_callback_func_log_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_selinux_callback, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_callback_func_log_get" "', argument " "1"" of type '" "union selinux_callback *""'"); 
-  }
-  arg1 = (union selinux_callback *)(argp1);
-  result = (int (*)(int,char const *,...)) ((arg1)->func_log);
-  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_int_p_q_const__char_v_______int);
+  resultobj = SWIG_From_int((int)(result));
+  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return resultobj;
 fail:
+  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_selinux_callback_func_audit_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_security_compute_av_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  union selinux_callback *arg1 = (union selinux_callback *) 0 ;
-  int (*arg2)(void *,security_class_t,char *,size_t) = (int (*)(void *,security_class_t,char *,size_t)) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  security_context_t arg1 = (security_context_t) 0 ;
+  security_context_t arg2 = (security_context_t) 0 ;
+  security_class_t arg3 ;
+  access_vector_t arg4 ;
+  struct av_decision *arg5 = (struct av_decision *) 0 ;
+  int res1 ;
+  char *buf1 = 0 ;
+  int alloc1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  unsigned short val3 ;
+  int ecode3 = 0 ;
+  unsigned int val4 ;
+  int ecode4 = 0 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  int result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:selinux_callback_func_audit_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_selinux_callback, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:security_compute_av_raw",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_callback_func_audit_set" "', argument " "1"" of type '" "union selinux_callback *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_av_raw" "', argument " "1"" of type '" "security_context_t""'");
+  }
+  arg1 = (security_context_t)(buf1);
+  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_av_raw" "', argument " "2"" of type '" "security_context_t""'");
+  }
+  arg2 = (security_context_t)(buf2);
+  ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_av_raw" "', argument " "3"" of type '" "security_class_t""'");
+  } 
+  arg3 = (security_class_t)(val3);
+  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "security_compute_av_raw" "', argument " "4"" of type '" "access_vector_t""'");
+  } 
+  arg4 = (access_vector_t)(val4);
+  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_av_decision, 0 |  0 );
+  if (!SWIG_IsOK(res5)) {
+    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "security_compute_av_raw" "', argument " "5"" of type '" "struct av_decision *""'"); 
   }
-  arg1 = (union selinux_callback *)(argp1);
+  arg5 = (struct av_decision *)(argp5);
   {
-    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_unsigned_short_p_char_size_t__int);
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "selinux_callback_func_audit_set" "', argument " "2"" of type '" "int (*)(void *,security_class_t,char *,size_t)""'"); 
+    result = (int)security_compute_av_raw(arg1,arg2,arg3,arg4,arg5); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
     }
   }
-  if (arg1) (arg1)->func_audit = arg2;
-  
-  resultobj = SWIG_Py_Void();
+  resultobj = SWIG_From_int((int)(result));
+  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return resultobj;
 fail:
+  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_selinux_callback_func_audit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_security_compute_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  union selinux_callback *arg1 = (union selinux_callback *) 0 ;
-  int (*result)(void *,security_class_t,char *,size_t) = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  security_context_t arg1 = (security_context_t) 0 ;
+  security_context_t arg2 = (security_context_t) 0 ;
+  security_class_t arg3 ;
+  security_context_t *arg4 = (security_context_t *) 0 ;
+  int res1 ;
+  char *buf1 = 0 ;
+  int alloc1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  unsigned short val3 ;
+  int ecode3 = 0 ;
+  security_context_t temp4 = 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  int result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:selinux_callback_func_audit_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_selinux_callback, 0 |  0 );
+  arg4 = &temp4;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:security_compute_create",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_callback_func_audit_get" "', argument " "1"" of type '" "union selinux_callback *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_create" "', argument " "1"" of type '" "security_context_t""'");
   }
-  arg1 = (union selinux_callback *)(argp1);
-  result = (int (*)(void *,security_class_t,char *,size_t)) ((arg1)->func_audit);
-  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_unsigned_short_p_char_size_t__int);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_selinux_callback_func_validate_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  union selinux_callback *arg1 = (union selinux_callback *) 0 ;
-  int (*arg2)(security_context_t *) = (int (*)(security_context_t *)) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:selinux_callback_func_validate_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_selinux_callback, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_callback_func_validate_set" "', argument " "1"" of type '" "union selinux_callback *""'"); 
+  arg1 = (security_context_t)(buf1);
+  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_create" "', argument " "2"" of type '" "security_context_t""'");
   }
-  arg1 = (union selinux_callback *)(argp1);
+  arg2 = (security_context_t)(buf2);
+  ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_create" "', argument " "3"" of type '" "security_class_t""'");
+  } 
+  arg3 = (security_class_t)(val3);
   {
-    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_p_char__int);
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "selinux_callback_func_validate_set" "', argument " "2"" of type '" "int (*)(security_context_t *)""'"); 
+    result = (int)security_compute_create(arg1,arg2,arg3,arg4); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
     }
   }
-  if (arg1) (arg1)->func_validate = arg2;
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_selinux_callback_func_validate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  union selinux_callback *arg1 = (union selinux_callback *) 0 ;
-  int (*result)(security_context_t *) = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:selinux_callback_func_validate_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_selinux_callback, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_callback_func_validate_get" "', argument " "1"" of type '" "union selinux_callback *""'"); 
-  }
-  arg1 = (union selinux_callback *)(argp1);
-  result = (int (*)(security_context_t *)) ((arg1)->func_validate);
-  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_p_char__int);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_new_selinux_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  union selinux_callback *result = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)":new_selinux_callback")) SWIG_fail;
-  result = (union selinux_callback *)calloc(1, sizeof(union selinux_callback));
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_selinux_callback, SWIG_POINTER_NEW |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_delete_selinux_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  union selinux_callback *arg1 = (union selinux_callback *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:delete_selinux_callback",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_selinux_callback, SWIG_POINTER_DISOWN |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_selinux_callback" "', argument " "1"" of type '" "union selinux_callback *""'"); 
+  resultobj = SWIG_From_int((int)(result));
+  if (*arg4) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg4));
+    freecon(*arg4);
   }
-  arg1 = (union selinux_callback *)(argp1);
-  free((char *) arg1);
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *selinux_callback_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *obj;
-  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_selinux_callback, SWIG_NewClientData(obj));
-  return SWIG_Py_Void();
-}
-
-SWIGINTERN PyObject *_wrap_selinux_get_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  int arg1 ;
-  union selinux_callback result;
-  int val1 ;
-  int ecode1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:selinux_get_callback",&obj0)) SWIG_fail;
-  ecode1 = SWIG_AsVal_int(obj0, &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "selinux_get_callback" "', argument " "1"" of type '" "int""'");
-  } 
-  arg1 = (int)(val1);
-  result = selinux_get_callback(arg1);
-  resultobj = SWIG_NewPointerObj((union selinux_callback *)memcpy((union selinux_callback *)malloc(sizeof(union selinux_callback)),&result,sizeof(union selinux_callback)), SWIGTYPE_p_selinux_callback, SWIG_POINTER_OWN |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_selinux_set_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  int arg1 ;
-  union selinux_callback arg2 ;
-  int val1 ;
-  int ecode1 = 0 ;
-  void *argp2 ;
-  int res2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:selinux_set_callback",&obj0,&obj1)) SWIG_fail;
-  ecode1 = SWIG_AsVal_int(obj0, &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "selinux_set_callback" "', argument " "1"" of type '" "int""'");
-  } 
-  arg1 = (int)(val1);
-  {
-    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_selinux_callback,  0 );
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "selinux_set_callback" "', argument " "2"" of type '" "union selinux_callback""'"); 
-    }  
-    if (!argp2) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "selinux_set_callback" "', argument " "2"" of type '" "union selinux_callback""'");
-    } else {
-      arg2 = *((union selinux_callback *)(argp2));
-    }
+  else {
+    Py_INCREF(Py_None);
+    resultobj = SWIG_Python_AppendOutput(resultobj, Py_None);
   }
-  selinux_set_callback(arg1,arg2);
-  resultobj = SWIG_Py_Void();
+  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return resultobj;
 fail:
+  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_security_compute_av(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_security_compute_create_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
   security_context_t arg2 = (security_context_t) 0 ;
   security_class_t arg3 ;
-  access_vector_t arg4 ;
-  struct av_decision *arg5 = (struct av_decision *) 0 ;
-  int result;
+  security_context_t *arg4 = (security_context_t *) 0 ;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
@@ -4755,44 +5086,45 @@
   int alloc2 = 0 ;
   unsigned short val3 ;
   int ecode3 = 0 ;
-  unsigned int val4 ;
-  int ecode4 = 0 ;
-  void *argp5 = 0 ;
-  int res5 = 0 ;
+  security_context_t temp4 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  PyObject * obj4 = 0 ;
+  int result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOOOO:security_compute_av",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  arg4 = &temp4;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:security_compute_create_raw",&obj0,&obj1,&obj2)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_av" "', argument " "1"" of type '" "security_context_t""'");
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_create_raw" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_av" "', argument " "2"" of type '" "security_context_t""'");
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_create_raw" "', argument " "2"" of type '" "security_context_t""'");
   }
   arg2 = (security_context_t)(buf2);
   ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_av" "', argument " "3"" of type '" "security_class_t""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_create_raw" "', argument " "3"" of type '" "security_class_t""'");
   } 
   arg3 = (security_class_t)(val3);
-  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
-  if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "security_compute_av" "', argument " "4"" of type '" "access_vector_t""'");
-  } 
-  arg4 = (access_vector_t)(val4);
-  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_av_decision, 0 |  0 );
-  if (!SWIG_IsOK(res5)) {
-    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "security_compute_av" "', argument " "5"" of type '" "struct av_decision *""'"); 
+  {
+    result = (int)security_compute_create_raw(arg1,arg2,arg3,arg4); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
   }
-  arg5 = (struct av_decision *)(argp5);
-  result = (int)security_compute_av(arg1,arg2,arg3,arg4,arg5);
   resultobj = SWIG_From_int((int)(result));
+  if (*arg4) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg4));
+    freecon(*arg4);
+  }
+  else {
+    Py_INCREF(Py_None);
+    resultobj = SWIG_Python_AppendOutput(resultobj, Py_None);
+  }
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return resultobj;
@@ -4803,14 +5135,12 @@
 }
 
 
-SWIGINTERN PyObject *_wrap_security_compute_av_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_security_compute_relabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
   security_context_t arg2 = (security_context_t) 0 ;
   security_class_t arg3 ;
-  access_vector_t arg4 ;
-  struct av_decision *arg5 = (struct av_decision *) 0 ;
-  int result;
+  security_context_t *arg4 = (security_context_t *) 0 ;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
@@ -4819,44 +5149,45 @@
   int alloc2 = 0 ;
   unsigned short val3 ;
   int ecode3 = 0 ;
-  unsigned int val4 ;
-  int ecode4 = 0 ;
-  void *argp5 = 0 ;
-  int res5 = 0 ;
+  security_context_t temp4 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  PyObject * obj4 = 0 ;
+  int result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOOOO:security_compute_av_raw",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  arg4 = &temp4;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:security_compute_relabel",&obj0,&obj1,&obj2)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_av_raw" "', argument " "1"" of type '" "security_context_t""'");
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_relabel" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_av_raw" "', argument " "2"" of type '" "security_context_t""'");
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_relabel" "', argument " "2"" of type '" "security_context_t""'");
   }
   arg2 = (security_context_t)(buf2);
   ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_av_raw" "', argument " "3"" of type '" "security_class_t""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_relabel" "', argument " "3"" of type '" "security_class_t""'");
   } 
   arg3 = (security_class_t)(val3);
-  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
-  if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "security_compute_av_raw" "', argument " "4"" of type '" "access_vector_t""'");
-  } 
-  arg4 = (access_vector_t)(val4);
-  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_av_decision, 0 |  0 );
-  if (!SWIG_IsOK(res5)) {
-    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "security_compute_av_raw" "', argument " "5"" of type '" "struct av_decision *""'"); 
+  {
+    result = (int)security_compute_relabel(arg1,arg2,arg3,arg4); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
   }
-  arg5 = (struct av_decision *)(argp5);
-  result = (int)security_compute_av_raw(arg1,arg2,arg3,arg4,arg5);
   resultobj = SWIG_From_int((int)(result));
+  if (*arg4) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg4));
+    freecon(*arg4);
+  }
+  else {
+    Py_INCREF(Py_None);
+    resultobj = SWIG_Python_AppendOutput(resultobj, Py_None);
+  }
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return resultobj;
@@ -4867,13 +5198,12 @@
 }
 
 
-SWIGINTERN PyObject *_wrap_security_compute_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_security_compute_relabel_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
   security_context_t arg2 = (security_context_t) 0 ;
   security_class_t arg3 ;
   security_context_t *arg4 = (security_context_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
@@ -4886,25 +5216,32 @@
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
+  int result;
   
   arg4 = &temp4;
-  if (!PyArg_ParseTuple(args,(char *)"OOO:security_compute_create",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:security_compute_relabel_raw",&obj0,&obj1,&obj2)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_create" "', argument " "1"" of type '" "security_context_t""'");
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_relabel_raw" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_create" "', argument " "2"" of type '" "security_context_t""'");
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_relabel_raw" "', argument " "2"" of type '" "security_context_t""'");
   }
   arg2 = (security_context_t)(buf2);
   ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_create" "', argument " "3"" of type '" "security_class_t""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_relabel_raw" "', argument " "3"" of type '" "security_class_t""'");
   } 
   arg3 = (security_class_t)(val3);
-  result = (int)security_compute_create(arg1,arg2,arg3,arg4);
+  {
+    result = (int)security_compute_relabel_raw(arg1,arg2,arg3,arg4); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg4) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg4));
@@ -4924,13 +5261,12 @@
 }
 
 
-SWIGINTERN PyObject *_wrap_security_compute_create_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_security_compute_member(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
   security_context_t arg2 = (security_context_t) 0 ;
   security_class_t arg3 ;
   security_context_t *arg4 = (security_context_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
@@ -4943,25 +5279,32 @@
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
+  int result;
   
   arg4 = &temp4;
-  if (!PyArg_ParseTuple(args,(char *)"OOO:security_compute_create_raw",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:security_compute_member",&obj0,&obj1,&obj2)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_create_raw" "', argument " "1"" of type '" "security_context_t""'");
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_member" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_create_raw" "', argument " "2"" of type '" "security_context_t""'");
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_member" "', argument " "2"" of type '" "security_context_t""'");
   }
   arg2 = (security_context_t)(buf2);
   ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_create_raw" "', argument " "3"" of type '" "security_class_t""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_member" "', argument " "3"" of type '" "security_class_t""'");
   } 
   arg3 = (security_class_t)(val3);
-  result = (int)security_compute_create_raw(arg1,arg2,arg3,arg4);
+  {
+    result = (int)security_compute_member(arg1,arg2,arg3,arg4); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg4) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg4));
@@ -4981,13 +5324,12 @@
 }
 
 
-SWIGINTERN PyObject *_wrap_security_compute_relabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_security_compute_member_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
   security_context_t arg2 = (security_context_t) 0 ;
   security_class_t arg3 ;
   security_context_t *arg4 = (security_context_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
@@ -5000,25 +5342,32 @@
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
+  int result;
   
   arg4 = &temp4;
-  if (!PyArg_ParseTuple(args,(char *)"OOO:security_compute_relabel",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:security_compute_member_raw",&obj0,&obj1,&obj2)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_relabel" "', argument " "1"" of type '" "security_context_t""'");
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_member_raw" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_relabel" "', argument " "2"" of type '" "security_context_t""'");
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_member_raw" "', argument " "2"" of type '" "security_context_t""'");
   }
   arg2 = (security_context_t)(buf2);
   ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_relabel" "', argument " "3"" of type '" "security_class_t""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_member_raw" "', argument " "3"" of type '" "security_class_t""'");
   } 
   arg3 = (security_class_t)(val3);
-  result = (int)security_compute_relabel(arg1,arg2,arg3,arg4);
+  {
+    result = (int)security_compute_member_raw(arg1,arg2,arg3,arg4); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg4) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg4));
@@ -5038,192 +5387,21 @@
 }
 
 
-SWIGINTERN PyObject *_wrap_security_compute_relabel_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_security_compute_user(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
-  security_context_t arg2 = (security_context_t) 0 ;
-  security_class_t arg3 ;
-  security_context_t *arg4 = (security_context_t *) 0 ;
-  int result;
+  char *arg2 = (char *) 0 ;
+  security_context_t **arg3 = (security_context_t **) 0 ;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   int res2 ;
   char *buf2 = 0 ;
   int alloc2 = 0 ;
-  unsigned short val3 ;
-  int ecode3 = 0 ;
-  security_context_t temp4 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  
-  arg4 = &temp4;
-  if (!PyArg_ParseTuple(args,(char *)"OOO:security_compute_relabel_raw",&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_relabel_raw" "', argument " "1"" of type '" "security_context_t""'");
-  }
-  arg1 = (security_context_t)(buf1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_relabel_raw" "', argument " "2"" of type '" "security_context_t""'");
-  }
-  arg2 = (security_context_t)(buf2);
-  ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_relabel_raw" "', argument " "3"" of type '" "security_class_t""'");
-  } 
-  arg3 = (security_class_t)(val3);
-  result = (int)security_compute_relabel_raw(arg1,arg2,arg3,arg4);
-  resultobj = SWIG_From_int((int)(result));
-  if (*arg4) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg4));
-    freecon(*arg4);
-  }
-  else {
-    Py_INCREF(Py_None);
-    resultobj = SWIG_Python_AppendOutput(resultobj, Py_None);
-  }
-  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return resultobj;
-fail:
-  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_security_compute_member(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  security_context_t arg1 = (security_context_t) 0 ;
-  security_context_t arg2 = (security_context_t) 0 ;
-  security_class_t arg3 ;
-  security_context_t *arg4 = (security_context_t *) 0 ;
-  int result;
-  int res1 ;
-  char *buf1 = 0 ;
-  int alloc1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  unsigned short val3 ;
-  int ecode3 = 0 ;
-  security_context_t temp4 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  
-  arg4 = &temp4;
-  if (!PyArg_ParseTuple(args,(char *)"OOO:security_compute_member",&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_member" "', argument " "1"" of type '" "security_context_t""'");
-  }
-  arg1 = (security_context_t)(buf1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_member" "', argument " "2"" of type '" "security_context_t""'");
-  }
-  arg2 = (security_context_t)(buf2);
-  ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_member" "', argument " "3"" of type '" "security_class_t""'");
-  } 
-  arg3 = (security_class_t)(val3);
-  result = (int)security_compute_member(arg1,arg2,arg3,arg4);
-  resultobj = SWIG_From_int((int)(result));
-  if (*arg4) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg4));
-    freecon(*arg4);
-  }
-  else {
-    Py_INCREF(Py_None);
-    resultobj = SWIG_Python_AppendOutput(resultobj, Py_None);
-  }
-  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return resultobj;
-fail:
-  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_security_compute_member_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  security_context_t arg1 = (security_context_t) 0 ;
-  security_context_t arg2 = (security_context_t) 0 ;
-  security_class_t arg3 ;
-  security_context_t *arg4 = (security_context_t *) 0 ;
-  int result;
-  int res1 ;
-  char *buf1 = 0 ;
-  int alloc1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  unsigned short val3 ;
-  int ecode3 = 0 ;
-  security_context_t temp4 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  
-  arg4 = &temp4;
-  if (!PyArg_ParseTuple(args,(char *)"OOO:security_compute_member_raw",&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_compute_member_raw" "', argument " "1"" of type '" "security_context_t""'");
-  }
-  arg1 = (security_context_t)(buf1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_member_raw" "', argument " "2"" of type '" "security_context_t""'");
-  }
-  arg2 = (security_context_t)(buf2);
-  ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_compute_member_raw" "', argument " "3"" of type '" "security_class_t""'");
-  } 
-  arg3 = (security_class_t)(val3);
-  result = (int)security_compute_member_raw(arg1,arg2,arg3,arg4);
-  resultobj = SWIG_From_int((int)(result));
-  if (*arg4) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg4));
-    freecon(*arg4);
-  }
-  else {
-    Py_INCREF(Py_None);
-    resultobj = SWIG_Python_AppendOutput(resultobj, Py_None);
-  }
-  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return resultobj;
-fail:
-  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_security_compute_user(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  security_context_t arg1 = (security_context_t) 0 ;
-  char *arg2 = (char *) 0 ;
-  security_context_t **arg3 = (security_context_t **) 0 ;
-  int result;
-  int res1 ;
-  char *buf1 = 0 ;
-  int alloc1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  security_context_t *temp3 ;
+  security_context_t *temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  int result;
   
   {
     arg3 = &temp3;
@@ -5239,7 +5417,13 @@
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_user" "', argument " "2"" of type '" "char const *""'");
   }
   arg2 = (char *)(buf2);
-  result = (int)security_compute_user(arg1,(char const *)arg2,arg3);
+  {
+    result = (int)security_compute_user(arg1,(char const *)arg2,arg3); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   {
     PyObject* plist;
@@ -5279,7 +5463,6 @@
   security_context_t arg1 = (security_context_t) 0 ;
   char *arg2 = (char *) 0 ;
   security_context_t **arg3 = (security_context_t **) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
@@ -5289,6 +5472,7 @@
   security_context_t *temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  int result;
   
   {
     arg3 = &temp3;
@@ -5304,7 +5488,13 @@
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_compute_user_raw" "', argument " "2"" of type '" "char const *""'");
   }
   arg2 = (char *)(buf2);
-  result = (int)security_compute_user_raw(arg1,(char const *)arg2,arg3);
+  {
+    result = (int)security_compute_user_raw(arg1,(char const *)arg2,arg3); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   {
     PyObject* plist;
@@ -5343,12 +5533,12 @@
   PyObject *resultobj = 0;
   void *arg1 = (void *) 0 ;
   size_t arg2 ;
-  int result;
   int res1 ;
   size_t val2 ;
   int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:security_load_policy",&obj0,&obj1)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
@@ -5360,7 +5550,13 @@
     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "security_load_policy" "', argument " "2"" of type '" "size_t""'");
   } 
   arg2 = (size_t)(val2);
-  result = (int)security_load_policy(arg1,arg2);
+  {
+    result = (int)security_load_policy(arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -5372,12 +5568,12 @@
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
   security_context_t *arg2 = (security_context_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   security_context_t temp2 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   arg2 = &temp2;
   if (!PyArg_ParseTuple(args,(char *)"O:security_get_initial_context",&obj0)) SWIG_fail;
@@ -5386,7 +5582,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_get_initial_context" "', argument " "1"" of type '" "char const *""'");
   }
   arg1 = (char *)(buf1);
-  result = (int)security_get_initial_context((char const *)arg1,arg2);
+  {
+    result = (int)security_get_initial_context((char const *)arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg2) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg2));
@@ -5408,12 +5610,12 @@
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
   security_context_t *arg2 = (security_context_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   security_context_t temp2 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   arg2 = &temp2;
   if (!PyArg_ParseTuple(args,(char *)"O:security_get_initial_context_raw",&obj0)) SWIG_fail;
@@ -5422,7 +5624,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_get_initial_context_raw" "', argument " "1"" of type '" "char const *""'");
   }
   arg1 = (char *)(buf1);
-  result = (int)security_get_initial_context_raw((char const *)arg1,arg2);
+  {
+    result = (int)security_get_initial_context_raw((char const *)arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg2) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg2));
@@ -5443,10 +5651,10 @@
 SWIGINTERN PyObject *_wrap_selinux_mkload_policy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   int arg1 ;
-  int result;
   int val1 ;
   int ecode1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:selinux_mkload_policy",&obj0)) SWIG_fail;
   ecode1 = SWIG_AsVal_int(obj0, &val1);
@@ -5454,7 +5662,13 @@
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "selinux_mkload_policy" "', argument " "1"" of type '" "int""'");
   } 
   arg1 = (int)(val1);
-  result = (int)selinux_mkload_policy(arg1);
+  {
+    result = (int)selinux_mkload_policy(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -5465,13 +5679,19 @@
 SWIGINTERN PyObject *_wrap_selinux_init_load_policy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   int *arg1 = (int *) 0 ;
-  int result;
   int temp1 ;
   int res1 = SWIG_TMPOBJ ;
+  int result;
   
   arg1 = &temp1;
   if (!PyArg_ParseTuple(args,(char *)":selinux_init_load_policy")) SWIG_fail;
-  result = (int)selinux_init_load_policy(arg1);
+  {
+    result = (int)selinux_init_load_policy(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (SWIG_IsTmpObj(res1)) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
@@ -5527,10 +5747,10 @@
 SWIGINTERN PyObject *_wrap_SELboolean_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   SELboolean *arg1 = (SELboolean *) 0 ;
-  char *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
+  char *result = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:SELboolean_name_get",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SELboolean, 0 |  0 );
@@ -5569,7 +5789,6 @@
   } 
   arg2 = (int)(val2);
   if (arg1) (arg1)->value = arg2;
-  
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -5580,10 +5799,10 @@
 SWIGINTERN PyObject *_wrap_SELboolean_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   SELboolean *arg1 = (SELboolean *) 0 ;
-  int result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:SELboolean_value_get",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SELboolean, 0 |  0 );
@@ -5626,7 +5845,6 @@
   }
   arg1 = (SELboolean *)(argp1);
   free((char *) arg1);
-  
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -5646,7 +5864,6 @@
   size_t arg1 ;
   SELboolean *arg2 = (SELboolean *) 0 ;
   int arg3 ;
-  int result;
   size_t val1 ;
   int ecode1 = 0 ;
   void *argp2 = 0 ;
@@ -5656,6 +5873,7 @@
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"OOO:security_set_boolean_list",&obj0,&obj1,&obj2)) SWIG_fail;
   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
@@ -5673,7 +5891,13 @@
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "security_set_boolean_list" "', argument " "3"" of type '" "int""'");
   } 
   arg3 = (int)(val3);
-  result = (int)security_set_boolean_list(arg1,arg2,arg3);
+  {
+    result = (int)security_set_boolean_list(arg1,arg2,arg3); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -5684,11 +5908,11 @@
 SWIGINTERN PyObject *_wrap_security_load_booleans(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:security_load_booleans",&obj0)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -5696,7 +5920,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_load_booleans" "', argument " "1"" of type '" "char *""'");
   }
   arg1 = (char *)(buf1);
-  result = (int)security_load_booleans(arg1);
+  {
+    result = (int)security_load_booleans(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   return resultobj;
@@ -5709,11 +5939,11 @@
 SWIGINTERN PyObject *_wrap_security_check_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:security_check_context",&obj0)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -5721,7 +5951,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_check_context" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
-  result = (int)security_check_context(arg1);
+  {
+    result = (int)security_check_context(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   return resultobj;
@@ -5734,11 +5970,11 @@
 SWIGINTERN PyObject *_wrap_security_check_context_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:security_check_context_raw",&obj0)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -5746,7 +5982,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_check_context_raw" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
-  result = (int)security_check_context_raw(arg1);
+  {
+    result = (int)security_check_context_raw(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   return resultobj;
@@ -5760,12 +6002,12 @@
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
   security_context_t *arg2 = (security_context_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   security_context_t temp2 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   arg2 = &temp2;
   if (!PyArg_ParseTuple(args,(char *)"O:security_canonicalize_context",&obj0)) SWIG_fail;
@@ -5774,7 +6016,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_canonicalize_context" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
-  result = (int)security_canonicalize_context(arg1,arg2);
+  {
+    result = (int)security_canonicalize_context(arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg2) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg2));
@@ -5796,12 +6044,12 @@
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
   security_context_t *arg2 = (security_context_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   security_context_t temp2 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   arg2 = &temp2;
   if (!PyArg_ParseTuple(args,(char *)"O:security_canonicalize_context_raw",&obj0)) SWIG_fail;
@@ -5810,7 +6058,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_canonicalize_context_raw" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
-  result = (int)security_canonicalize_context_raw(arg1,arg2);
+  {
+    result = (int)security_canonicalize_context_raw(arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg2) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg2));
@@ -5833,7 +6087,13 @@
   int result;
   
   if (!PyArg_ParseTuple(args,(char *)":security_getenforce")) SWIG_fail;
-  result = (int)security_getenforce();
+  {
+    result = (int)security_getenforce(); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -5844,10 +6104,10 @@
 SWIGINTERN PyObject *_wrap_security_setenforce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   int arg1 ;
-  int result;
   int val1 ;
   int ecode1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:security_setenforce",&obj0)) SWIG_fail;
   ecode1 = SWIG_AsVal_int(obj0, &val1);
@@ -5855,7 +6115,13 @@
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "security_setenforce" "', argument " "1"" of type '" "int""'");
   } 
   arg1 = (int)(val1);
-  result = (int)security_setenforce(arg1);
+  {
+    result = (int)security_setenforce(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -5868,7 +6134,13 @@
   int result;
   
   if (!PyArg_ParseTuple(args,(char *)":security_disable")) SWIG_fail;
-  result = (int)security_disable();
+  {
+    result = (int)security_disable(); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -5881,7 +6153,13 @@
   int result;
   
   if (!PyArg_ParseTuple(args,(char *)":security_policyvers")) SWIG_fail;
-  result = (int)security_policyvers();
+  {
+    result = (int)security_policyvers(); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -5893,16 +6171,22 @@
   PyObject *resultobj = 0;
   char ***arg1 = (char ***) 0 ;
   int *arg2 = (int *) 0 ;
-  int result;
   char **temp11 ;
   int temp21 ;
+  int result;
   
   {
     arg1 = &temp11;
     arg2 = &temp21;
   }
   if (!PyArg_ParseTuple(args,(char *)":security_get_boolean_names")) SWIG_fail;
-  result = (int)security_get_boolean_names(arg1,arg2);
+  {
+    result = (int)security_get_boolean_names(arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   {
     PyObject* list = PyList_New(*arg2);
@@ -5939,11 +6223,11 @@
 SWIGINTERN PyObject *_wrap_security_get_boolean_pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:security_get_boolean_pending",&obj0)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -5951,7 +6235,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_get_boolean_pending" "', argument " "1"" of type '" "char const *""'");
   }
   arg1 = (char *)(buf1);
-  result = (int)security_get_boolean_pending((char const *)arg1);
+  {
+    result = (int)security_get_boolean_pending((char const *)arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   return resultobj;
@@ -5964,11 +6254,11 @@
 SWIGINTERN PyObject *_wrap_security_get_boolean_active(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:security_get_boolean_active",&obj0)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -5976,7 +6266,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_get_boolean_active" "', argument " "1"" of type '" "char const *""'");
   }
   arg1 = (char *)(buf1);
-  result = (int)security_get_boolean_active((char const *)arg1);
+  {
+    result = (int)security_get_boolean_active((char const *)arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   return resultobj;
@@ -5990,7 +6286,6 @@
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
   int arg2 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
@@ -5998,6 +6293,7 @@
   int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:security_set_boolean",&obj0,&obj1)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -6010,7 +6306,13 @@
     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "security_set_boolean" "', argument " "2"" of type '" "int""'");
   } 
   arg2 = (int)(val2);
-  result = (int)security_set_boolean((char const *)arg1,arg2);
+  {
+    result = (int)security_set_boolean((char const *)arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   return resultobj;
@@ -6025,7 +6327,13 @@
   int result;
   
   if (!PyArg_ParseTuple(args,(char *)":security_commit_booleans")) SWIG_fail;
-  result = (int)security_commit_booleans();
+  {
+    result = (int)security_commit_booleans(); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -6074,10 +6382,10 @@
 SWIGINTERN PyObject *_wrap_security_class_mapping_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct security_class_mapping *arg1 = (struct security_class_mapping *) 0 ;
-  char *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
+  char *result = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:security_class_mapping_name_get",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_class_mapping, 0 |  0 );
@@ -6133,10 +6441,10 @@
 SWIGINTERN PyObject *_wrap_security_class_mapping_perms_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct security_class_mapping *arg1 = (struct security_class_mapping *) 0 ;
-  char **result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
+  char **result = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:security_class_mapping_perms_get",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_class_mapping, 0 |  0 );
@@ -6179,7 +6487,6 @@
   }
   arg1 = (struct security_class_mapping *)(argp1);
   free((char *) arg1);
-  
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -6194,36 +6501,14 @@
   return SWIG_Py_Void();
 }
 
-SWIGINTERN PyObject *_wrap_selinux_set_mapping(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct security_class_mapping *arg1 = (struct security_class_mapping *) 0 ;
-  int result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:selinux_set_mapping",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_class_mapping, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_set_mapping" "', argument " "1"" of type '" "struct security_class_mapping *""'"); 
-  }
-  arg1 = (struct security_class_mapping *)(argp1);
-  result = (int)selinux_set_mapping(arg1);
-  resultobj = SWIG_From_int((int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_string_to_security_class(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
-  security_class_t result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   PyObject * obj0 = 0 ;
+  security_class_t result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:string_to_security_class",&obj0)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -6244,10 +6529,10 @@
 SWIGINTERN PyObject *_wrap_security_class_to_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_class_t arg1 ;
-  char *result = 0 ;
   unsigned short val1 ;
   int ecode1 = 0 ;
   PyObject * obj0 = 0 ;
+  char *result = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:security_class_to_string",&obj0)) SWIG_fail;
   ecode1 = SWIG_AsVal_unsigned_SS_short(obj0, &val1);
@@ -6267,13 +6552,13 @@
   PyObject *resultobj = 0;
   security_class_t arg1 ;
   access_vector_t arg2 ;
-  char *result = 0 ;
   unsigned short val1 ;
   int ecode1 = 0 ;
   unsigned int val2 ;
   int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  char *result = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:security_av_perm_to_string",&obj0,&obj1)) SWIG_fail;
   ecode1 = SWIG_AsVal_unsigned_SS_short(obj0, &val1);
@@ -6298,7 +6583,6 @@
   PyObject *resultobj = 0;
   security_class_t arg1 ;
   char *arg2 = (char *) 0 ;
-  access_vector_t result;
   unsigned short val1 ;
   int ecode1 = 0 ;
   int res2 ;
@@ -6306,6 +6590,7 @@
   int alloc2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  access_vector_t result;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:string_to_av_perm",&obj0,&obj1)) SWIG_fail;
   ecode1 = SWIG_AsVal_unsigned_SS_short(obj0, &val1);
@@ -6333,7 +6618,6 @@
   security_class_t arg1 ;
   access_vector_t arg2 ;
   char **arg3 = (char **) 0 ;
-  int result;
   unsigned short val1 ;
   int ecode1 = 0 ;
   unsigned int val2 ;
@@ -6341,6 +6625,7 @@
   char *temp3 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  int result;
   
   arg3 = &temp3;
   if (!PyArg_ParseTuple(args,(char *)"OO:security_av_string",&obj0,&obj1)) SWIG_fail;
@@ -6354,7 +6639,13 @@
     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "security_av_string" "', argument " "2"" of type '" "access_vector_t""'");
   } 
   arg2 = (access_vector_t)(val2);
-  result = (int)security_av_string(arg1,arg2,arg3);
+  {
+    result = (int)security_av_string(arg1,arg2,arg3); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg3) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg3));
@@ -6370,65 +6661,14 @@
 }
 
 
-SWIGINTERN PyObject *_wrap_print_access_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  security_class_t arg1 ;
-  access_vector_t arg2 ;
-  unsigned short val1 ;
-  int ecode1 = 0 ;
-  unsigned int val2 ;
-  int ecode2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:print_access_vector",&obj0,&obj1)) SWIG_fail;
-  ecode1 = SWIG_AsVal_unsigned_SS_short(obj0, &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "print_access_vector" "', argument " "1"" of type '" "security_class_t""'");
-  } 
-  arg1 = (security_class_t)(val1);
-  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "print_access_vector" "', argument " "2"" of type '" "access_vector_t""'");
-  } 
-  arg2 = (access_vector_t)(val2);
-  print_access_vector(arg1,arg2);
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_set_matchpathcon_flags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  unsigned int arg1 ;
-  unsigned int val1 ;
-  int ecode1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:set_matchpathcon_flags",&obj0)) SWIG_fail;
-  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "set_matchpathcon_flags" "', argument " "1"" of type '" "unsigned int""'");
-  } 
-  arg1 = (unsigned int)(val1);
-  set_matchpathcon_flags(arg1);
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_matchpathcon_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:matchpathcon_init",&obj0)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -6436,7 +6676,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "matchpathcon_init" "', argument " "1"" of type '" "char const *""'");
   }
   arg1 = (char *)(buf1);
-  result = (int)matchpathcon_init((char const *)arg1);
+  {
+    result = (int)matchpathcon_init((char const *)arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   return resultobj;
@@ -6450,7 +6696,6 @@
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
   char *arg2 = (char *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
@@ -6459,6 +6704,7 @@
   int alloc2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:matchpathcon_init_prefix",&obj0,&obj1)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -6471,7 +6717,13 @@
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "matchpathcon_init_prefix" "', argument " "2"" of type '" "char const *""'");
   }
   arg2 = (char *)(buf2);
-  result = (int)matchpathcon_init_prefix((char const *)arg1,(char const *)arg2);
+  {
+    result = (int)matchpathcon_init_prefix((char const *)arg1,(char const *)arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
@@ -6483,24 +6735,11 @@
 }
 
 
-SWIGINTERN PyObject *_wrap_matchpathcon_fini(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  
-  if (!PyArg_ParseTuple(args,(char *)":matchpathcon_fini")) SWIG_fail;
-  matchpathcon_fini();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_matchpathcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
   mode_t arg2 ;
   security_context_t *arg3 = (security_context_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
@@ -6509,6 +6748,7 @@
   security_context_t temp3 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  int result;
   
   arg3 = &temp3;
   if (!PyArg_ParseTuple(args,(char *)"OO:matchpathcon",&obj0,&obj1)) SWIG_fail;
@@ -6522,7 +6762,13 @@
     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "matchpathcon" "', argument " "2"" of type '" "mode_t""'");
   } 
   arg2 = (mode_t)(val2);
-  result = (int)matchpathcon((char const *)arg1,arg2,arg3);
+  {
+    result = (int)matchpathcon((char const *)arg1,arg2,arg3); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg3) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg3));
@@ -6545,7 +6791,6 @@
   char *arg1 = (char *) 0 ;
   mode_t arg2 ;
   security_context_t *arg3 = (security_context_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
@@ -6554,6 +6799,7 @@
   security_context_t temp3 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  int result;
   
   arg3 = &temp3;
   if (!PyArg_ParseTuple(args,(char *)"OO:matchpathcon_index",&obj0,&obj1)) SWIG_fail;
@@ -6567,7 +6813,13 @@
     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "matchpathcon_index" "', argument " "2"" of type '" "mode_t""'");
   } 
   arg2 = (mode_t)(val2);
-  result = (int)matchpathcon_index((char const *)arg1,arg2,arg3);
+  {
+    result = (int)matchpathcon_index((char const *)arg1,arg2,arg3); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg3) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg3));
@@ -6590,7 +6842,6 @@
   ino_t arg1 ;
   int arg2 ;
   char *arg3 = (char *) 0 ;
-  int result;
   void *argp1 ;
   int res1 = 0 ;
   int val2 ;
@@ -6601,6 +6852,7 @@
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"OOO:matchpathcon_filespec_add",&obj0,&obj1,&obj2)) SWIG_fail;
   {
@@ -6624,7 +6876,13 @@
     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "matchpathcon_filespec_add" "', argument " "3"" of type '" "char const *""'");
   }
   arg3 = (char *)(buf3);
-  result = (int)matchpathcon_filespec_add(arg1,arg2,(char const *)arg3);
+  {
+    result = (int)matchpathcon_filespec_add(arg1,arg2,(char const *)arg3); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   return resultobj;
@@ -6634,64 +6892,16 @@
 }
 
 
-SWIGINTERN PyObject *_wrap_matchpathcon_filespec_destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  
-  if (!PyArg_ParseTuple(args,(char *)":matchpathcon_filespec_destroy")) SWIG_fail;
-  matchpathcon_filespec_destroy();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_matchpathcon_filespec_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  
-  if (!PyArg_ParseTuple(args,(char *)":matchpathcon_filespec_eval")) SWIG_fail;
-  matchpathcon_filespec_eval();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_matchpathcon_checkmatches(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  char *arg1 = (char *) 0 ;
-  int res1 ;
-  char *buf1 = 0 ;
-  int alloc1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:matchpathcon_checkmatches",&obj0)) SWIG_fail;
-  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "matchpathcon_checkmatches" "', argument " "1"" of type '" "char *""'");
-  }
-  arg1 = (char *)(buf1);
-  matchpathcon_checkmatches(arg1);
-  resultobj = SWIG_Py_Void();
-  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
-  return resultobj;
-fail:
-  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_matchmediacon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
   security_context_t *arg2 = (security_context_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   security_context_t temp2 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   arg2 = &temp2;
   if (!PyArg_ParseTuple(args,(char *)"O:matchmediacon",&obj0)) SWIG_fail;
@@ -6700,7 +6910,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "matchmediacon" "', argument " "1"" of type '" "char const *""'");
   }
   arg1 = (char *)(buf1);
-  result = (int)matchmediacon((char const *)arg1,arg2);
+  {
+    result = (int)matchmediacon((char const *)arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg2) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg2));
@@ -6721,13 +6937,19 @@
 SWIGINTERN PyObject *_wrap_selinux_getenforcemode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   int *arg1 = (int *) 0 ;
-  int result;
   int temp1 ;
   int res1 = SWIG_TMPOBJ ;
+  int result;
   
   arg1 = &temp1;
   if (!PyArg_ParseTuple(args,(char *)":selinux_getenforcemode")) SWIG_fail;
-  result = (int)selinux_getenforcemode(arg1);
+  {
+    result = (int)selinux_getenforcemode(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (SWIG_IsTmpObj(res1)) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
@@ -6744,12 +6966,18 @@
 SWIGINTERN PyObject *_wrap_selinux_getpolicytype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   char **arg1 = (char **) 0 ;
-  int result;
   char *temp1 = 0 ;
+  int result;
   
   arg1 = &temp1;
   if (!PyArg_ParseTuple(args,(char *)":selinux_getpolicytype")) SWIG_fail;
-  result = (int)selinux_getpolicytype(arg1);
+  {
+    result = (int)selinux_getpolicytype(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg1) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg1));
@@ -6882,6 +7110,19 @@
 }
 
 
+SWIGINTERN PyObject *_wrap_selinux_file_context_subs_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  char *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":selinux_file_context_subs_path")) SWIG_fail;
+  result = (char *)selinux_file_context_subs_path();
+  resultobj = SWIG_FromCharPtr((const char *)result);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_selinux_homedir_context_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   char *result = 0 ;
@@ -6908,6 +7149,32 @@
 }
 
 
+SWIGINTERN PyObject *_wrap_selinux_virtual_domain_context_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  char *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":selinux_virtual_domain_context_path")) SWIG_fail;
+  result = (char *)selinux_virtual_domain_context_path();
+  resultobj = SWIG_FromCharPtr((const char *)result);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_selinux_virtual_image_context_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  char *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":selinux_virtual_image_context_path")) SWIG_fail;
+  result = (char *)selinux_virtual_image_context_path();
+  resultobj = SWIG_FromCharPtr((const char *)result);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_selinux_x_context_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   char *result = 0 ;
@@ -7054,10 +7321,10 @@
 SWIGINTERN PyObject *_wrap_selinux_check_passwd_access(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   access_vector_t arg1 ;
-  int result;
   unsigned int val1 ;
   int ecode1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:selinux_check_passwd_access",&obj0)) SWIG_fail;
   ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
@@ -7065,7 +7332,13 @@
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "selinux_check_passwd_access" "', argument " "1"" of type '" "access_vector_t""'");
   } 
   arg1 = (access_vector_t)(val1);
-  result = (int)selinux_check_passwd_access(arg1);
+  {
+    result = (int)selinux_check_passwd_access(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -7076,10 +7349,10 @@
 SWIGINTERN PyObject *_wrap_checkPasswdAccess(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   access_vector_t arg1 ;
-  int result;
   unsigned int val1 ;
   int ecode1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:checkPasswdAccess",&obj0)) SWIG_fail;
   ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
@@ -7087,7 +7360,13 @@
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "checkPasswdAccess" "', argument " "1"" of type '" "access_vector_t""'");
   } 
   arg1 = (access_vector_t)(val1);
-  result = (int)checkPasswdAccess(arg1);
+  {
+    result = (int)checkPasswdAccess(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -7098,11 +7377,11 @@
 SWIGINTERN PyObject *_wrap_selinux_check_securetty_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:selinux_check_securetty_context",&obj0)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -7110,32 +7389,14 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_check_securetty_context" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
-  result = (int)selinux_check_securetty_context(arg1);
-  resultobj = SWIG_From_int((int)(result));
-  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
-  return resultobj;
-fail:
-  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_set_selinuxmnt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  char *arg1 = (char *) 0 ;
-  int res1 ;
-  char *buf1 = 0 ;
-  int alloc1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:set_selinuxmnt",&obj0)) SWIG_fail;
-  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_selinuxmnt" "', argument " "1"" of type '" "char *""'");
+  {
+    result = (int)selinux_check_securetty_context(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
   }
-  arg1 = (char *)(buf1);
-  set_selinuxmnt(arg1);
-  resultobj = SWIG_Py_Void();
+  resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   return resultobj;
 fail:
@@ -7150,7 +7411,6 @@
   char *arg2 = (char *) 0 ;
   char **arg3 ;
   char **arg4 ;
-  int result;
   unsigned int val1 ;
   int ecode1 = 0 ;
   int res2 ;
@@ -7160,6 +7420,7 @@
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
   PyObject * obj3 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"OOOO:rpm_execcon",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
@@ -7226,7 +7487,13 @@
     }
     arg4[size] = NULL;
   }
-  result = (int)rpm_execcon(arg1,(char const *)arg2,(char *const (*))arg3,(char *const (*))arg4);
+  {
+    result = (int)rpm_execcon(arg1,(char const *)arg2,(char *const (*))arg3,(char *const (*))arg4); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   {
@@ -7271,11 +7538,11 @@
 SWIGINTERN PyObject *_wrap_is_context_customizable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:is_context_customizable",&obj0)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -7283,7 +7550,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_context_customizable" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
-  result = (int)is_context_customizable(arg1);
+  {
+    result = (int)is_context_customizable(arg1); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   return resultobj;
@@ -7297,12 +7570,12 @@
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
   security_context_t *arg2 = (security_context_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   security_context_t temp2 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   arg2 = &temp2;
   if (!PyArg_ParseTuple(args,(char *)"O:selinux_trans_to_raw_context",&obj0)) SWIG_fail;
@@ -7311,7 +7584,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_trans_to_raw_context" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
-  result = (int)selinux_trans_to_raw_context(arg1,arg2);
+  {
+    result = (int)selinux_trans_to_raw_context(arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg2) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg2));
@@ -7333,12 +7612,12 @@
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
   security_context_t *arg2 = (security_context_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   security_context_t temp2 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   arg2 = &temp2;
   if (!PyArg_ParseTuple(args,(char *)"O:selinux_raw_to_trans_context",&obj0)) SWIG_fail;
@@ -7347,7 +7626,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_raw_to_trans_context" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
-  result = (int)selinux_raw_to_trans_context(arg1,arg2);
+  {
+    result = (int)selinux_raw_to_trans_context(arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg2) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg2));
@@ -7369,12 +7654,12 @@
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
   char **arg2 = (char **) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   char *temp2 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   arg2 = &temp2;
   if (!PyArg_ParseTuple(args,(char *)"O:selinux_raw_context_to_color",&obj0)) SWIG_fail;
@@ -7383,7 +7668,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selinux_raw_context_to_color" "', argument " "1"" of type '" "security_context_t""'");
   }
   arg1 = (security_context_t)(buf1);
-  result = (int)selinux_raw_context_to_color(arg1,arg2);
+  {
+    result = (int)selinux_raw_context_to_color(arg1,arg2); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg2) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg2));
@@ -7406,13 +7697,13 @@
   char *arg1 = (char *) 0 ;
   char **arg2 = (char **) 0 ;
   char **arg3 = (char **) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   char *temp2 = 0 ;
   char *temp3 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   arg2 = &temp2;
   arg3 = &temp3;
@@ -7422,7 +7713,13 @@
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getseuserbyname" "', argument " "1"" of type '" "char const *""'");
   }
   arg1 = (char *)(buf1);
-  result = (int)getseuserbyname((char const *)arg1,arg2,arg3);
+  {
+    result = (int)getseuserbyname((char const *)arg1,arg2,arg3); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
   resultobj = SWIG_From_int((int)(result));
   if (*arg2) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg2));
@@ -7448,11 +7745,75 @@
 }
 
 
+SWIGINTERN PyObject *_wrap_getseuser(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  char *arg1 = (char *) 0 ;
+  char *arg2 = (char *) 0 ;
+  char **arg3 = (char **) 0 ;
+  char **arg4 = (char **) 0 ;
+  int res1 ;
+  char *buf1 = 0 ;
+  int alloc1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  char *temp3 = 0 ;
+  char *temp4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  int result;
+  
+  arg3 = &temp3;
+  arg4 = &temp4;
+  if (!PyArg_ParseTuple(args,(char *)"OO:getseuser",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getseuser" "', argument " "1"" of type '" "char const *""'");
+  }
+  arg1 = (char *)(buf1);
+  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getseuser" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = (char *)(buf2);
+  {
+    result = (int)getseuser((char const *)arg1,(char const *)arg2,arg3,arg4); 
+    if (result < 0) {
+      PyErr_SetFromErrno(PyExc_OSError);
+      return NULL;
+    }
+  }
+  resultobj = SWIG_From_int((int)(result));
+  if (*arg3) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg3));
+    free(*arg3);
+  }
+  else {
+    Py_INCREF(Py_None);
+    resultobj = SWIG_Python_AppendOutput(resultobj, Py_None);
+  }
+  if (*arg4) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(*arg4));
+    free(*arg4);
+  }
+  else {
+    Py_INCREF(Py_None);
+    resultobj = SWIG_Python_AppendOutput(resultobj, Py_None);
+  }
+  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  return resultobj;
+fail:
+  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_selinux_file_context_cmp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) (security_context_t)0 ;
   security_context_t arg2 = (security_context_t) (security_context_t)0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
@@ -7461,6 +7822,7 @@
   int alloc2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:selinux_file_context_cmp",&obj0,&obj1)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -7489,7 +7851,6 @@
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
   mode_t arg2 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
@@ -7497,6 +7858,7 @@
   int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:selinux_file_context_verify",&obj0,&obj1)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -7522,11 +7884,11 @@
 SWIGINTERN PyObject *_wrap_selinux_lsetfilecon_default(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:selinux_lsetfilecon_default",&obj0)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
@@ -7544,171 +7906,15 @@
 }
 
 
-SWIGINTERN PyObject *_wrap_security_id_ctx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct security_id *arg1 = (struct security_id *) 0 ;
-  security_context_t arg2 = (security_context_t) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:security_id_ctx_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_id_ctx_set" "', argument " "1"" of type '" "struct security_id *""'"); 
-  }
-  arg1 = (struct security_id *)(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "security_id_ctx_set" "', argument " "2"" of type '" "security_context_t""'");
-  }
-  arg2 = (security_context_t)(buf2);
-  if (arg1->ctx) free((char*)arg1->ctx);
-  if (arg2) {
-    size_t size = strlen((const char *)(arg2)) + 1;
-    arg1->ctx = (security_context_t)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
-  } else {
-    arg1->ctx = 0;
-  }
-  resultobj = SWIG_Py_Void();
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_security_id_ctx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct security_id *arg1 = (struct security_id *) 0 ;
-  security_context_t result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:security_id_ctx_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_id_ctx_get" "', argument " "1"" of type '" "struct security_id *""'"); 
-  }
-  arg1 = (struct security_id *)(argp1);
-  result = (security_context_t) ((arg1)->ctx);
-  resultobj = SWIG_FromCharPtr((const char *)result);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_security_id_refcnt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct security_id *arg1 = (struct security_id *) 0 ;
-  unsigned int arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  unsigned int val2 ;
-  int ecode2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:security_id_refcnt_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_id_refcnt_set" "', argument " "1"" of type '" "struct security_id *""'"); 
-  }
-  arg1 = (struct security_id *)(argp1);
-  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "security_id_refcnt_set" "', argument " "2"" of type '" "unsigned int""'");
-  } 
-  arg2 = (unsigned int)(val2);
-  if (arg1) (arg1)->refcnt = arg2;
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_security_id_refcnt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct security_id *arg1 = (struct security_id *) 0 ;
-  unsigned int result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:security_id_refcnt_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "security_id_refcnt_get" "', argument " "1"" of type '" "struct security_id *""'"); 
-  }
-  arg1 = (struct security_id *)(argp1);
-  result = (unsigned int) ((arg1)->refcnt);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_new_security_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct security_id *result = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)":new_security_id")) SWIG_fail;
-  result = (struct security_id *)calloc(1, sizeof(struct security_id));
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_security_id, SWIG_POINTER_NEW |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_delete_security_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct security_id *arg1 = (struct security_id *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:delete_security_id",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, SWIG_POINTER_DISOWN |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_security_id" "', argument " "1"" of type '" "struct security_id *""'"); 
-  }
-  arg1 = (struct security_id *)(argp1);
-  free((char *) arg1);
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *security_id_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *obj;
-  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_security_id, SWIG_NewClientData(obj));
-  return SWIG_Py_Void();
-}
-
 SWIGINTERN PyObject *_wrap_avc_sid_to_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_id_t arg1 = (security_id_t) 0 ;
   security_context_t *arg2 = (security_context_t *) 0 ;
-  int result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   security_context_t temp2 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   arg2 = &temp2;
   if (!PyArg_ParseTuple(args,(char *)"O:avc_sid_to_context",&obj0)) SWIG_fail;
@@ -7737,11 +7943,11 @@
   PyObject *resultobj = 0;
   security_id_t arg1 = (security_id_t) 0 ;
   security_context_t *arg2 = (security_context_t *) 0 ;
-  int result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   security_context_t temp2 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   arg2 = &temp2;
   if (!PyArg_ParseTuple(args,(char *)"O:avc_sid_to_context_raw",&obj0)) SWIG_fail;
@@ -7770,12 +7976,12 @@
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
   security_id_t *arg2 = (security_id_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   security_id_t temp2 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   {
     arg2 = &temp2;
@@ -7808,12 +8014,12 @@
   PyObject *resultobj = 0;
   security_context_t arg1 = (security_context_t) 0 ;
   security_id_t *arg2 = (security_id_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   security_id_t temp2 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   {
     arg2 = &temp2;
@@ -7845,10 +8051,10 @@
 SWIGINTERN PyObject *_wrap_sidget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_id_t arg1 = (security_id_t) 0 ;
-  int result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:sidget",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 |  0 );
@@ -7867,10 +8073,10 @@
 SWIGINTERN PyObject *_wrap_sidput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   security_id_t arg1 = (security_id_t) 0 ;
-  int result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   if (!PyArg_ParseTuple(args,(char *)"O:sidput",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 |  0 );
@@ -7890,12 +8096,12 @@
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
   security_id_t *arg2 = (security_id_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   security_id_t temp2 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   {
     arg2 = &temp2;
@@ -7924,1587 +8130,70 @@
 }
 
 
-SWIGINTERN PyObject *_wrap_avc_entry_ref_ae_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_avc_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  struct avc_entry_ref *arg1 = (struct avc_entry_ref *) 0 ;
-  struct avc_entry *arg2 = (struct avc_entry *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:avc_entry_ref_ae_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_entry_ref, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_entry_ref_ae_set" "', argument " "1"" of type '" "struct avc_entry_ref *""'"); 
-  }
-  arg1 = (struct avc_entry_ref *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_avc_entry, SWIG_POINTER_DISOWN |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "avc_entry_ref_ae_set" "', argument " "2"" of type '" "struct avc_entry *""'"); 
-  }
-  arg2 = (struct avc_entry *)(argp2);
-  if (arg1) (arg1)->ae = arg2;
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_entry_ref_ae_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_entry_ref *arg1 = (struct avc_entry_ref *) 0 ;
-  struct avc_entry *result = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:avc_entry_ref_ae_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_entry_ref, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_entry_ref_ae_get" "', argument " "1"" of type '" "struct avc_entry_ref *""'"); 
-  }
-  arg1 = (struct avc_entry_ref *)(argp1);
-  result = (struct avc_entry *) ((arg1)->ae);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_avc_entry, 0 |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_new_avc_entry_ref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_entry_ref *result = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)":new_avc_entry_ref")) SWIG_fail;
-  result = (struct avc_entry_ref *)calloc(1, sizeof(struct avc_entry_ref));
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_avc_entry_ref, SWIG_POINTER_NEW |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_delete_avc_entry_ref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_entry_ref *arg1 = (struct avc_entry_ref *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:delete_avc_entry_ref",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_entry_ref, SWIG_POINTER_DISOWN |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_avc_entry_ref" "', argument " "1"" of type '" "struct avc_entry_ref *""'"); 
-  }
-  arg1 = (struct avc_entry_ref *)(argp1);
-  free((char *) arg1);
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *avc_entry_ref_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *obj;
-  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_avc_entry_ref, SWIG_NewClientData(obj));
-  return SWIG_Py_Void();
-}
-
-SWIGINTERN PyObject *_wrap_avc_memory_callback_func_malloc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_memory_callback *arg1 = (struct avc_memory_callback *) 0 ;
-  void *(*arg2)(size_t) = (void *(*)(size_t)) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:avc_memory_callback_func_malloc_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_memory_callback, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_memory_callback_func_malloc_set" "', argument " "1"" of type '" "struct avc_memory_callback *""'"); 
-  }
-  arg1 = (struct avc_memory_callback *)(argp1);
-  {
-    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_size_t__p_void);
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "avc_memory_callback_func_malloc_set" "', argument " "2"" of type '" "void *(*)(size_t)""'"); 
-    }
-  }
-  if (arg1) (arg1)->func_malloc = arg2;
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_memory_callback_func_malloc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_memory_callback *arg1 = (struct avc_memory_callback *) 0 ;
-  void *(*result)(size_t) = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:avc_memory_callback_func_malloc_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_memory_callback, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_memory_callback_func_malloc_get" "', argument " "1"" of type '" "struct avc_memory_callback *""'"); 
-  }
-  arg1 = (struct avc_memory_callback *)(argp1);
-  result = (void *(*)(size_t)) ((arg1)->func_malloc);
-  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_size_t__p_void);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_memory_callback_func_free_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_memory_callback *arg1 = (struct avc_memory_callback *) 0 ;
-  void (*arg2)(void *) = (void (*)(void *)) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:avc_memory_callback_func_free_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_memory_callback, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_memory_callback_func_free_set" "', argument " "1"" of type '" "struct avc_memory_callback *""'"); 
-  }
-  arg1 = (struct avc_memory_callback *)(argp1);
-  {
-    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__void);
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "avc_memory_callback_func_free_set" "', argument " "2"" of type '" "void (*)(void *)""'"); 
-    }
-  }
-  if (arg1) (arg1)->func_free = arg2;
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_memory_callback_func_free_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_memory_callback *arg1 = (struct avc_memory_callback *) 0 ;
-  void (*result)(void *) = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:avc_memory_callback_func_free_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_memory_callback, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_memory_callback_func_free_get" "', argument " "1"" of type '" "struct avc_memory_callback *""'"); 
-  }
-  arg1 = (struct avc_memory_callback *)(argp1);
-  result = (void (*)(void *)) ((arg1)->func_free);
-  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__void);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_new_avc_memory_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_memory_callback *result = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)":new_avc_memory_callback")) SWIG_fail;
-  result = (struct avc_memory_callback *)calloc(1, sizeof(struct avc_memory_callback));
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_avc_memory_callback, SWIG_POINTER_NEW |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_delete_avc_memory_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_memory_callback *arg1 = (struct avc_memory_callback *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:delete_avc_memory_callback",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_memory_callback, SWIG_POINTER_DISOWN |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_avc_memory_callback" "', argument " "1"" of type '" "struct avc_memory_callback *""'"); 
-  }
-  arg1 = (struct avc_memory_callback *)(argp1);
-  free((char *) arg1);
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *avc_memory_callback_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *obj;
-  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_avc_memory_callback, SWIG_NewClientData(obj));
-  return SWIG_Py_Void();
-}
-
-SWIGINTERN PyObject *_wrap_avc_log_callback_func_log_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_log_callback *arg1 = (struct avc_log_callback *) 0 ;
-  void (*arg2)(char const *,...) = (void (*)(char const *,...)) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:avc_log_callback_func_log_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_log_callback, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_log_callback_func_log_set" "', argument " "1"" of type '" "struct avc_log_callback *""'"); 
-  }
-  arg1 = (struct avc_log_callback *)(argp1);
-  {
-    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__char_v_______void);
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "avc_log_callback_func_log_set" "', argument " "2"" of type '" "void (*)(char const *,...)""'"); 
-    }
-  }
-  if (arg1) (arg1)->func_log = arg2;
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_log_callback_func_log_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_log_callback *arg1 = (struct avc_log_callback *) 0 ;
-  void (*result)(char const *,...) = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:avc_log_callback_func_log_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_log_callback, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_log_callback_func_log_get" "', argument " "1"" of type '" "struct avc_log_callback *""'"); 
-  }
-  arg1 = (struct avc_log_callback *)(argp1);
-  result = (void (*)(char const *,...)) ((arg1)->func_log);
-  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_v_______void);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_log_callback_func_audit_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_log_callback *arg1 = (struct avc_log_callback *) 0 ;
-  void (*arg2)(void *,security_class_t,char *,size_t) = (void (*)(void *,security_class_t,char *,size_t)) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:avc_log_callback_func_audit_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_log_callback, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_log_callback_func_audit_set" "', argument " "1"" of type '" "struct avc_log_callback *""'"); 
-  }
-  arg1 = (struct avc_log_callback *)(argp1);
-  {
-    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_unsigned_short_p_char_size_t__void);
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "avc_log_callback_func_audit_set" "', argument " "2"" of type '" "void (*)(void *,security_class_t,char *,size_t)""'"); 
-    }
-  }
-  if (arg1) (arg1)->func_audit = arg2;
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_log_callback_func_audit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_log_callback *arg1 = (struct avc_log_callback *) 0 ;
-  void (*result)(void *,security_class_t,char *,size_t) = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:avc_log_callback_func_audit_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_log_callback, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_log_callback_func_audit_get" "', argument " "1"" of type '" "struct avc_log_callback *""'"); 
-  }
-  arg1 = (struct avc_log_callback *)(argp1);
-  result = (void (*)(void *,security_class_t,char *,size_t)) ((arg1)->func_audit);
-  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_unsigned_short_p_char_size_t__void);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_new_avc_log_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_log_callback *result = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)":new_avc_log_callback")) SWIG_fail;
-  result = (struct avc_log_callback *)calloc(1, sizeof(struct avc_log_callback));
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_avc_log_callback, SWIG_POINTER_NEW |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_delete_avc_log_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_log_callback *arg1 = (struct avc_log_callback *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:delete_avc_log_callback",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_log_callback, SWIG_POINTER_DISOWN |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_avc_log_callback" "', argument " "1"" of type '" "struct avc_log_callback *""'"); 
-  }
-  arg1 = (struct avc_log_callback *)(argp1);
-  free((char *) arg1);
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *avc_log_callback_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *obj;
-  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_avc_log_callback, SWIG_NewClientData(obj));
-  return SWIG_Py_Void();
-}
-
-SWIGINTERN PyObject *_wrap_avc_thread_callback_func_create_thread_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_thread_callback *arg1 = (struct avc_thread_callback *) 0 ;
-  void *(*arg2)(void (*)(void)) = (void *(*)(void (*)(void))) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:avc_thread_callback_func_create_thread_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_thread_callback, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_thread_callback_func_create_thread_set" "', argument " "1"" of type '" "struct avc_thread_callback *""'"); 
-  }
-  arg1 = (struct avc_thread_callback *)(argp1);
-  {
-    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_f_void__void__p_void);
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "avc_thread_callback_func_create_thread_set" "', argument " "2"" of type '" "void *(*)(void (*)(void))""'"); 
-    }
-  }
-  if (arg1) (arg1)->func_create_thread = arg2;
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_thread_callback_func_create_thread_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_thread_callback *arg1 = (struct avc_thread_callback *) 0 ;
-  void *(*result)(void (*)(void)) = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:avc_thread_callback_func_create_thread_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_thread_callback, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_thread_callback_func_create_thread_get" "', argument " "1"" of type '" "struct avc_thread_callback *""'"); 
-  }
-  arg1 = (struct avc_thread_callback *)(argp1);
-  result = (void *(*)(void (*)(void))) ((arg1)->func_create_thread);
-  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_f_void__void__p_void);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_thread_callback_func_stop_thread_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_thread_callback *arg1 = (struct avc_thread_callback *) 0 ;
-  void (*arg2)(void *) = (void (*)(void *)) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:avc_thread_callback_func_stop_thread_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_thread_callback, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_thread_callback_func_stop_thread_set" "', argument " "1"" of type '" "struct avc_thread_callback *""'"); 
-  }
-  arg1 = (struct avc_thread_callback *)(argp1);
-  {
-    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__void);
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "avc_thread_callback_func_stop_thread_set" "', argument " "2"" of type '" "void (*)(void *)""'"); 
-    }
-  }
-  if (arg1) (arg1)->func_stop_thread = arg2;
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_thread_callback_func_stop_thread_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_thread_callback *arg1 = (struct avc_thread_callback *) 0 ;
-  void (*result)(void *) = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:avc_thread_callback_func_stop_thread_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_thread_callback, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_thread_callback_func_stop_thread_get" "', argument " "1"" of type '" "struct avc_thread_callback *""'"); 
-  }
-  arg1 = (struct avc_thread_callback *)(argp1);
-  result = (void (*)(void *)) ((arg1)->func_stop_thread);
-  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__void);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_new_avc_thread_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_thread_callback *result = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)":new_avc_thread_callback")) SWIG_fail;
-  result = (struct avc_thread_callback *)calloc(1, sizeof(struct avc_thread_callback));
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_avc_thread_callback, SWIG_POINTER_NEW |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_delete_avc_thread_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_thread_callback *arg1 = (struct avc_thread_callback *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:delete_avc_thread_callback",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_thread_callback, SWIG_POINTER_DISOWN |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_avc_thread_callback" "', argument " "1"" of type '" "struct avc_thread_callback *""'"); 
-  }
-  arg1 = (struct avc_thread_callback *)(argp1);
-  free((char *) arg1);
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *avc_thread_callback_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *obj;
-  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_avc_thread_callback, SWIG_NewClientData(obj));
-  return SWIG_Py_Void();
-}
-
-SWIGINTERN PyObject *_wrap_avc_lock_callback_func_alloc_lock_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_lock_callback *arg1 = (struct avc_lock_callback *) 0 ;
-  void *(*arg2)(void) = (void *(*)(void)) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:avc_lock_callback_func_alloc_lock_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_lock_callback, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_lock_callback_func_alloc_lock_set" "', argument " "1"" of type '" "struct avc_lock_callback *""'"); 
-  }
-  arg1 = (struct avc_lock_callback *)(argp1);
-  {
-    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_void__p_void);
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "avc_lock_callback_func_alloc_lock_set" "', argument " "2"" of type '" "void *(*)(void)""'"); 
-    }
-  }
-  if (arg1) (arg1)->func_alloc_lock = arg2;
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_lock_callback_func_alloc_lock_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_lock_callback *arg1 = (struct avc_lock_callback *) 0 ;
-  void *(*result)(void) = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:avc_lock_callback_func_alloc_lock_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_lock_callback, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_lock_callback_func_alloc_lock_get" "', argument " "1"" of type '" "struct avc_lock_callback *""'"); 
-  }
-  arg1 = (struct avc_lock_callback *)(argp1);
-  result = (void *(*)(void)) ((arg1)->func_alloc_lock);
-  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_void__p_void);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_lock_callback_func_get_lock_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_lock_callback *arg1 = (struct avc_lock_callback *) 0 ;
-  void (*arg2)(void *) = (void (*)(void *)) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:avc_lock_callback_func_get_lock_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_lock_callback, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_lock_callback_func_get_lock_set" "', argument " "1"" of type '" "struct avc_lock_callback *""'"); 
-  }
-  arg1 = (struct avc_lock_callback *)(argp1);
-  {
-    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__void);
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "avc_lock_callback_func_get_lock_set" "', argument " "2"" of type '" "void (*)(void *)""'"); 
-    }
-  }
-  if (arg1) (arg1)->func_get_lock = arg2;
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_lock_callback_func_get_lock_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_lock_callback *arg1 = (struct avc_lock_callback *) 0 ;
-  void (*result)(void *) = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:avc_lock_callback_func_get_lock_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_lock_callback, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_lock_callback_func_get_lock_get" "', argument " "1"" of type '" "struct avc_lock_callback *""'"); 
-  }
-  arg1 = (struct avc_lock_callback *)(argp1);
-  result = (void (*)(void *)) ((arg1)->func_get_lock);
-  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__void);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_lock_callback_func_release_lock_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_lock_callback *arg1 = (struct avc_lock_callback *) 0 ;
-  void (*arg2)(void *) = (void (*)(void *)) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:avc_lock_callback_func_release_lock_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_lock_callback, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_lock_callback_func_release_lock_set" "', argument " "1"" of type '" "struct avc_lock_callback *""'"); 
-  }
-  arg1 = (struct avc_lock_callback *)(argp1);
-  {
-    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__void);
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "avc_lock_callback_func_release_lock_set" "', argument " "2"" of type '" "void (*)(void *)""'"); 
-    }
-  }
-  if (arg1) (arg1)->func_release_lock = arg2;
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_lock_callback_func_release_lock_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_lock_callback *arg1 = (struct avc_lock_callback *) 0 ;
-  void (*result)(void *) = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:avc_lock_callback_func_release_lock_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_lock_callback, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_lock_callback_func_release_lock_get" "', argument " "1"" of type '" "struct avc_lock_callback *""'"); 
-  }
-  arg1 = (struct avc_lock_callback *)(argp1);
-  result = (void (*)(void *)) ((arg1)->func_release_lock);
-  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__void);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_lock_callback_func_free_lock_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_lock_callback *arg1 = (struct avc_lock_callback *) 0 ;
-  void (*arg2)(void *) = (void (*)(void *)) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:avc_lock_callback_func_free_lock_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_lock_callback, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_lock_callback_func_free_lock_set" "', argument " "1"" of type '" "struct avc_lock_callback *""'"); 
-  }
-  arg1 = (struct avc_lock_callback *)(argp1);
-  {
-    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__void);
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "avc_lock_callback_func_free_lock_set" "', argument " "2"" of type '" "void (*)(void *)""'"); 
-    }
-  }
-  if (arg1) (arg1)->func_free_lock = arg2;
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_lock_callback_func_free_lock_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_lock_callback *arg1 = (struct avc_lock_callback *) 0 ;
-  void (*result)(void *) = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:avc_lock_callback_func_free_lock_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_lock_callback, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_lock_callback_func_free_lock_get" "', argument " "1"" of type '" "struct avc_lock_callback *""'"); 
-  }
-  arg1 = (struct avc_lock_callback *)(argp1);
-  result = (void (*)(void *)) ((arg1)->func_free_lock);
-  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__void);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_new_avc_lock_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_lock_callback *result = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)":new_avc_lock_callback")) SWIG_fail;
-  result = (struct avc_lock_callback *)calloc(1, sizeof(struct avc_lock_callback));
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_avc_lock_callback, SWIG_POINTER_NEW |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_delete_avc_lock_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_lock_callback *arg1 = (struct avc_lock_callback *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:delete_avc_lock_callback",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_lock_callback, SWIG_POINTER_DISOWN |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_avc_lock_callback" "', argument " "1"" of type '" "struct avc_lock_callback *""'"); 
-  }
-  arg1 = (struct avc_lock_callback *)(argp1);
-  free((char *) arg1);
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *avc_lock_callback_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *obj;
-  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_avc_lock_callback, SWIG_NewClientData(obj));
-  return SWIG_Py_Void();
-}
-
-SWIGINTERN PyObject *_wrap_avc_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  char *arg1 = (char *) 0 ;
-  struct avc_memory_callback *arg2 = (struct avc_memory_callback *) 0 ;
-  struct avc_log_callback *arg3 = (struct avc_log_callback *) 0 ;
-  struct avc_thread_callback *arg4 = (struct avc_thread_callback *) 0 ;
-  struct avc_lock_callback *arg5 = (struct avc_lock_callback *) 0 ;
-  int result;
-  int res1 ;
-  char *buf1 = 0 ;
-  int alloc1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
-  void *argp4 = 0 ;
-  int res4 = 0 ;
-  void *argp5 = 0 ;
-  int res5 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  PyObject * obj4 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOOOO:avc_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
-  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_init" "', argument " "1"" of type '" "char const *""'");
-  }
-  arg1 = (char *)(buf1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_avc_memory_callback, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "avc_init" "', argument " "2"" of type '" "struct avc_memory_callback const *""'"); 
-  }
-  arg2 = (struct avc_memory_callback *)(argp2);
-  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_avc_log_callback, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "avc_init" "', argument " "3"" of type '" "struct avc_log_callback const *""'"); 
-  }
-  arg3 = (struct avc_log_callback *)(argp3);
-  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_avc_thread_callback, 0 |  0 );
-  if (!SWIG_IsOK(res4)) {
-    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "avc_init" "', argument " "4"" of type '" "struct avc_thread_callback const *""'"); 
-  }
-  arg4 = (struct avc_thread_callback *)(argp4);
-  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_avc_lock_callback, 0 |  0 );
-  if (!SWIG_IsOK(res5)) {
-    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "avc_init" "', argument " "5"" of type '" "struct avc_lock_callback const *""'"); 
-  }
-  arg5 = (struct avc_lock_callback *)(argp5);
-  result = (int)avc_init((char const *)arg1,(struct avc_memory_callback const *)arg2,(struct avc_log_callback const *)arg3,(struct avc_thread_callback const *)arg4,(struct avc_lock_callback const *)arg5);
-  resultobj = SWIG_From_int((int)(result));
-  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
-  return resultobj;
-fail:
-  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct selinux_opt *arg1 = (struct selinux_opt *) 0 ;
-  unsigned int arg2 ;
-  int result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  unsigned int val2 ;
-  int ecode2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:avc_open",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_selinux_opt, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_open" "', argument " "1"" of type '" "struct selinux_opt *""'"); 
-  }
-  arg1 = (struct selinux_opt *)(argp1);
-  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "avc_open" "', argument " "2"" of type '" "unsigned int""'");
-  } 
-  arg2 = (unsigned int)(val2);
-  result = (int)avc_open(arg1,arg2);
-  resultobj = SWIG_From_int((int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_cleanup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  
-  if (!PyArg_ParseTuple(args,(char *)":avc_cleanup")) SWIG_fail;
-  avc_cleanup();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  int result;
-  
-  if (!PyArg_ParseTuple(args,(char *)":avc_reset")) SWIG_fail;
-  result = (int)avc_reset();
-  resultobj = SWIG_From_int((int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  
-  if (!PyArg_ParseTuple(args,(char *)":avc_destroy")) SWIG_fail;
-  avc_destroy();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_has_perm_noaudit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  security_id_t arg1 = (security_id_t) 0 ;
-  security_id_t arg2 = (security_id_t) 0 ;
-  security_class_t arg3 ;
-  access_vector_t arg4 ;
-  struct avc_entry_ref *arg5 = (struct avc_entry_ref *) 0 ;
-  struct av_decision *arg6 = (struct av_decision *) 0 ;
-  int result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  unsigned short val3 ;
-  int ecode3 = 0 ;
-  unsigned int val4 ;
-  int ecode4 = 0 ;
-  void *argp5 = 0 ;
-  int res5 = 0 ;
-  void *argp6 = 0 ;
-  int res6 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  PyObject * obj4 = 0 ;
-  PyObject * obj5 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:avc_has_perm_noaudit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_has_perm_noaudit" "', argument " "1"" of type '" "security_id_t""'"); 
-  }
-  arg1 = (security_id_t)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_security_id, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "avc_has_perm_noaudit" "', argument " "2"" of type '" "security_id_t""'"); 
-  }
-  arg2 = (security_id_t)(argp2);
-  ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "avc_has_perm_noaudit" "', argument " "3"" of type '" "security_class_t""'");
-  } 
-  arg3 = (security_class_t)(val3);
-  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
-  if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "avc_has_perm_noaudit" "', argument " "4"" of type '" "access_vector_t""'");
-  } 
-  arg4 = (access_vector_t)(val4);
-  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_avc_entry_ref, 0 |  0 );
-  if (!SWIG_IsOK(res5)) {
-    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "avc_has_perm_noaudit" "', argument " "5"" of type '" "struct avc_entry_ref *""'"); 
-  }
-  arg5 = (struct avc_entry_ref *)(argp5);
-  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_av_decision, 0 |  0 );
-  if (!SWIG_IsOK(res6)) {
-    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "avc_has_perm_noaudit" "', argument " "6"" of type '" "struct av_decision *""'"); 
-  }
-  arg6 = (struct av_decision *)(argp6);
-  result = (int)avc_has_perm_noaudit(arg1,arg2,arg3,arg4,arg5,arg6);
-  resultobj = SWIG_From_int((int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_has_perm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  security_id_t arg1 = (security_id_t) 0 ;
-  security_id_t arg2 = (security_id_t) 0 ;
-  security_class_t arg3 ;
-  access_vector_t arg4 ;
-  struct avc_entry_ref *arg5 = (struct avc_entry_ref *) 0 ;
-  void *arg6 = (void *) 0 ;
-  int result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  unsigned short val3 ;
-  int ecode3 = 0 ;
-  unsigned int val4 ;
-  int ecode4 = 0 ;
-  void *argp5 = 0 ;
-  int res5 = 0 ;
-  int res6 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  PyObject * obj4 = 0 ;
-  PyObject * obj5 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:avc_has_perm",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_has_perm" "', argument " "1"" of type '" "security_id_t""'"); 
-  }
-  arg1 = (security_id_t)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_security_id, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "avc_has_perm" "', argument " "2"" of type '" "security_id_t""'"); 
-  }
-  arg2 = (security_id_t)(argp2);
-  ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "avc_has_perm" "', argument " "3"" of type '" "security_class_t""'");
-  } 
-  arg3 = (security_class_t)(val3);
-  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
-  if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "avc_has_perm" "', argument " "4"" of type '" "access_vector_t""'");
-  } 
-  arg4 = (access_vector_t)(val4);
-  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_avc_entry_ref, 0 |  0 );
-  if (!SWIG_IsOK(res5)) {
-    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "avc_has_perm" "', argument " "5"" of type '" "struct avc_entry_ref *""'"); 
-  }
-  arg5 = (struct avc_entry_ref *)(argp5);
-  res6 = SWIG_ConvertPtr(obj5,SWIG_as_voidptrptr(&arg6), 0, 0);
-  if (!SWIG_IsOK(res6)) {
-    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "avc_has_perm" "', argument " "6"" of type '" "void *""'"); 
-  }
-  result = (int)avc_has_perm(arg1,arg2,arg3,arg4,arg5,arg6);
-  resultobj = SWIG_From_int((int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_audit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  security_id_t arg1 = (security_id_t) 0 ;
-  security_id_t arg2 = (security_id_t) 0 ;
-  security_class_t arg3 ;
-  access_vector_t arg4 ;
-  struct av_decision *arg5 = (struct av_decision *) 0 ;
-  int arg6 ;
-  void *arg7 = (void *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  unsigned short val3 ;
-  int ecode3 = 0 ;
-  unsigned int val4 ;
-  int ecode4 = 0 ;
-  void *argp5 = 0 ;
-  int res5 = 0 ;
-  int val6 ;
-  int ecode6 = 0 ;
-  int res7 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  PyObject * obj4 = 0 ;
-  PyObject * obj5 = 0 ;
-  PyObject * obj6 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:avc_audit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_audit" "', argument " "1"" of type '" "security_id_t""'"); 
-  }
-  arg1 = (security_id_t)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_security_id, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "avc_audit" "', argument " "2"" of type '" "security_id_t""'"); 
-  }
-  arg2 = (security_id_t)(argp2);
-  ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "avc_audit" "', argument " "3"" of type '" "security_class_t""'");
-  } 
-  arg3 = (security_class_t)(val3);
-  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
-  if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "avc_audit" "', argument " "4"" of type '" "access_vector_t""'");
-  } 
-  arg4 = (access_vector_t)(val4);
-  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_av_decision, 0 |  0 );
-  if (!SWIG_IsOK(res5)) {
-    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "avc_audit" "', argument " "5"" of type '" "struct av_decision *""'"); 
-  }
-  arg5 = (struct av_decision *)(argp5);
-  ecode6 = SWIG_AsVal_int(obj5, &val6);
-  if (!SWIG_IsOK(ecode6)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "avc_audit" "', argument " "6"" of type '" "int""'");
-  } 
-  arg6 = (int)(val6);
-  res7 = SWIG_ConvertPtr(obj6,SWIG_as_voidptrptr(&arg7), 0, 0);
-  if (!SWIG_IsOK(res7)) {
-    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "avc_audit" "', argument " "7"" of type '" "void *""'"); 
-  }
-  avc_audit(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_compute_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  security_id_t arg1 = (security_id_t) 0 ;
-  security_id_t arg2 = (security_id_t) 0 ;
-  security_class_t arg3 ;
-  security_id_t *arg4 = (security_id_t *) 0 ;
-  int result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  unsigned short val3 ;
-  int ecode3 = 0 ;
-  security_id_t temp4 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  
-  {
-    arg4 = &temp4;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OOO:avc_compute_create",&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_compute_create" "', argument " "1"" of type '" "security_id_t""'"); 
-  }
-  arg1 = (security_id_t)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_security_id, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "avc_compute_create" "', argument " "2"" of type '" "security_id_t""'"); 
-  }
-  arg2 = (security_id_t)(argp2);
-  ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "avc_compute_create" "', argument " "3"" of type '" "security_class_t""'");
-  } 
-  arg3 = (security_class_t)(val3);
-  result = (int)avc_compute_create(arg1,arg2,arg3,arg4);
-  resultobj = SWIG_From_int((int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_compute_member(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  security_id_t arg1 = (security_id_t) 0 ;
-  security_id_t arg2 = (security_id_t) 0 ;
-  security_class_t arg3 ;
-  security_id_t *arg4 = (security_id_t *) 0 ;
-  int result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  unsigned short val3 ;
-  int ecode3 = 0 ;
-  security_id_t temp4 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  
-  {
-    arg4 = &temp4;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OOO:avc_compute_member",&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_compute_member" "', argument " "1"" of type '" "security_id_t""'"); 
-  }
-  arg1 = (security_id_t)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_security_id, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "avc_compute_member" "', argument " "2"" of type '" "security_id_t""'"); 
-  }
-  arg2 = (security_id_t)(argp2);
-  ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "avc_compute_member" "', argument " "3"" of type '" "security_class_t""'");
-  } 
-  arg3 = (security_class_t)(val3);
-  result = (int)avc_compute_member(arg1,arg2,arg3,arg4);
-  resultobj = SWIG_From_int((int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_cache_stats_entry_lookups_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ;
-  unsigned int arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  unsigned int val2 ;
-  int ecode2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:avc_cache_stats_entry_lookups_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_entry_lookups_set" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); 
-  }
-  arg1 = (struct avc_cache_stats *)(argp1);
-  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "avc_cache_stats_entry_lookups_set" "', argument " "2"" of type '" "unsigned int""'");
-  } 
-  arg2 = (unsigned int)(val2);
-  if (arg1) (arg1)->entry_lookups = arg2;
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_cache_stats_entry_lookups_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ;
-  unsigned int result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:avc_cache_stats_entry_lookups_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_entry_lookups_get" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); 
-  }
-  arg1 = (struct avc_cache_stats *)(argp1);
-  result = (unsigned int) ((arg1)->entry_lookups);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_cache_stats_entry_hits_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ;
-  unsigned int arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  unsigned int val2 ;
-  int ecode2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:avc_cache_stats_entry_hits_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_entry_hits_set" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); 
-  }
-  arg1 = (struct avc_cache_stats *)(argp1);
-  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "avc_cache_stats_entry_hits_set" "', argument " "2"" of type '" "unsigned int""'");
-  } 
-  arg2 = (unsigned int)(val2);
-  if (arg1) (arg1)->entry_hits = arg2;
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_cache_stats_entry_hits_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ;
-  unsigned int result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:avc_cache_stats_entry_hits_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_entry_hits_get" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); 
-  }
-  arg1 = (struct avc_cache_stats *)(argp1);
-  result = (unsigned int) ((arg1)->entry_hits);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_cache_stats_entry_misses_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ;
-  unsigned int arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  unsigned int val2 ;
-  int ecode2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:avc_cache_stats_entry_misses_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_entry_misses_set" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); 
-  }
-  arg1 = (struct avc_cache_stats *)(argp1);
-  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "avc_cache_stats_entry_misses_set" "', argument " "2"" of type '" "unsigned int""'");
-  } 
-  arg2 = (unsigned int)(val2);
-  if (arg1) (arg1)->entry_misses = arg2;
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_cache_stats_entry_misses_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ;
-  unsigned int result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:avc_cache_stats_entry_misses_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_entry_misses_get" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); 
-  }
-  arg1 = (struct avc_cache_stats *)(argp1);
-  result = (unsigned int) ((arg1)->entry_misses);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_cache_stats_entry_discards_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ;
-  unsigned int arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  unsigned int val2 ;
-  int ecode2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:avc_cache_stats_entry_discards_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_entry_discards_set" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); 
-  }
-  arg1 = (struct avc_cache_stats *)(argp1);
-  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "avc_cache_stats_entry_discards_set" "', argument " "2"" of type '" "unsigned int""'");
-  } 
-  arg2 = (unsigned int)(val2);
-  if (arg1) (arg1)->entry_discards = arg2;
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_cache_stats_entry_discards_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ;
-  unsigned int result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:avc_cache_stats_entry_discards_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_entry_discards_get" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); 
-  }
-  arg1 = (struct avc_cache_stats *)(argp1);
-  result = (unsigned int) ((arg1)->entry_discards);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_cache_stats_cav_lookups_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ;
-  unsigned int arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  unsigned int val2 ;
-  int ecode2 = 0 ;
+  char *arg1 = (char *) 0 ;
+  struct avc_memory_callback *arg2 = (struct avc_memory_callback *) 0 ;
+  struct avc_log_callback *arg3 = (struct avc_log_callback *) 0 ;
+  struct avc_thread_callback *arg4 = (struct avc_thread_callback *) 0 ;
+  struct avc_lock_callback *arg5 = (struct avc_lock_callback *) 0 ;
+  int res1 ;
+  char *buf1 = 0 ;
+  int alloc1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  int result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:avc_cache_stats_cav_lookups_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_cav_lookups_set" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); 
-  }
-  arg1 = (struct avc_cache_stats *)(argp1);
-  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "avc_cache_stats_cav_lookups_set" "', argument " "2"" of type '" "unsigned int""'");
-  } 
-  arg2 = (unsigned int)(val2);
-  if (arg1) (arg1)->cav_lookups = arg2;
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_cache_stats_cav_lookups_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ;
-  unsigned int result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:avc_cache_stats_cav_lookups_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:avc_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_cav_lookups_get" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_init" "', argument " "1"" of type '" "char const *""'");
   }
-  arg1 = (struct avc_cache_stats *)(argp1);
-  result = (unsigned int) ((arg1)->cav_lookups);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_cache_stats_cav_hits_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ;
-  unsigned int arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  unsigned int val2 ;
-  int ecode2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:avc_cache_stats_cav_hits_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_cav_hits_set" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); 
+  arg1 = (char *)(buf1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_avc_memory_callback, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "avc_init" "', argument " "2"" of type '" "struct avc_memory_callback const *""'"); 
   }
-  arg1 = (struct avc_cache_stats *)(argp1);
-  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "avc_cache_stats_cav_hits_set" "', argument " "2"" of type '" "unsigned int""'");
-  } 
-  arg2 = (unsigned int)(val2);
-  if (arg1) (arg1)->cav_hits = arg2;
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_cache_stats_cav_hits_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ;
-  unsigned int result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:avc_cache_stats_cav_hits_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_cav_hits_get" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); 
+  arg2 = (struct avc_memory_callback *)(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_avc_log_callback, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "avc_init" "', argument " "3"" of type '" "struct avc_log_callback const *""'"); 
   }
-  arg1 = (struct avc_cache_stats *)(argp1);
-  result = (unsigned int) ((arg1)->cav_hits);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_cache_stats_cav_probes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ;
-  unsigned int arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  unsigned int val2 ;
-  int ecode2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:avc_cache_stats_cav_probes_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_cav_probes_set" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); 
+  arg3 = (struct avc_log_callback *)(argp3);
+  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_avc_thread_callback, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "avc_init" "', argument " "4"" of type '" "struct avc_thread_callback const *""'"); 
   }
-  arg1 = (struct avc_cache_stats *)(argp1);
-  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "avc_cache_stats_cav_probes_set" "', argument " "2"" of type '" "unsigned int""'");
-  } 
-  arg2 = (unsigned int)(val2);
-  if (arg1) (arg1)->cav_probes = arg2;
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_avc_cache_stats_cav_probes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ;
-  unsigned int result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:avc_cache_stats_cav_probes_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_cav_probes_get" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); 
+  arg4 = (struct avc_thread_callback *)(argp4);
+  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_avc_lock_callback, 0 |  0 );
+  if (!SWIG_IsOK(res5)) {
+    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "avc_init" "', argument " "5"" of type '" "struct avc_lock_callback const *""'"); 
   }
-  arg1 = (struct avc_cache_stats *)(argp1);
-  result = (unsigned int) ((arg1)->cav_probes);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  arg5 = (struct avc_lock_callback *)(argp5);
+  result = (int)avc_init((char const *)arg1,(struct avc_memory_callback const *)arg2,(struct avc_log_callback const *)arg3,(struct avc_thread_callback const *)arg4,(struct avc_lock_callback const *)arg5);
+  resultobj = SWIG_From_int((int)(result));
+  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   return resultobj;
 fail:
+  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_avc_cache_stats_cav_misses_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_avc_open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ;
+  struct selinux_opt *arg1 = (struct selinux_opt *) 0 ;
   unsigned int arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -9512,109 +8201,256 @@
   int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  int result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:avc_cache_stats_cav_misses_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OO:avc_open",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_selinux_opt, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_cav_misses_set" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_open" "', argument " "1"" of type '" "struct selinux_opt *""'"); 
   }
-  arg1 = (struct avc_cache_stats *)(argp1);
+  arg1 = (struct selinux_opt *)(argp1);
   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "avc_cache_stats_cav_misses_set" "', argument " "2"" of type '" "unsigned int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "avc_open" "', argument " "2"" of type '" "unsigned int""'");
   } 
   arg2 = (unsigned int)(val2);
-  if (arg1) (arg1)->cav_misses = arg2;
-  
-  resultobj = SWIG_Py_Void();
+  result = (int)avc_open(arg1,arg2);
+  resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_avc_cache_stats_cav_misses_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_avc_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ;
-  unsigned int result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
+  int result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:avc_cache_stats_cav_misses_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_cache_stats_cav_misses_get" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); 
-  }
-  arg1 = (struct avc_cache_stats *)(argp1);
-  result = (unsigned int) ((arg1)->cav_misses);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  if (!PyArg_ParseTuple(args,(char *)":avc_reset")) SWIG_fail;
+  result = (int)avc_reset();
+  resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_new_avc_cache_stats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_avc_has_perm_noaudit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  struct avc_cache_stats *result = 0 ;
+  security_id_t arg1 = (security_id_t) 0 ;
+  security_id_t arg2 = (security_id_t) 0 ;
+  security_class_t arg3 ;
+  access_vector_t arg4 ;
+  struct avc_entry_ref *arg5 = (struct avc_entry_ref *) 0 ;
+  struct av_decision *arg6 = (struct av_decision *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  unsigned short val3 ;
+  int ecode3 = 0 ;
+  unsigned int val4 ;
+  int ecode4 = 0 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  void *argp6 = 0 ;
+  int res6 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  PyObject * obj5 = 0 ;
+  int result;
   
-  if (!PyArg_ParseTuple(args,(char *)":new_avc_cache_stats")) SWIG_fail;
-  result = (struct avc_cache_stats *)calloc(1, sizeof(struct avc_cache_stats));
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_avc_cache_stats, SWIG_POINTER_NEW |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:avc_has_perm_noaudit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_has_perm_noaudit" "', argument " "1"" of type '" "security_id_t""'"); 
+  }
+  arg1 = (security_id_t)(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_security_id, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "avc_has_perm_noaudit" "', argument " "2"" of type '" "security_id_t""'"); 
+  }
+  arg2 = (security_id_t)(argp2);
+  ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "avc_has_perm_noaudit" "', argument " "3"" of type '" "security_class_t""'");
+  } 
+  arg3 = (security_class_t)(val3);
+  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "avc_has_perm_noaudit" "', argument " "4"" of type '" "access_vector_t""'");
+  } 
+  arg4 = (access_vector_t)(val4);
+  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_avc_entry_ref, 0 |  0 );
+  if (!SWIG_IsOK(res5)) {
+    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "avc_has_perm_noaudit" "', argument " "5"" of type '" "struct avc_entry_ref *""'"); 
+  }
+  arg5 = (struct avc_entry_ref *)(argp5);
+  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_av_decision, 0 |  0 );
+  if (!SWIG_IsOK(res6)) {
+    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "avc_has_perm_noaudit" "', argument " "6"" of type '" "struct av_decision *""'"); 
+  }
+  arg6 = (struct av_decision *)(argp6);
+  result = (int)avc_has_perm_noaudit(arg1,arg2,arg3,arg4,arg5,arg6);
+  resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_delete_avc_cache_stats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_avc_has_perm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  struct avc_cache_stats *arg1 = (struct avc_cache_stats *) 0 ;
+  security_id_t arg1 = (security_id_t) 0 ;
+  security_id_t arg2 = (security_id_t) 0 ;
+  security_class_t arg3 ;
+  access_vector_t arg4 ;
+  struct avc_entry_ref *arg5 = (struct avc_entry_ref *) 0 ;
+  void *arg6 = (void *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  unsigned short val3 ;
+  int ecode3 = 0 ;
+  unsigned int val4 ;
+  int ecode4 = 0 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  int res6 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  PyObject * obj5 = 0 ;
+  int result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:delete_avc_cache_stats",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_avc_cache_stats, SWIG_POINTER_DISOWN |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:avc_has_perm",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_avc_cache_stats" "', argument " "1"" of type '" "struct avc_cache_stats *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_has_perm" "', argument " "1"" of type '" "security_id_t""'"); 
   }
-  arg1 = (struct avc_cache_stats *)(argp1);
-  free((char *) arg1);
-  
-  resultobj = SWIG_Py_Void();
+  arg1 = (security_id_t)(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_security_id, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "avc_has_perm" "', argument " "2"" of type '" "security_id_t""'"); 
+  }
+  arg2 = (security_id_t)(argp2);
+  ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "avc_has_perm" "', argument " "3"" of type '" "security_class_t""'");
+  } 
+  arg3 = (security_class_t)(val3);
+  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "avc_has_perm" "', argument " "4"" of type '" "access_vector_t""'");
+  } 
+  arg4 = (access_vector_t)(val4);
+  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_avc_entry_ref, 0 |  0 );
+  if (!SWIG_IsOK(res5)) {
+    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "avc_has_perm" "', argument " "5"" of type '" "struct avc_entry_ref *""'"); 
+  }
+  arg5 = (struct avc_entry_ref *)(argp5);
+  res6 = SWIG_ConvertPtr(obj5,SWIG_as_voidptrptr(&arg6), 0, 0);
+  if (!SWIG_IsOK(res6)) {
+    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "avc_has_perm" "', argument " "6"" of type '" "void *""'"); 
+  }
+  result = (int)avc_has_perm(arg1,arg2,arg3,arg4,arg5,arg6);
+  resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *avc_cache_stats_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *obj;
-  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_avc_cache_stats, SWIG_NewClientData(obj));
-  return SWIG_Py_Void();
-}
-
-SWIGINTERN PyObject *_wrap_avc_av_stats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_avc_compute_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
+  security_id_t arg1 = (security_id_t) 0 ;
+  security_id_t arg2 = (security_id_t) 0 ;
+  security_class_t arg3 ;
+  security_id_t *arg4 = (security_id_t *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  unsigned short val3 ;
+  int ecode3 = 0 ;
+  security_id_t temp4 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  int result;
   
-  if (!PyArg_ParseTuple(args,(char *)":avc_av_stats")) SWIG_fail;
-  avc_av_stats();
-  resultobj = SWIG_Py_Void();
+  {
+    arg4 = &temp4;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"OOO:avc_compute_create",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_compute_create" "', argument " "1"" of type '" "security_id_t""'"); 
+  }
+  arg1 = (security_id_t)(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_security_id, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "avc_compute_create" "', argument " "2"" of type '" "security_id_t""'"); 
+  }
+  arg2 = (security_id_t)(argp2);
+  ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "avc_compute_create" "', argument " "3"" of type '" "security_class_t""'");
+  } 
+  arg3 = (security_class_t)(val3);
+  result = (int)avc_compute_create(arg1,arg2,arg3,arg4);
+  resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_avc_sid_stats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_avc_compute_member(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
+  security_id_t arg1 = (security_id_t) 0 ;
+  security_id_t arg2 = (security_id_t) 0 ;
+  security_class_t arg3 ;
+  security_id_t *arg4 = (security_id_t *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  unsigned short val3 ;
+  int ecode3 = 0 ;
+  security_id_t temp4 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  int result;
   
-  if (!PyArg_ParseTuple(args,(char *)":avc_sid_stats")) SWIG_fail;
-  avc_sid_stats();
-  resultobj = SWIG_Py_Void();
+  {
+    arg4 = &temp4;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"OOO:avc_compute_member",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_id, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "avc_compute_member" "', argument " "1"" of type '" "security_id_t""'"); 
+  }
+  arg1 = (security_id_t)(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_security_id, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "avc_compute_member" "', argument " "2"" of type '" "security_id_t""'"); 
+  }
+  arg2 = (security_id_t)(argp2);
+  ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "avc_compute_member" "', argument " "3"" of type '" "security_class_t""'");
+  } 
+  arg3 = (security_class_t)(val3);
+  result = (int)avc_compute_member(arg1,arg2,arg3,arg4);
+  resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
   return NULL;
@@ -9638,12 +8474,12 @@
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
   char **arg2 = (char **) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   char *temp2 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   arg2 = &temp2;
   if (!PyArg_ParseTuple(args,(char *)"O:get_default_type",&obj0)) SWIG_fail;
@@ -9675,7 +8511,6 @@
   char *arg1 = (char *) 0 ;
   security_context_t arg2 = (security_context_t) 0 ;
   security_context_t **arg3 = (security_context_t **) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
@@ -9685,6 +8520,7 @@
   security_context_t *temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  int result;
   
   {
     arg3 = &temp3;
@@ -9739,7 +8575,6 @@
   char *arg2 = (char *) 0 ;
   security_context_t arg3 = (security_context_t) 0 ;
   security_context_t **arg4 = (security_context_t **) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
@@ -9753,6 +8588,7 @@
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
+  int result;
   
   {
     arg4 = &temp4;
@@ -9813,7 +8649,6 @@
   char *arg1 = (char *) 0 ;
   security_context_t arg2 = (security_context_t) 0 ;
   security_context_t *arg3 = (security_context_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
@@ -9823,6 +8658,7 @@
   security_context_t temp3 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  int result;
   
   arg3 = &temp3;
   if (!PyArg_ParseTuple(args,(char *)"OO:get_default_context",&obj0,&obj1)) SWIG_fail;
@@ -9862,7 +8698,6 @@
   char *arg2 = (char *) 0 ;
   security_context_t arg3 = (security_context_t) 0 ;
   security_context_t *arg4 = (security_context_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
@@ -9876,6 +8711,7 @@
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
+  int result;
   
   arg4 = &temp4;
   if (!PyArg_ParseTuple(args,(char *)"OOO:get_default_context_with_level",&obj0,&obj1,&obj2)) SWIG_fail;
@@ -9922,7 +8758,6 @@
   char *arg2 = (char *) 0 ;
   security_context_t arg3 = (security_context_t) 0 ;
   security_context_t *arg4 = (security_context_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
@@ -9936,6 +8771,7 @@
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
+  int result;
   
   arg4 = &temp4;
   if (!PyArg_ParseTuple(args,(char *)"OOO:get_default_context_with_role",&obj0,&obj1,&obj2)) SWIG_fail;
@@ -9983,7 +8819,6 @@
   char *arg3 = (char *) 0 ;
   security_context_t arg4 = (security_context_t) 0 ;
   security_context_t *arg5 = (security_context_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
@@ -10001,6 +8836,7 @@
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
   PyObject * obj3 = 0 ;
+  int result;
   
   arg5 = &temp5;
   if (!PyArg_ParseTuple(args,(char *)"OOOO:get_default_context_with_rolelevel",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
@@ -10052,9 +8888,9 @@
   PyObject *resultobj = 0;
   security_context_t *arg1 = (security_context_t *) 0 ;
   security_context_t *arg2 = (security_context_t *) 0 ;
-  int result;
   security_context_t temp1 = 0 ;
   security_context_t temp2 = 0 ;
+  int result;
   
   arg1 = &temp1;
   arg2 = &temp2;
@@ -10087,12 +8923,12 @@
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
   security_context_t *arg2 = (security_context_t *) 0 ;
-  int result;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
   security_context_t temp2 = 0 ;
   PyObject * obj0 = 0 ;
+  int result;
   
   arg2 = &temp2;
   if (!PyArg_ParseTuple(args,(char *)"O:manual_user_enter_context",&obj0)) SWIG_fail;
@@ -10120,6 +8956,7 @@
 
 
 static PyMethodDef SwigMethods[] = {
+	 { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
 	 { (char *)"is_selinux_enabled", _wrap_is_selinux_enabled, METH_VARARGS, NULL},
 	 { (char *)"is_selinux_mls_enabled", _wrap_is_selinux_mls_enabled, METH_VARARGS, NULL},
 	 { (char *)"getcon", _wrap_getcon, METH_VARARGS, NULL},
@@ -10180,17 +9017,6 @@
 	 { (char *)"new_selinux_opt", _wrap_new_selinux_opt, METH_VARARGS, NULL},
 	 { (char *)"delete_selinux_opt", _wrap_delete_selinux_opt, METH_VARARGS, NULL},
 	 { (char *)"selinux_opt_swigregister", selinux_opt_swigregister, METH_VARARGS, NULL},
-	 { (char *)"selinux_callback_func_log_set", _wrap_selinux_callback_func_log_set, METH_VARARGS, NULL},
-	 { (char *)"selinux_callback_func_log_get", _wrap_selinux_callback_func_log_get, METH_VARARGS, NULL},
-	 { (char *)"selinux_callback_func_audit_set", _wrap_selinux_callback_func_audit_set, METH_VARARGS, NULL},
-	 { (char *)"selinux_callback_func_audit_get", _wrap_selinux_callback_func_audit_get, METH_VARARGS, NULL},
-	 { (char *)"selinux_callback_func_validate_set", _wrap_selinux_callback_func_validate_set, METH_VARARGS, NULL},
-	 { (char *)"selinux_callback_func_validate_get", _wrap_selinux_callback_func_validate_get, METH_VARARGS, NULL},
-	 { (char *)"new_selinux_callback", _wrap_new_selinux_callback, METH_VARARGS, NULL},
-	 { (char *)"delete_selinux_callback", _wrap_delete_selinux_callback, METH_VARARGS, NULL},
-	 { (char *)"selinux_callback_swigregister", selinux_callback_swigregister, METH_VARARGS, NULL},
-	 { (char *)"selinux_get_callback", _wrap_selinux_get_callback, METH_VARARGS, NULL},
-	 { (char *)"selinux_set_callback", _wrap_selinux_set_callback, METH_VARARGS, NULL},
 	 { (char *)"security_compute_av", _wrap_security_compute_av, METH_VARARGS, NULL},
 	 { (char *)"security_compute_av_raw", _wrap_security_compute_av_raw, METH_VARARGS, NULL},
 	 { (char *)"security_compute_create", _wrap_security_compute_create, METH_VARARGS, NULL},
@@ -10235,23 +9061,16 @@
 	 { (char *)"new_security_class_mapping", _wrap_new_security_class_mapping, METH_VARARGS, NULL},
 	 { (char *)"delete_security_class_mapping", _wrap_delete_security_class_mapping, METH_VARARGS, NULL},
 	 { (char *)"security_class_mapping_swigregister", security_class_mapping_swigregister, METH_VARARGS, NULL},
-	 { (char *)"selinux_set_mapping", _wrap_selinux_set_mapping, METH_VARARGS, NULL},
 	 { (char *)"string_to_security_class", _wrap_string_to_security_class, METH_VARARGS, NULL},
 	 { (char *)"security_class_to_string", _wrap_security_class_to_string, METH_VARARGS, NULL},
 	 { (char *)"security_av_perm_to_string", _wrap_security_av_perm_to_string, METH_VARARGS, NULL},
 	 { (char *)"string_to_av_perm", _wrap_string_to_av_perm, METH_VARARGS, NULL},
 	 { (char *)"security_av_string", _wrap_security_av_string, METH_VARARGS, NULL},
-	 { (char *)"print_access_vector", _wrap_print_access_vector, METH_VARARGS, NULL},
-	 { (char *)"set_matchpathcon_flags", _wrap_set_matchpathcon_flags, METH_VARARGS, NULL},
 	 { (char *)"matchpathcon_init", _wrap_matchpathcon_init, METH_VARARGS, NULL},
 	 { (char *)"matchpathcon_init_prefix", _wrap_matchpathcon_init_prefix, METH_VARARGS, NULL},
-	 { (char *)"matchpathcon_fini", _wrap_matchpathcon_fini, METH_VARARGS, NULL},
 	 { (char *)"matchpathcon", _wrap_matchpathcon, METH_VARARGS, NULL},
 	 { (char *)"matchpathcon_index", _wrap_matchpathcon_index, METH_VARARGS, NULL},
 	 { (char *)"matchpathcon_filespec_add", _wrap_matchpathcon_filespec_add, METH_VARARGS, NULL},
-	 { (char *)"matchpathcon_filespec_destroy", _wrap_matchpathcon_filespec_destroy, METH_VARARGS, NULL},
-	 { (char *)"matchpathcon_filespec_eval", _wrap_matchpathcon_filespec_eval, METH_VARARGS, NULL},
-	 { (char *)"matchpathcon_checkmatches", _wrap_matchpathcon_checkmatches, METH_VARARGS, NULL},
 	 { (char *)"matchmediacon", _wrap_matchmediacon, METH_VARARGS, NULL},
 	 { (char *)"selinux_getenforcemode", _wrap_selinux_getenforcemode, METH_VARARGS, NULL},
 	 { (char *)"selinux_getpolicytype", _wrap_selinux_getpolicytype, METH_VARARGS, NULL},
@@ -10264,8 +9083,11 @@
 	 { (char *)"selinux_file_context_path", _wrap_selinux_file_context_path, METH_VARARGS, NULL},
 	 { (char *)"selinux_file_context_homedir_path", _wrap_selinux_file_context_homedir_path, METH_VARARGS, NULL},
 	 { (char *)"selinux_file_context_local_path", _wrap_selinux_file_context_local_path, METH_VARARGS, NULL},
+	 { (char *)"selinux_file_context_subs_path", _wrap_selinux_file_context_subs_path, METH_VARARGS, NULL},
 	 { (char *)"selinux_homedir_context_path", _wrap_selinux_homedir_context_path, METH_VARARGS, NULL},
 	 { (char *)"selinux_media_context_path", _wrap_selinux_media_context_path, METH_VARARGS, NULL},
+	 { (char *)"selinux_virtual_domain_context_path", _wrap_selinux_virtual_domain_context_path, METH_VARARGS, NULL},
+	 { (char *)"selinux_virtual_image_context_path", _wrap_selinux_virtual_image_context_path, METH_VARARGS, NULL},
 	 { (char *)"selinux_x_context_path", _wrap_selinux_x_context_path, METH_VARARGS, NULL},
 	 { (char *)"selinux_contexts_path", _wrap_selinux_contexts_path, METH_VARARGS, NULL},
 	 { (char *)"selinux_securetty_types_path", _wrap_selinux_securetty_types_path, METH_VARARGS, NULL},
@@ -10280,23 +9102,16 @@
 	 { (char *)"selinux_check_passwd_access", _wrap_selinux_check_passwd_access, METH_VARARGS, NULL},
 	 { (char *)"checkPasswdAccess", _wrap_checkPasswdAccess, METH_VARARGS, NULL},
 	 { (char *)"selinux_check_securetty_context", _wrap_selinux_check_securetty_context, METH_VARARGS, NULL},
-	 { (char *)"set_selinuxmnt", _wrap_set_selinuxmnt, METH_VARARGS, NULL},
 	 { (char *)"rpm_execcon", _wrap_rpm_execcon, METH_VARARGS, NULL},
 	 { (char *)"is_context_customizable", _wrap_is_context_customizable, METH_VARARGS, NULL},
 	 { (char *)"selinux_trans_to_raw_context", _wrap_selinux_trans_to_raw_context, METH_VARARGS, NULL},
 	 { (char *)"selinux_raw_to_trans_context", _wrap_selinux_raw_to_trans_context, METH_VARARGS, NULL},
 	 { (char *)"selinux_raw_context_to_color", _wrap_selinux_raw_context_to_color, METH_VARARGS, NULL},
 	 { (char *)"getseuserbyname", _wrap_getseuserbyname, METH_VARARGS, NULL},
+	 { (char *)"getseuser", _wrap_getseuser, METH_VARARGS, NULL},
 	 { (char *)"selinux_file_context_cmp", _wrap_selinux_file_context_cmp, METH_VARARGS, NULL},
 	 { (char *)"selinux_file_context_verify", _wrap_selinux_file_context_verify, METH_VARARGS, NULL},
 	 { (char *)"selinux_lsetfilecon_default", _wrap_selinux_lsetfilecon_default, METH_VARARGS, NULL},
-	 { (char *)"security_id_ctx_set", _wrap_security_id_ctx_set, METH_VARARGS, NULL},
-	 { (char *)"security_id_ctx_get", _wrap_security_id_ctx_get, METH_VARARGS, NULL},
-	 { (char *)"security_id_refcnt_set", _wrap_security_id_refcnt_set, METH_VARARGS, NULL},
-	 { (char *)"security_id_refcnt_get", _wrap_security_id_refcnt_get, METH_VARARGS, NULL},
-	 { (char *)"new_security_id", _wrap_new_security_id, METH_VARARGS, NULL},
-	 { (char *)"delete_security_id", _wrap_delete_security_id, METH_VARARGS, NULL},
-	 { (char *)"security_id_swigregister", security_id_swigregister, METH_VARARGS, NULL},
 	 { (char *)"avc_sid_to_context", _wrap_avc_sid_to_context, METH_VARARGS, NULL},
 	 { (char *)"avc_sid_to_context_raw", _wrap_avc_sid_to_context_raw, METH_VARARGS, NULL},
 	 { (char *)"avc_context_to_sid", _wrap_avc_context_to_sid, METH_VARARGS, NULL},
@@ -10304,74 +9119,13 @@
 	 { (char *)"sidget", _wrap_sidget, METH_VARARGS, NULL},
 	 { (char *)"sidput", _wrap_sidput, METH_VARARGS, NULL},
 	 { (char *)"avc_get_initial_sid", _wrap_avc_get_initial_sid, METH_VARARGS, NULL},
-	 { (char *)"avc_entry_ref_ae_set", _wrap_avc_entry_ref_ae_set, METH_VARARGS, NULL},
-	 { (char *)"avc_entry_ref_ae_get", _wrap_avc_entry_ref_ae_get, METH_VARARGS, NULL},
-	 { (char *)"new_avc_entry_ref", _wrap_new_avc_entry_ref, METH_VARARGS, NULL},
-	 { (char *)"delete_avc_entry_ref", _wrap_delete_avc_entry_ref, METH_VARARGS, NULL},
-	 { (char *)"avc_entry_ref_swigregister", avc_entry_ref_swigregister, METH_VARARGS, NULL},
-	 { (char *)"avc_memory_callback_func_malloc_set", _wrap_avc_memory_callback_func_malloc_set, METH_VARARGS, NULL},
-	 { (char *)"avc_memory_callback_func_malloc_get", _wrap_avc_memory_callback_func_malloc_get, METH_VARARGS, NULL},
-	 { (char *)"avc_memory_callback_func_free_set", _wrap_avc_memory_callback_func_free_set, METH_VARARGS, NULL},
-	 { (char *)"avc_memory_callback_func_free_get", _wrap_avc_memory_callback_func_free_get, METH_VARARGS, NULL},
-	 { (char *)"new_avc_memory_callback", _wrap_new_avc_memory_callback, METH_VARARGS, NULL},
-	 { (char *)"delete_avc_memory_callback", _wrap_delete_avc_memory_callback, METH_VARARGS, NULL},
-	 { (char *)"avc_memory_callback_swigregister", avc_memory_callback_swigregister, METH_VARARGS, NULL},
-	 { (char *)"avc_log_callback_func_log_set", _wrap_avc_log_callback_func_log_set, METH_VARARGS, NULL},
-	 { (char *)"avc_log_callback_func_log_get", _wrap_avc_log_callback_func_log_get, METH_VARARGS, NULL},
-	 { (char *)"avc_log_callback_func_audit_set", _wrap_avc_log_callback_func_audit_set, METH_VARARGS, NULL},
-	 { (char *)"avc_log_callback_func_audit_get", _wrap_avc_log_callback_func_audit_get, METH_VARARGS, NULL},
-	 { (char *)"new_avc_log_callback", _wrap_new_avc_log_callback, METH_VARARGS, NULL},
-	 { (char *)"delete_avc_log_callback", _wrap_delete_avc_log_callback, METH_VARARGS, NULL},
-	 { (char *)"avc_log_callback_swigregister", avc_log_callback_swigregister, METH_VARARGS, NULL},
-	 { (char *)"avc_thread_callback_func_create_thread_set", _wrap_avc_thread_callback_func_create_thread_set, METH_VARARGS, NULL},
-	 { (char *)"avc_thread_callback_func_create_thread_get", _wrap_avc_thread_callback_func_create_thread_get, METH_VARARGS, NULL},
-	 { (char *)"avc_thread_callback_func_stop_thread_set", _wrap_avc_thread_callback_func_stop_thread_set, METH_VARARGS, NULL},
-	 { (char *)"avc_thread_callback_func_stop_thread_get", _wrap_avc_thread_callback_func_stop_thread_get, METH_VARARGS, NULL},
-	 { (char *)"new_avc_thread_callback", _wrap_new_avc_thread_callback, METH_VARARGS, NULL},
-	 { (char *)"delete_avc_thread_callback", _wrap_delete_avc_thread_callback, METH_VARARGS, NULL},
-	 { (char *)"avc_thread_callback_swigregister", avc_thread_callback_swigregister, METH_VARARGS, NULL},
-	 { (char *)"avc_lock_callback_func_alloc_lock_set", _wrap_avc_lock_callback_func_alloc_lock_set, METH_VARARGS, NULL},
-	 { (char *)"avc_lock_callback_func_alloc_lock_get", _wrap_avc_lock_callback_func_alloc_lock_get, METH_VARARGS, NULL},
-	 { (char *)"avc_lock_callback_func_get_lock_set", _wrap_avc_lock_callback_func_get_lock_set, METH_VARARGS, NULL},
-	 { (char *)"avc_lock_callback_func_get_lock_get", _wrap_avc_lock_callback_func_get_lock_get, METH_VARARGS, NULL},
-	 { (char *)"avc_lock_callback_func_release_lock_set", _wrap_avc_lock_callback_func_release_lock_set, METH_VARARGS, NULL},
-	 { (char *)"avc_lock_callback_func_release_lock_get", _wrap_avc_lock_callback_func_release_lock_get, METH_VARARGS, NULL},
-	 { (char *)"avc_lock_callback_func_free_lock_set", _wrap_avc_lock_callback_func_free_lock_set, METH_VARARGS, NULL},
-	 { (char *)"avc_lock_callback_func_free_lock_get", _wrap_avc_lock_callback_func_free_lock_get, METH_VARARGS, NULL},
-	 { (char *)"new_avc_lock_callback", _wrap_new_avc_lock_callback, METH_VARARGS, NULL},
-	 { (char *)"delete_avc_lock_callback", _wrap_delete_avc_lock_callback, METH_VARARGS, NULL},
-	 { (char *)"avc_lock_callback_swigregister", avc_lock_callback_swigregister, METH_VARARGS, NULL},
 	 { (char *)"avc_init", _wrap_avc_init, METH_VARARGS, NULL},
 	 { (char *)"avc_open", _wrap_avc_open, METH_VARARGS, NULL},
-	 { (char *)"avc_cleanup", _wrap_avc_cleanup, METH_VARARGS, NULL},
 	 { (char *)"avc_reset", _wrap_avc_reset, METH_VARARGS, NULL},
-	 { (char *)"avc_destroy", _wrap_avc_destroy, METH_VARARGS, NULL},
 	 { (char *)"avc_has_perm_noaudit", _wrap_avc_has_perm_noaudit, METH_VARARGS, NULL},
 	 { (char *)"avc_has_perm", _wrap_avc_has_perm, METH_VARARGS, NULL},
-	 { (char *)"avc_audit", _wrap_avc_audit, METH_VARARGS, NULL},
 	 { (char *)"avc_compute_create", _wrap_avc_compute_create, METH_VARARGS, NULL},
 	 { (char *)"avc_compute_member", _wrap_avc_compute_member, METH_VARARGS, NULL},
-	 { (char *)"avc_cache_stats_entry_lookups_set", _wrap_avc_cache_stats_entry_lookups_set, METH_VARARGS, NULL},
-	 { (char *)"avc_cache_stats_entry_lookups_get", _wrap_avc_cache_stats_entry_lookups_get, METH_VARARGS, NULL},
-	 { (char *)"avc_cache_stats_entry_hits_set", _wrap_avc_cache_stats_entry_hits_set, METH_VARARGS, NULL},
-	 { (char *)"avc_cache_stats_entry_hits_get", _wrap_avc_cache_stats_entry_hits_get, METH_VARARGS, NULL},
-	 { (char *)"avc_cache_stats_entry_misses_set", _wrap_avc_cache_stats_entry_misses_set, METH_VARARGS, NULL},
-	 { (char *)"avc_cache_stats_entry_misses_get", _wrap_avc_cache_stats_entry_misses_get, METH_VARARGS, NULL},
-	 { (char *)"avc_cache_stats_entry_discards_set", _wrap_avc_cache_stats_entry_discards_set, METH_VARARGS, NULL},
-	 { (char *)"avc_cache_stats_entry_discards_get", _wrap_avc_cache_stats_entry_discards_get, METH_VARARGS, NULL},
-	 { (char *)"avc_cache_stats_cav_lookups_set", _wrap_avc_cache_stats_cav_lookups_set, METH_VARARGS, NULL},
-	 { (char *)"avc_cache_stats_cav_lookups_get", _wrap_avc_cache_stats_cav_lookups_get, METH_VARARGS, NULL},
-	 { (char *)"avc_cache_stats_cav_hits_set", _wrap_avc_cache_stats_cav_hits_set, METH_VARARGS, NULL},
-	 { (char *)"avc_cache_stats_cav_hits_get", _wrap_avc_cache_stats_cav_hits_get, METH_VARARGS, NULL},
-	 { (char *)"avc_cache_stats_cav_probes_set", _wrap_avc_cache_stats_cav_probes_set, METH_VARARGS, NULL},
-	 { (char *)"avc_cache_stats_cav_probes_get", _wrap_avc_cache_stats_cav_probes_get, METH_VARARGS, NULL},
-	 { (char *)"avc_cache_stats_cav_misses_set", _wrap_avc_cache_stats_cav_misses_set, METH_VARARGS, NULL},
-	 { (char *)"avc_cache_stats_cav_misses_get", _wrap_avc_cache_stats_cav_misses_get, METH_VARARGS, NULL},
-	 { (char *)"new_avc_cache_stats", _wrap_new_avc_cache_stats, METH_VARARGS, NULL},
-	 { (char *)"delete_avc_cache_stats", _wrap_delete_avc_cache_stats, METH_VARARGS, NULL},
-	 { (char *)"avc_cache_stats_swigregister", avc_cache_stats_swigregister, METH_VARARGS, NULL},
-	 { (char *)"avc_av_stats", _wrap_avc_av_stats, METH_VARARGS, NULL},
-	 { (char *)"avc_sid_stats", _wrap_avc_sid_stats, METH_VARARGS, NULL},
 	 { (char *)"selinux_default_type_path", _wrap_selinux_default_type_path, METH_VARARGS, NULL},
 	 { (char *)"get_default_type", _wrap_get_default_type, METH_VARARGS, NULL},
 	 { (char *)"get_ordered_context_list", _wrap_get_ordered_context_list, METH_VARARGS, NULL},
@@ -10390,31 +9144,19 @@
 
 static swig_type_info _swigt__p_SELboolean = {"_p_SELboolean", "SELboolean *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_av_decision = {"_p_av_decision", "struct av_decision *|av_decision *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_avc_cache_stats = {"_p_avc_cache_stats", "struct avc_cache_stats *|avc_cache_stats *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_avc_entry = {"_p_avc_entry", "struct avc_entry *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_avc_entry_ref = {"_p_avc_entry_ref", "struct avc_entry_ref *|avc_entry_ref *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_avc_lock_callback = {"_p_avc_lock_callback", "struct avc_lock_callback *|avc_lock_callback *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_avc_log_callback = {"_p_avc_log_callback", "struct avc_log_callback *|avc_log_callback *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_avc_memory_callback = {"_p_avc_memory_callback", "struct avc_memory_callback *|avc_memory_callback *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_avc_thread_callback = {"_p_avc_thread_callback", "struct avc_thread_callback *|avc_thread_callback *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_avc_entry_ref = {"_p_avc_entry_ref", "struct avc_entry_ref *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_avc_lock_callback = {"_p_avc_lock_callback", "struct avc_lock_callback *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_avc_log_callback = {"_p_avc_log_callback", "struct avc_log_callback *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_avc_memory_callback = {"_p_avc_memory_callback", "struct avc_memory_callback *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_avc_thread_callback = {"_p_avc_thread_callback", "struct avc_thread_callback *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_f_int_p_q_const__char_v_______int = {"_p_f_int_p_q_const__char_v_______int", "int (*)(int,char const *,...)", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_f_p_f_void__void__p_void = {"_p_f_p_f_void__void__p_void", "void *(*)(void (*)(void))", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_f_p_p_char__int = {"_p_f_p_p_char__int", "int (*)(char **)|int (*)(security_context_t *)", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_f_p_q_const__char_v_______void = {"_p_f_p_q_const__char_v_______void", "void (*)(char const *,...)", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_f_p_void__void = {"_p_f_p_void__void", "void (*)(void *)", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_f_p_void_unsigned_short_p_char_size_t__int = {"_p_f_p_void_unsigned_short_p_char_size_t__int", "int (*)(void *,unsigned short,char *,size_t)|int (*)(void *,security_class_t,char *,size_t)", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_f_p_void_unsigned_short_p_char_size_t__void = {"_p_f_p_void_unsigned_short_p_char_size_t__void", "void (*)(void *,unsigned short,char *,size_t)|void (*)(void *,security_class_t,char *,size_t)", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_f_size_t__p_void = {"_p_f_size_t__p_void", "void *(*)(size_t)", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_f_void__p_void = {"_p_f_void__p_void", "void *(*)(void)", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_ino_t = {"_p_ino_t", "ino_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **|security_context_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_p_p_char = {"_p_p_p_char", "char ***|security_context_t **", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_p_security_id = {"_p_p_security_id", "struct security_id **|security_id_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_security_class_mapping = {"_p_security_class_mapping", "struct security_class_mapping *|security_class_mapping *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_security_id = {"_p_security_id", "security_id_t|struct security_id *|security_id *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_selinux_callback = {"_p_selinux_callback", "union selinux_callback *|selinux_callback *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_security_id = {"_p_security_id", "security_id_t|struct security_id *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_selinux_opt = {"_p_selinux_opt", "struct selinux_opt *|selinux_opt *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|access_vector_t *|mode_t *|pid_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "security_class_t *|unsigned short *", 0, 0, (void*)0, 0};
@@ -10422,23 +9164,12 @@
 static swig_type_info *swig_type_initial[] = {
   &_swigt__p_SELboolean,
   &_swigt__p_av_decision,
-  &_swigt__p_avc_cache_stats,
-  &_swigt__p_avc_entry,
   &_swigt__p_avc_entry_ref,
   &_swigt__p_avc_lock_callback,
   &_swigt__p_avc_log_callback,
   &_swigt__p_avc_memory_callback,
   &_swigt__p_avc_thread_callback,
   &_swigt__p_char,
-  &_swigt__p_f_int_p_q_const__char_v_______int,
-  &_swigt__p_f_p_f_void__void__p_void,
-  &_swigt__p_f_p_p_char__int,
-  &_swigt__p_f_p_q_const__char_v_______void,
-  &_swigt__p_f_p_void__void,
-  &_swigt__p_f_p_void_unsigned_short_p_char_size_t__int,
-  &_swigt__p_f_p_void_unsigned_short_p_char_size_t__void,
-  &_swigt__p_f_size_t__p_void,
-  &_swigt__p_f_void__p_void,
   &_swigt__p_ino_t,
   &_swigt__p_int,
   &_swigt__p_p_char,
@@ -10446,7 +9177,6 @@
   &_swigt__p_p_security_id,
   &_swigt__p_security_class_mapping,
   &_swigt__p_security_id,
-  &_swigt__p_selinux_callback,
   &_swigt__p_selinux_opt,
   &_swigt__p_unsigned_int,
   &_swigt__p_unsigned_short,
@@ -10454,23 +9184,12 @@
 
 static swig_cast_info _swigc__p_SELboolean[] = {  {&_swigt__p_SELboolean, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_av_decision[] = {  {&_swigt__p_av_decision, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_avc_cache_stats[] = {  {&_swigt__p_avc_cache_stats, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_avc_entry[] = {  {&_swigt__p_avc_entry, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_avc_entry_ref[] = {  {&_swigt__p_avc_entry_ref, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_avc_lock_callback[] = {  {&_swigt__p_avc_lock_callback, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_avc_log_callback[] = {  {&_swigt__p_avc_log_callback, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_avc_memory_callback[] = {  {&_swigt__p_avc_memory_callback, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_avc_thread_callback[] = {  {&_swigt__p_avc_thread_callback, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_f_int_p_q_const__char_v_______int[] = {  {&_swigt__p_f_int_p_q_const__char_v_______int, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_f_p_f_void__void__p_void[] = {  {&_swigt__p_f_p_f_void__void__p_void, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_f_p_p_char__int[] = {  {&_swigt__p_f_p_p_char__int, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_f_p_q_const__char_v_______void[] = {  {&_swigt__p_f_p_q_const__char_v_______void, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_f_p_void__void[] = {  {&_swigt__p_f_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_f_p_void_unsigned_short_p_char_size_t__int[] = {  {&_swigt__p_f_p_void_unsigned_short_p_char_size_t__int, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_f_p_void_unsigned_short_p_char_size_t__void[] = {  {&_swigt__p_f_p_void_unsigned_short_p_char_size_t__void, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_f_size_t__p_void[] = {  {&_swigt__p_f_size_t__p_void, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_f_void__p_void[] = {  {&_swigt__p_f_void__p_void, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_ino_t[] = {  {&_swigt__p_ino_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
@@ -10478,7 +9197,6 @@
 static swig_cast_info _swigc__p_p_security_id[] = {  {&_swigt__p_p_security_id, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_security_class_mapping[] = {  {&_swigt__p_security_class_mapping, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_security_id[] = {  {&_swigt__p_security_id, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_selinux_callback[] = {  {&_swigt__p_selinux_callback, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_selinux_opt[] = {  {&_swigt__p_selinux_opt, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
@@ -10486,23 +9204,12 @@
 static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_SELboolean,
   _swigc__p_av_decision,
-  _swigc__p_avc_cache_stats,
-  _swigc__p_avc_entry,
   _swigc__p_avc_entry_ref,
   _swigc__p_avc_lock_callback,
   _swigc__p_avc_log_callback,
   _swigc__p_avc_memory_callback,
   _swigc__p_avc_thread_callback,
   _swigc__p_char,
-  _swigc__p_f_int_p_q_const__char_v_______int,
-  _swigc__p_f_p_f_void__void__p_void,
-  _swigc__p_f_p_p_char__int,
-  _swigc__p_f_p_q_const__char_v_______void,
-  _swigc__p_f_p_void__void,
-  _swigc__p_f_p_void_unsigned_short_p_char_size_t__int,
-  _swigc__p_f_p_void_unsigned_short_p_char_size_t__void,
-  _swigc__p_f_size_t__p_void,
-  _swigc__p_f_void__p_void,
   _swigc__p_ino_t,
   _swigc__p_int,
   _swigc__p_p_char,
@@ -10510,7 +9217,6 @@
   _swigc__p_p_security_id,
   _swigc__p_security_class_mapping,
   _swigc__p_security_id,
-  _swigc__p_selinux_callback,
   _swigc__p_selinux_opt,
   _swigc__p_unsigned_int,
   _swigc__p_unsigned_short,
@@ -10791,18 +9497,48 @@
   
   SWIGINTERN PyObject *
   swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
+#if PY_VERSION_HEX >= 0x03000000
+    return PyUnicode_InternFromString("<Swig global variables>");
+#else
     return PyString_FromString("<Swig global variables>");
+#endif
   }
   
   SWIGINTERN PyObject *
   swig_varlink_str(swig_varlinkobject *v) {
+#if PY_VERSION_HEX >= 0x03000000
+    PyObject *str = PyUnicode_InternFromString("(");
+    PyObject *tail;
+    PyObject *joined;
+    swig_globalvar *var;
+    for (var = v->vars; var; var=var->next) {
+      tail = PyUnicode_FromString(var->name);
+      joined = PyUnicode_Concat(str, tail);
+      Py_DecRef(str);
+      Py_DecRef(tail);
+      str = joined;
+      if (var->next) {
+        tail = PyUnicode_InternFromString(", ");
+        joined = PyUnicode_Concat(str, tail);
+        Py_DecRef(str);
+        Py_DecRef(tail);
+        str = joined;
+      }
+    }
+    tail = PyUnicode_InternFromString(")");
+    joined = PyUnicode_Concat(str, tail);
+    Py_DecRef(str);
+    Py_DecRef(tail);
+    str = joined;
+#else
     PyObject *str = PyString_FromString("(");
-    swig_globalvar  *var;
+    swig_globalvar *var;
     for (var = v->vars; var; var=var->next) {
       PyString_ConcatAndDel(&str,PyString_FromString(var->name));
       if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
     }
     PyString_ConcatAndDel(&str,PyString_FromString(")"));
+#endif
     return str;
   }
   
@@ -10810,7 +9546,7 @@
   swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
     PyObject *str = swig_varlink_str(v);
     fprintf(fp,"Swig global variables ");
-    fprintf(fp,"%s\n", PyString_AsString(str));
+    fprintf(fp,"%s\n", SWIG_Python_str_AsChar(str));
     Py_DECREF(str);
     return 0;
   }
@@ -10868,8 +9604,13 @@
     if (!type_init) {
       const PyTypeObject tmp
       = {
+        /* PyObject header changed in Python 3 */
+#if PY_VERSION_HEX >= 0x03000000
+        PyVarObject_HEAD_INIT(&PyType_Type, 0)
+#else
         PyObject_HEAD_INIT(NULL)
         0,                                  /* Number of items in variable part (ob_size) */
+#endif
         (char *)"swigvarlink",              /* Type name (tp_name) */
         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
         0,                                  /* Itemsize (tp_itemsize) */
@@ -10905,7 +9646,10 @@
 #endif
       };
       varlink_type = tmp;
+      /* for Python 3 we already assigned the ob_type in PyVarObject_HEAD_INIT() */
+#if PY_VERSION_HEX < 0x03000000
       varlink_type.ob_type = &PyType_Type;
+#endif
       type_init = 1;
     }
     return &varlink_type;
@@ -11030,13 +9774,35 @@
 #ifdef __cplusplus
 extern "C"
 #endif
-SWIGEXPORT void SWIG_init(void) {
+
+SWIGEXPORT 
+#if PY_VERSION_HEX >= 0x03000000
+PyObject*
+#else
+void
+#endif
+SWIG_init(void) {
   PyObject *m, *d;
   
   /* Fix SwigMethods to carry the callback ptrs when needed */
   SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
+#if PY_VERSION_HEX >= 0x03000000
+  static struct PyModuleDef SWIG_module = {
+    PyModuleDef_HEAD_INIT,
+    (char *) SWIG_name,
+    NULL,
+    -1,
+    SwigMethods,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+  };
   
+  m = PyModule_Create(&SWIG_module);
+#else
   m = Py_InitModule((char *) SWIG_name, SwigMethods);
+#endif
   d = PyModule_GetDict(m);
   
   SWIG_InitializeModule(0);
@@ -11065,5 +9831,10 @@
   SWIG_Python_SetConstant(d, "AVC_CALLBACK_AUDITDENY_DISABLE",SWIG_From_int((int)(128)));
   SWIG_Python_SetConstant(d, "AVC_CACHE_STATS",SWIG_From_int((int)(1)));
   SWIG_Python_SetConstant(d, "SELINUX_DEFAULTUSER",SWIG_FromCharPtr("user_u"));
+#if PY_VERSION_HEX >= 0x03000000
+  return m;
+#else
+  return;
+#endif
 }
 
diff --exclude-from=exclude -N -u -r nsalibselinux/src/seusers.c libselinux-2.0.79/src/seusers.c
--- nsalibselinux/src/seusers.c	2009-03-06 14:41:45.000000000 -0500
+++ libselinux-2.0.79/src/seusers.c	2009-03-27 10:09:31.000000000 -0400
@@ -243,3 +243,67 @@
 	*r_level = NULL;
 	return 0;
 }
+
+int getseuser(const char *username, const char *service, 
+	      char **r_seuser, char **r_level) {
+	int ret = -1;
+	int len = 0;
+	char *seuser = NULL;
+	char *level = NULL;
+	char *buffer = NULL;
+	size_t size = 0;
+	size_t lineno = 0;
+	char *rec = NULL;
+	char *path=NULL;
+	if (asprintf(&path,"%s/logins/%s", selinux_policy_root(), username) <  0)
+		goto err;
+	FILE *fp = fopen(path, "r");
+	free(path);
+	if (fp == NULL) goto err;
+	__fsetlocking(fp, FSETLOCKING_BYCALLER);
+	while (getline(&buffer, &size, fp) > 0) {
+		++lineno;
+
+		if (strncmp(buffer, "*:", 2) == 0) {
+			free(rec);
+			rec = strdup(buffer);
+			continue;
+		}
+		len = strlen(service);
+		if ((strncmp(buffer, service, len) == 0) &&
+		    (buffer[len] == ':')) {
+			free(rec);
+			rec = strdup(buffer);
+			break;
+		}
+	}
+
+	if (! rec)  goto err;
+	seuser = strchr(rec, ':');
+	if (! seuser) goto err;
+
+	seuser++;
+	level = strchr(seuser, ':');
+	*level = 0;
+	level++;
+	*r_seuser = strdup(seuser);
+	if (! *r_seuser) goto err;
+
+	len = strlen(level);
+	if (len && level[len-1] == '\n')
+		level[len-1] = 0;
+
+	*r_level = strdup(level);
+	if (! *r_level) {
+		free(*r_seuser);
+		goto err;
+	}
+	ret = 0;
+
+	err:
+	free(buffer);
+	if (fp) fclose(fp);
+	free(rec);
+
+	return (ret ? getseuserbyname(username, r_seuser, r_level) : ret);
+}
diff --exclude-from=exclude -N -u -r nsalibselinux/utils/getdefaultcon.c libselinux-2.0.79/utils/getdefaultcon.c
--- nsalibselinux/utils/getdefaultcon.c	2009-03-06 14:41:45.000000000 -0500
+++ libselinux-2.0.79/utils/getdefaultcon.c	2009-03-27 10:09:31.000000000 -0400
@@ -22,8 +22,9 @@
 	security_context_t usercon = NULL, cur_context = NULL;
 	char *user = NULL, *level = NULL, *role=NULL, *seuser=NULL, *dlevel=NULL;
 	int ret, opt;
+	int verbose = 0;
 
-	while ((opt = getopt(argc, argv, "l:r:")) > 0) {
+	while ((opt = getopt(argc, argv, "l:r:v")) > 0) {
 		switch (opt) {
 		case 'l':
 			level = strdup(optarg);
@@ -31,6 +32,9 @@
 		case 'r':
 			role = strdup(optarg);
 			break;
+		case 'v':
+			verbose = 1;
+			break;
 		default:
 			usage(argv[0], "invalid option", 1);
 		}
@@ -66,9 +70,13 @@
 	}
 	if (ret < 0)
 		perror(argv[0]);
-	else
-		printf("%s: %s from %s %s %s %s -> %s\n", argv[0], user, cur_context, seuser, role, level, usercon);
-
+	else {
+		if (verbose) {
+			printf("%s: %s from %s %s %s %s -> %s\n", argv[0], user, cur_context, seuser, role, level, usercon);
+		} else {
+			printf("%s", usercon);
+		}
+	}
 
 	free(role);
 	free(seuser);
@@ -76,5 +84,5 @@
 	free(dlevel);
 	free(usercon);
 
-	return 0;
+	return ret >= 0;
 }
diff --exclude-from=exclude -N -u -r nsalibselinux/utils/Makefile libselinux-2.0.79/utils/Makefile
--- nsalibselinux/utils/Makefile	2009-03-06 14:41:45.000000000 -0500
+++ libselinux-2.0.79/utils/Makefile	2009-03-27 10:09:31.000000000 -0400
@@ -2,28 +2,33 @@
 PREFIX ?= $(DESTDIR)/usr
 LIBDIR ?= $(PREFIX)/lib
 BINDIR ?= $(PREFIX)/sbin
+_BINDIR ?= $(DESTDIR)/sbin
 
 CFLAGS ?= -Wall
 override CFLAGS += -I../include -D_GNU_SOURCE $(EMFLAGS)
 LDLIBS += -L../src -lselinux -L$(LIBDIR)
 
 TARGETS=$(patsubst %.c,%,$(wildcard *.c))
+
+
 ifeq ($(DISABLE_AVC),y)
 	UNUSED_TARGETS+=compute_av compute_create compute_member compute_relabel
 endif
 ifeq ($(DISABLE_BOOL),y)
 	UNUSED_TARGETS+=getsebool togglesebool
 endif
-TARGETS:= $(filter-out $(UNUSED_TARGETS), $(TARGETS))
+TARGETS:= $(filter-out $(UNUSED_TARGETS) matchpathcon, $(TARGETS))
 
-all: $(TARGETS)
+all: $(TARGETS) matchpathcon
 
 install: all
 	-mkdir -p $(BINDIR)
 	install -m 755 $(TARGETS) $(BINDIR)
-
+	-mkdir -p $(_BINDIR)
+	install -m 755 matchpathcon $(_BINDIR)
+	(cd $(BINDIR); 	ln -fs ../../sbin/matchpathcon)
 clean:
-	rm -f $(TARGETS) *.o 
+	rm -f $(TARGETS) *.o *~
 
 indent:
 	../../scripts/Lindent $(wildcard *.[ch])
diff --exclude-from=exclude -N -u -r nsalibselinux/utils/matchpathcon.c libselinux-2.0.79/utils/matchpathcon.c
--- nsalibselinux/utils/matchpathcon.c	2009-03-06 14:41:45.000000000 -0500
+++ libselinux-2.0.79/utils/matchpathcon.c	2009-03-27 10:09:31.000000000 -0400
@@ -22,9 +22,13 @@
 	char *buf;
 	int rc = matchpathcon(path, mode, &buf);
 	if (rc < 0) {
-		fprintf(stderr, "matchpathcon(%s) failed: %s\n", path,
-			strerror(errno));
-		return 1;
+		if (errno == ENOENT) {
+			buf=strdup("<<none>>");
+		} else {
+			fprintf(stderr, "matchpathcon(%s) failed: %s\n", path,
+				strerror(errno));
+			return 1;
+		}
 	}
 	if (header)
 		printf("%s\t%s\n", path, buf);
@@ -101,6 +105,11 @@
 	for (i = optind; i < argc; i++) {
 		int mode = 0;
 		struct stat buf;
+		int len = strlen(argv[i]);
+		if (len > 1  && argv[i][len - 1 ] == '/') {
+			argv[i][len - 1 ] = '\0';
+		}
+
 		if (lstat(argv[i], &buf) == 0)
 			mode = buf.st_mode;