[packages/setools] - new URLs, updated to 3.3.8 - removed outdated opt patch - added swig patch (from git) + swig-part2
qboosh
qboosh at pld-linux.org
Thu Mar 6 12:31:53 CET 2014
commit 4df63b553c7b85067bf2789494d10b47f4774ba4
Author: Jakub Bogusz <qboosh at pld-linux.org>
Date: Thu Mar 6 12:34:35 2014 +0100
- new URLs, updated to 3.3.8
- removed outdated opt patch
- added swig patch (from git) + swig-part2 patch (inspired by gentoo patch) to allow build with swig 2.0.x
- added sh patch (fixes POSIX sh syntax in configure)
- added tcl patch (allows to pass TCLSH and WISH paths directly)
- added format patch (fixes build with -Werror=format-security)
- added link patch
seaudit.pamd | 4 +
setools-format.patch | 119 +
setools-link.patch | 55 +
setools-opt.patch | 81 -
setools-sh.patch | 25 +
setools-swig-part2.patch | 6434 ++++++++++++++++++++++++++++++++++++++++++++++
setools-swig.patch | 1543 +++++++++++
setools-tcl.patch | 24 +
setools.spec | 535 +++-
9 files changed, 8635 insertions(+), 185 deletions(-)
---
diff --git a/setools.spec b/setools.spec
index 9b3a5b5..fbf00fb 100644
--- a/setools.spec
+++ b/setools.spec
@@ -1,155 +1,482 @@
-Summary: SELinux tools for managing policy
-Summary(pl.UTF-8): Narzędzia do zarządzania polityką SELinux
+#
+# Conditional build:
+%bcond_without java # Java bindings
+%bcond_without python # Python bindings
+#
+Summary: Policy analysis tools for SELinux
+Summary(pl.UTF-8): Narzędzia do analizy polityk SELinuksa
Name: setools
-Version: 2.4
-Release: 0.1
-License: GPL
-Group: Base
-#Source0: http://www.nsa.gov/selinux/archives/%{name}-%{version}.tar.bz2
-Source0: http://tresys.com/files/setools/%{name}-%{version}.tar.bz2
-# Source0-md5: 4b3d22e07fc92a5c1321bf08958dda81
-Patch0: %{name}-opt.patch
-URL: http://www.tresys.com/selinux/selinux_policy_tools.html
+Version: 3.3.8
+Release: 1
+License: GPL v2+ (tools), LGPL v2.1+ (libraries)
+Group: Applications/System
+#Source0Download: http://oss.tresys.com/projects/setools/wiki/download
+Source0: http://oss.tresys.com/projects/setools/chrome/site/dists/%{name}-%{version}/%{name}-%{version}.tar.bz2
+# Source0-md5: d68d0d4e4da0f01da0f208782ff04b91
+Source1: seaudit.pamd
+Patch0: %{name}-swig.patch
+Patch1: %{name}-sh.patch
+Patch2: %{name}-tcl.patch
+Patch3: %{name}-format.patch
+Patch4: %{name}-swig-part2.patch
+Patch5: %{name}-link.patch
+URL: http://oss.tresys.com/projects/setools/
+BuildRequires: autoconf >= 2.59
+BuildRequires: automake
BuildRequires: bison
+BuildRequires: bzip2-devel
BuildRequires: flex
+BuildRequires: gcc >= 5:3.2
+BuildRequires: gtk+2-devel >= 2:2.8
+%{?with_java:BuildRequires: jdk >= 1.2}
BuildRequires: libglade2-devel >= 2.0
-BuildRequires: libselinux-devel
+BuildRequires: libselinux-devel >= 1.30
+BuildRequires: libsepol-devel >= 2.0.29
+BuildRequires: libsepol-static >= 2.0.29
+BuildRequires: libstdc++-devel
+BuildRequires: libtool
+BuildRequires: libxml2-devel >= 2
BuildRequires: perl-base
BuildRequires: pkgconfig
-BuildRequires: sqlite3-devel >= 3.0.8
-BuildRequires: tk-devel
-Requires: checkpolicy
-Requires: policy-sources
-Requires: policycoreutils
-Requires: tk-BWidget
+%{?with_python:BuildRequires: python-devel >= 1:2.7}
+BuildRequires: rpmbuild(macros) >= 1.219
+BuildRequires: sqlite3-devel >= 3.2.0
+BuildRequires: swig >= 2.0.0
+%{?with_python:BuildRequires: swig-python >= 2.0.0}
+BuildRequires: swig-tcl >= 2.0.0
+BuildRequires: tcl-devel >= 8.4
+BuildRequires: tk-devel >= 8.4
+Requires: %{name}-libs = %{version}-%{release}
+Suggests: policy-sources
BuildRoot: %{tmpdir}/%{name}-%{version}-root-%(id -u -n)
+%define pkgdatadir %{_datadir}/%{name}-3.3
+
+# python modules use Py* symbols, some of .so files are versioned
+%define skip_post_check_so .*%{py_sitedir}/setools/.*
+
%description
-This package contains some tools and libraries for Security-enhanced
-Linux (a project with enhanced security functionality designed to add
-mandatory access controls to Linux). This package includes the
-following utilities:
-- apol: The GUI-based policy analysis tool.
-- sepcut: A basic GUI-based policy configuration, browsing, editing,
- and testing tool, intended to provide a complete, single user
- interface for viewing the source files of a policy, configuring policy
- program modules, editing policy files, and making and testing the
- policy.
-- seuser: A GUI and command line user manager tool for SELinux. This
- is a tool that actually manages a portion of a running policy (i.e.,
- user accounts).
-- seuser scripts: A set of shell scripts: seuseradd, seusermod, and
- seuserdel. These scripts combine the functions of the associated s*
- commands with seuser to provide a single interface to manage users in
- SE Linux.
-
-And the following tool which can serve as building blocks for the
-development of additional tools:
-- awish: A version of the Tcl/Tk wish interpreter that includes the
- setools libraries. It's used to test SELinux GUIs (apol and seuser
- have the interpreter compiled within them). One could conceivably
- write one's own GUI tools using Tcl/Tk as extended via awish.
-- libapol: The main policy.conf analysis library, which is the core
- library for all our tools.
-- libseuser: The primary logic used for seuser.
+SETools is a collection of graphical tools, command-line tools, and
+libraries designed to facilitate SELinux policy analysis.
+
+The base package includes the following console tools:
+- seaudit-report: audit log analysis tool
+- sechecker: SELinux policy checking tool
+- secmds command line tools: seinfo, sesearch, findcon, replcon, and
+ indexcon
+- sediff: semantic policy difference tool
%description -l pl.UTF-8
-Ten pakiet zawiera narzędzia i biblioteki dla Linuksa w wersji
-Security-enhanced (jest to projekt z rozszerzoną funkcjonalnością
-związaną z bezpieczeństwem opracowaną w celu dodania mandatowej
-kontroli dostępu do Linuksa). Ten pakiet zawiera następujące
-narzędzia:
-- apol - narzędzie do analizy polityki z graficznym interfejsem.
-- sepcut - podstawowe graficzne narzędzie do konfiguracji,
- przeglądania, edycji i testowania polityki, mające zapewnić kompletny
- interfejs do przeglądania plików źródłowych polityki, konfigurowania
- modułów programu polityki, edycji plików polityki oraz tworzenia i
- testowania polityki.
-- seuser - graficzne oraz działające z linii poleceń narzędzie do
- zarządzania użytkownikami dla SELinuksa. Jest to narzędzie
- zarządzające częścią funkcjonującej polityki (czyli kontami
- użytkowników).
-- skrypty seuser - zbiór skryptów powłoki: seuseradd, seusermod oraz
- seuserdel. Łączą one funkcjonalność poleceń s* z seuser, aby zapewnić
- pojedynczy interfejs do zarządzania użytkownikami w SELinuksie.
-- libapol - główna biblioteka analizy policy.conf, która jest rdzeniem
- wszystkich narzędzi z setools.
-- libseuser - podstawowa logika używana przez seuser.
-
-Pakiet zawiera także narzędzie mogące służyć jako część do budowania
-innych narzędzi - jest to awish, czyli wersja interpretera wish z
-Tcl/Tk zawierająca biblioteki setools. Jest używany do testowania GUI
-dla SELinuksa (apol i seuser mają interpreter wkompilowany). Można
-pisać własne graficzne narzędzia przy użyciu awisha.
+SETools to zbiór narzędzi graficznych, narzędzi linii poleceń oraz
+bibliotek mających na celu ułatwienie analizy polityk SELinuksa.
+
+Pakiet podstawowy zawiera narzędzia terminalowe:
+- seaudit-report - narzędzie do analizy logu audytowego
+- sechecker - narzędzie do sprawdzania polityk SELinuksa
+- narzędzia linii poleceń secmds: seinfo, sesearch, findcon, replcon
+ oraz indexcon
+- sediff - narzędzie do znajdywania różnic semantycznych polityk
+
+%package gui
+Summary: Policy analysis graphical tools for SELinux
+Summary(pl.UTF-8): Graficzne narzędzia do analizy polityk SELinuksa
+License: GPL v2+
+Group: Applications/System
+Requires: %{name} = %{version}-%{release}
+Requires: gtk+2 >= 2:2.8
+Requires: tk >= 8.4
+Requires: tk-BWidget >= 1.8
+
+%description gui
+SETools is a collection of graphical tools, command-line tools, and
+libraries designed to facilitate SELinux policy analysis.
+
+This package includes the following graphical tools:
+- apol: policy analysis tool
+- seaudit: audit log analysis tool
+- sediffx: semantic policy difference tool
+
+%description gui -l pl.UTF-8
+SETools to zbiór narzędzi graficznych, narzędzi linii poleceń oraz
+bibliotek mających na celu ułatwienie analizy polityk SELinuksa.
+
+Ten pakiet zawiera narzędzia graficzne:
+- apol - narzędzie do analizy polityk
+- seaudit - narzędzie do analizy logu audytowego
+- sediffx - narzędzie do znajdywania różnic semantycznych polityk
+
+%package libs
+Summary: Policy analysis support libraries for SELinux
+Summary(pl.UTF-8): Biblioteki wspierające analizę polityk SELinuksa
+License: LGPL v2.1+
+Group: Libraries
+Requires: libselinux >= 1.30
+Requires: libsepol >= 2.0.29
+Requires: sqlite3 >= 3.2.0
+
+%description libs
+SETools is a collection of graphical tools, command-line tools, and
+libraries designed to facilitate SELinux policy analysis.
+
+This package includes the following run-time libraries:
+- libapol: policy analysis library
+- libpoldiff: semantic policy difference library
+- libqpol: library that abstracts policy internals
+- libseaudit: parse and filter SELinux audit messages in log files
+- libsefs: SELinux file contexts library
+
+%description libs -l pl.UTF-8
+SETools to zbiór narzędzi graficznych, narzędzi linii poleceń oraz
+bibliotek mających na celu ułatwienie analizy polityk SELinuksa.
+
+Ten pakiet zawiera biblioteki uruchomieniowe:
+- libapol - analizy polityk
+- libpoldiff - różnic semantycznych polityk
+- libqpol - abstrakcji wnętrzności polityk
+- libseaudit - analizy i filtrowania komunikatów audytowych SELinuksa
+ z plików logów
+- libsefs - kontekstów plików SELinuksa
%package devel
-Summary: Header files for setools libraries
-Summary(pl.UTF-8): Pliki nagłówkowe bibliotek setools
+Summary: Header files for SETools libraries
+Summary(pl.UTF-8): Pliki nagłówkowe bibliotek SETools
+License: LGPL v2.1+
Group: Development/Libraries
-Requires: %{name} = %{version}-%{release}
+Requires: %{name}-libs = %{version}-%{release}
%description devel
-Header files for setools libraries: libapol, libseaudit, libsefs,
-libseuser.
+Header files for SETools libraries: libapol, libpoldiff, libqpol,
+libseaudit, libsefs.
%description devel -l pl.UTF-8
-Pliki nagłówkowe bibliotek setools: libapol, libseaudit, libsefs,
-libseuser.
+Pliki nagłówkowe bibliotek SETools: libapol, libpoldiff, libqpol,
+libseaudit, libsefs.
%package static
-Summary: Static setools libraries
-Summary(pl.UTF-8): Statyczne bibliotek setools
+Summary: Static SETools libraries
+Summary(pl.UTF-8): Statyczne biblioteki SETools
+License: LGPL v2.1+
Group: Development/Libraries
Requires: %{name}-devel = %{version}-%{release}
%description static
-Static setools libraries.
+Static SETools libraries.
%description static -l pl.UTF-8
-Statyczne bibliotek setools.
+Statyczne biblioteki SETools.
+
+%package -n java-setools
+Summary: Java bindings for SELinux policy analysis libraries
+Summary(pl.UTF-8): Wiązania Javy do bibliotek analizy polityk SELinuksa
+License: LGPL v2.1+
+Group: Libraries/Java
+Requires: %{name}-libs = %{version}-%{release}
+Requires: jre >= 1.2
+
+%description -n java-setools
+SETools is a collection of graphical tools, command-line tools, and
+libraries designed to facilitate SELinux policy analysis.
+
+This package includes Java bindings for the following libraries:
+- libapol: policy analysis library
+- libpoldiff: semantic policy difference library
+- libqpol: library that abstracts policy internals
+- libseaudit: parse and filter SELinux audit messages in log files
+- libsefs: SELinux file contexts library
+
+%description -n java-setools -l pl.UTF-8
+SETools to zbiór narzędzi graficznych, narzędzi linii poleceń oraz
+bibliotek mających na celu ułatwienie analizy polityk SELinuksa.
+
+Ten pakiet zawiera wiązania Javy do bibliotek uruchomieniowych:
+- libapol - analizy polityk
+- libpoldiff - różnic semantycznych polityk
+- libqpol - abstrakcji wnętrzności polityk
+- libseaudit - analizy i filtrowania komunikatów audytowych SELinuksa
+ z plików logów
+- libsefs - kontekstów plików SELinuksa
+
+%package -n python-setools
+Summary: Python bindings for SELinux policy analysis libraries
+Summary(pl.UTF-8): Wiązania Pythona do bibliotek analizy polityk SELinuksa
+License: LGPL v2.1+ (core modules), GPL v2+ (seinfo and sesearch)
+Group: Libraries/Python
+Requires: %{name}-libs = %{version}-%{release}
+
+%description -n python-setools
+SETools is a collection of graphical tools, command-line tools, and
+libraries designed to facilitate SELinux policy analysis.
+
+This package includes Python bindings for the following libraries:
+- libapol: policy analysis library
+- libpoldiff: semantic policy difference library
+- libqpol: library that abstracts policy internals
+- libseaudit: parse and filter SELinux audit messages in log files
+- libsefs: SELinux file contexts library
+
+%description -n python-setools -l pl.UTF-8
+SETools to zbiór narzędzi graficznych, narzędzi linii poleceń oraz
+bibliotek mających na celu ułatwienie analizy polityk SELinuksa.
+
+Ten pakiet zawiera wiązania Pythona do bibliotek uruchomieniowych:
+- libapol - analizy polityk
+- libpoldiff - różnic semantycznych polityk
+- libqpol - abstrakcji wnętrzności polityk
+- libseaudit - analizy i filtrowania komunikatów audytowych SELinuksa
+ z plików logów
+- libsefs - kontekstów plików SELinuksa
+
+%package -n tcl-setools
+Summary: Tcl bindings for SELinux policy analysis libraries
+Summary(pl.UTF-8): Wiązania Tcl-a do bibliotek analizy polityk SELinuksa
+License: LGPL v2.1+
+Group: Libraries
+Requires: %{name}-libs = %{version}-%{release}
+Requires: tcl >= 8.4
+
+%description -n tcl-setools
+SETools is a collection of graphical tools, command-line tools, and
+libraries designed to facilitate SELinux policy analysis.
+
+This package includes Tcl bindings for the following libraries:
+- libapol: policy analysis library
+- libpoldiff: semantic policy difference library
+- libqpol: library that abstracts policy internals
+- libseaudit: parse and filter SELinux audit messages in log files
+- libsefs: SELinux file contexts library
+
+%description -n tcl-setools -l pl.UTF-8
+SETools to zbiór narzędzi graficznych, narzędzi linii poleceń oraz
+bibliotek mających na celu ułatwienie analizy polityk SELinuksa.
+
+Ten pakiet zawiera wiązania Tcl-a do bibliotek uruchomieniowych:
+- libapol - analizy polityk
+- libpoldiff - różnic semantycznych polityk
+- libqpol - abstrakcji wnętrzności polityk
+- libseaudit - analizy i filtrowania komunikatów audytowych SELinuksa
+ z plików logów
+- libsefs - kontekstów plików SELinuksa
%prep
%setup -q
%patch0 -p1
+%patch1 -p1
+%patch2 -p1
+%patch3 -p1
+%patch4 -p1
+%patch5 -p1
%build
-%{__make} all \
- DYNAMIC=1 \
- CC="%{__cc}" \
- OPT="%{rpmcflags}" \
- TCL_LIBINC="" \
- TCL_LIBS="-ltk -ltcl -lfl -lm -ldl"
+%{__libtoolize}
+%{__aclocal} -I m4
+%{__autoconf}
+%{__autoheader}
+%{__automake}
+%configure \
+ CLASSPATH=. \
+ TCLSH_PROG=/usr/bin/tclsh \
+ WISH_PROG=/usr/bin/wish \
+ --disable-bwidget-check \
+ --disable-selinux-check \
+ %{?with_java:--enable-swig-java} \
+ %{?with_python:--enable-swig-python} \
+ --with-java-prefix=%{java_home}
+
+%{__make}
%install
rm -rf $RPM_BUILD_ROOT
-install -d $RPM_BUILD_ROOT%{_bindir}
+install -d $RPM_BUILD_ROOT{%{_desktopdir},%{_pixmapsdir},/etc/pam.d}
%{__make} install \
- DESTDIR=$RPM_BUILD_ROOT \
- SHARED_LIB_INSTALL_DIR=$RPM_BUILD_ROOT%{_libdir}
-rm -rf $RPM_BUILD_ROOT%{_datadir}/%{name}-%{version}/docs
+ DESTDIR=$RPM_BUILD_ROOT
+
+cp -p %{SOURCE1} $RPM_BUILD_ROOT/etc/pam.d/seaudit
+cp -p packages/rpm/*.desktop $RPM_BUILD_ROOT%{_desktopdir}
+cp -p apol/apol.png seaudit/seaudit.png sediff/sediffx.png $RPM_BUILD_ROOT%{_pixmapsdir}
+
+# let rpm autodetect dependencies
+chmod 755 $RPM_BUILD_ROOT%{_libdir}/lib*.so* \
+ $RPM_BUILD_ROOT%{_libdir}/setools/*/*.so*
+%if %{with python}
+chmod 755 $RPM_BUILD_ROOT%{py_sitedir}/setools/*.so*
+%py_comp $RPM_BUILD_ROOT%{py_sitedir}/setools
+%py_ocomp $RPM_BUILD_ROOT%{py_sitedir}/setools
+%py_postclean
+%endif
+
+%if %{with java}
+# replace symlinks with direct jars
+%{__mv} $RPM_BUILD_ROOT%{pkgdatadir}/*.jar $RPM_BUILD_ROOT%{_javadir}
+%endif
%clean
rm -rf $RPM_BUILD_ROOT
-%post -p /sbin/ldconfig
+%post libs -p /sbin/ldconfig
+%postun libs -p /sbin/ldconfig
-%postun -p /sbin/ldconfig
+%post -n java-setools -p /sbin/ldconfig
+%postun -n java-setools -p /sbin/ldconfig
%files
%defattr(644,root,root,755)
-%doc KNOWN-BUGS README apol/*.txt seaudit/seaudit_help.txt
-%attr(755,root,root) %{_bindir}/*
-%attr(755,root,root) %{_sbindir}/*
-%attr(755,root,root) %{_libdir}/lib*.so.*.*
-%{_datadir}/%{name}-%{version}
-%{_mandir}/man[18]/*
+%attr(755,root,root) %{_bindir}/findcon
+%attr(755,root,root) %{_bindir}/indexcon
+%attr(755,root,root) %{_bindir}/replcon
+%attr(755,root,root) %{_bindir}/seaudit-report
+%attr(755,root,root) %{_bindir}/sechecker
+%attr(755,root,root) %{_bindir}/sediff
+%attr(755,root,root) %{_bindir}/seinfo
+%attr(755,root,root) %{_bindir}/sesearch
+%dir %{pkgdatadir}
+%{pkgdatadir}/sechecker-profiles
+%{pkgdatadir}/sechecker_help.txt
+%{pkgdatadir}/seaudit-report-service
+%{pkgdatadir}/seaudit-report.conf
+%{pkgdatadir}/seaudit-report.css
+%{_mandir}/man1/findcon.1*
+%{_mandir}/man1/indexcon.1*
+%{_mandir}/man1/replcon.1*
+%{_mandir}/man1/sechecker.1*
+%{_mandir}/man1/sediff.1*
+%{_mandir}/man1/seinfo.1*
+%{_mandir}/man1/sesearch.1*
+%{_mandir}/man8/seaudit-report.8*
+
+%files gui
+%defattr(644,root,root,755)
+%attr(755,root,root) %{_bindir}/apol
+%attr(755,root,root) %{_bindir}/sediffx
+%attr(755,root,root) %{_sbindir}/seaudit
+%dir %{_libdir}/setools/apol_tcl
+%attr(755,root,root) %{_libdir}/setools/apol_tcl/libapol_tcl.so.*.*
+%{_libdir}/setools/apol_tcl/pkgIndex.tcl
+%{pkgdatadir}/apol.gif
+%{pkgdatadir}/apol_help.txt
+%{pkgdatadir}/apol_perm_mapping_*
+%{pkgdatadir}/domaintrans_help.txt
+%{pkgdatadir}/dot_seaudit
+%{pkgdatadir}/file_relabel_help.txt
+%{pkgdatadir}/infoflow_help.txt
+%{pkgdatadir}/sediff_help.txt
+%{pkgdatadir}/seaudit_help.txt
+%{pkgdatadir}/types_relation_help.txt
+%{pkgdatadir}/*.glade
+%{pkgdatadir}/*.png
+%config(noreplace) %verify(not md5 mtime size) /etc/pam.d/seaudit
+%{_desktopdir}/apol.desktop
+%{_desktopdir}/seaudit.desktop
+%{_desktopdir}/sediffx.desktop
+%{_pixmapsdir}/apol.png
+%{_pixmapsdir}/seaudit.png
+%{_pixmapsdir}/sediffx.png
+%{_mandir}/man1/apol.1*
+%{_mandir}/man1/sediffx.1*
+%{_mandir}/man8/seaudit.8*
+
+%files libs
+%defattr(644,root,root,755)
+%doc AUTHORS COPYING ChangeLog KNOWN-BUGS NEWS README TODO
+%attr(755,root,root) %{_libdir}/libapol.so.*.*
+%attr(755,root,root) %ghost %{_libdir}/libapol.so.4
+%attr(755,root,root) %{_libdir}/libpoldiff.so.*.*.*
+%attr(755,root,root) %ghost %{_libdir}/libpoldiff.so.1
+%attr(755,root,root) %{_libdir}/libqpol.so.*.*
+%attr(755,root,root) %ghost %{_libdir}/libqpol.so.1
+%attr(755,root,root) %{_libdir}/libseaudit.so.*.*
+%attr(755,root,root) %ghost %{_libdir}/libseaudit.so.4
+%attr(755,root,root) %{_libdir}/libsefs.so.*.*.*
+%attr(755,root,root) %ghost %{_libdir}/libsefs.so.4
%files devel
%defattr(644,root,root,755)
-%attr(755,root,root) %{_libdir}/lib*.so
-%{_includedir}/*
+%attr(755,root,root) %{_libdir}/libapol.so
+%attr(755,root,root) %{_libdir}/libpoldiff.so
+%attr(755,root,root) %{_libdir}/libqpol.so
+%attr(755,root,root) %{_libdir}/libseaudit.so
+%attr(755,root,root) %{_libdir}/libsefs.so
+%{_includedir}/apol
+%{_includedir}/poldiff
+%{_includedir}/qpol
+%{_includedir}/seaudit
+%{_includedir}/sefs
+%{_pkgconfigdir}/libapol.pc
+%{_pkgconfigdir}/libpoldiff.pc
+%{_pkgconfigdir}/libqpol.pc
+%{_pkgconfigdir}/libseaudit.pc
+%{_pkgconfigdir}/libsefs.pc
%files static
%defattr(644,root,root,755)
-%{_libdir}/lib*.a
+%{_libdir}/libapol.a
+%{_libdir}/libpoldiff.a
+%{_libdir}/libqpol.a
+%{_libdir}/libseaudit.a
+%{_libdir}/libsefs.a
+
+%if %{with java}
+%files -n java-setools
+%defattr(644,root,root,755)
+%attr(755,root,root) %{_libdir}/libjapol.so.*.*
+%attr(755,root,root) %ghost %{_libdir}/libjapol.so.4
+%attr(755,root,root) %{_libdir}/libjapol.so
+%attr(755,root,root) %{_libdir}/libjpoldiff.so.*.*.*
+%attr(755,root,root) %ghost %{_libdir}/libjpoldiff.so.1
+%attr(755,root,root) %{_libdir}/libjpoldiff.so
+%attr(755,root,root) %{_libdir}/libjqpol.so.*.*
+%attr(755,root,root) %ghost %{_libdir}/libjqpol.so.1
+%attr(755,root,root) %{_libdir}/libjqpol.so
+%attr(755,root,root) %{_libdir}/libjseaudit.so.*.*
+%attr(755,root,root) %ghost %{_libdir}/libjseaudit.so.4
+%attr(755,root,root) %{_libdir}/libjseaudit.so
+%attr(755,root,root) %{_libdir}/libjsefs.so.*.*.*
+%attr(755,root,root) %ghost %{_libdir}/libjsefs.so.4
+%attr(755,root,root) %{_libdir}/libjsefs.so
+%{_javadir}/apol.jar
+%{_javadir}/poldiff.jar
+%{_javadir}/qpol.jar
+%{_javadir}/seaudit.jar
+%{_javadir}/sefs.jar
+%endif
+
+%if %{with python}
+%files -n python-setools
+%defattr(644,root,root,755)
+%dir %{py_sitedir}/setools
+%attr(755,root,root) %{py_sitedir}/setools/_apol.so*
+%attr(755,root,root) %{py_sitedir}/setools/_poldiff.so*
+%attr(755,root,root) %{py_sitedir}/setools/_qpol.so*
+%attr(755,root,root) %{py_sitedir}/setools/_seaudit.so*
+%attr(755,root,root) %{py_sitedir}/setools/_sefs.so*
+%attr(755,root,root) %{py_sitedir}/setools/_seinfo.so
+%attr(755,root,root) %{py_sitedir}/setools/_sesearch.so
+%{py_sitedir}/setools/__init__.py[co]
+%{py_sitedir}/setools/apol.py[co]
+%{py_sitedir}/setools/poldiff.py[co]
+%{py_sitedir}/setools/qpol.py[co]
+%{py_sitedir}/setools/seaudit.py[co]
+%{py_sitedir}/setools/sefs.py[co]
+%{py_sitedir}/setools-1.0-py*.egg-info
+%dir %{py_sitescriptdir}/setools
+%{py_sitescriptdir}/setools/__init__.py[co]
+%endif
+
+%files -n tcl-setools
+%defattr(644,root,root,755)
+%dir %{_libdir}/setools
+%dir %{_libdir}/setools/apol
+%attr(755,root,root) %{_libdir}/setools/apol/libtapol.so.*.*
+%{_libdir}/setools/apol/pkgIndex.tcl
+%dir %{_libdir}/setools/poldiff
+%attr(755,root,root) %{_libdir}/setools/poldiff/libtpoldiff.so.*.*.*
+%{_libdir}/setools/poldiff/pkgIndex.tcl
+%dir %{_libdir}/setools/qpol
+%attr(755,root,root) %{_libdir}/setools/qpol/libtqpol.so.*.*
+%{_libdir}/setools/qpol/pkgIndex.tcl
+%dir %{_libdir}/setools/seaudit
+%attr(755,root,root) %{_libdir}/setools/seaudit/libtseaudit.so.*.*
+%{_libdir}/setools/seaudit/pkgIndex.tcl
+%dir %{_libdir}/setools/sefs
+%attr(755,root,root) %{_libdir}/setools/sefs/libtsefs.so.*.*.*
+%{_libdir}/setools/sefs/pkgIndex.tcl
diff --git a/seaudit.pamd b/seaudit.pamd
new file mode 100644
index 0000000..ab053c5
--- /dev/null
+++ b/seaudit.pamd
@@ -0,0 +1,4 @@
+#%PAM-1.0
+auth include system-auth
+account include system-auth
+session include system-auth
diff --git a/setools-format.patch b/setools-format.patch
new file mode 100644
index 0000000..e112132
--- /dev/null
+++ b/setools-format.patch
@@ -0,0 +1,119 @@
+--- setools-3.3.8/libseaudit/src/bool_message.c.orig 2013-01-16 17:36:23.000000000 +0100
++++ setools-3.3.8/libseaudit/src/bool_message.c 2014-03-05 10:48:42.193733896 +0100
+@@ -101,7 +101,7 @@
+ return NULL;
+ }
+ if ((misc_string = bool_message_to_misc_string(boolm)) == NULL ||
+- apol_str_appendf(&s, &len, misc_string) < 0 || apol_str_append(&s, &len, close_brace) < 0) {
++ apol_str_appendf(&s, &len, "%s%s", misc_string, close_brace) < 0) {
+ free(misc_string);
+ return NULL;
+ }
+@@ -128,7 +128,7 @@
+ return NULL;
+ }
+ if ((misc_string = bool_message_to_misc_string(boolm)) == NULL ||
+- apol_str_appendf(&s, &len, misc_string) < 0 || apol_str_appendf(&s, &len, "%s%s<br>", s, close_brace) < 0) {
++ apol_str_appendf(&s, &len, "%s%s%s<br>", misc_string, s, close_brace) < 0) {
+ free(misc_string);
+ return NULL;
+ }
+--- setools-3.3.8/libseaudit/src/filter.c.orig 2013-01-16 17:36:23.000000000 +0100
++++ setools-3.3.8/libseaudit/src/filter.c 2014-03-05 10:49:54.833730849 +0100
+@@ -1108,8 +1108,7 @@
+ if ((file = fopen(filename, "w")) == NULL) {
+ return -1;
+ }
+- fprintf(file, XML_VER);
+- fprintf(file, "<view xmlns=\"http://oss.tresys.com/projects/setools/seaudit-%s/\">\n", FILTER_FILE_FORMAT_VERSION);
++ fprintf(file, "%s<view xmlns=\"http://oss.tresys.com/projects/setools/seaudit-%s/\">\n", XML_VER, FILTER_FILE_FORMAT_VERSION);
+ filter_append_to_file(filter, file, 1);
+ fprintf(file, "</view>\n");
+ fclose(file);
+--- setools-3.3.8/libseaudit/src/model.c.orig 2013-01-16 17:36:23.000000000 +0100
++++ setools-3.3.8/libseaudit/src/model.c 2014-03-05 10:50:24.457062938 +0100
+@@ -514,8 +514,8 @@
+ if ((file = fopen(filename, "w")) == NULL) {
+ return -1;
+ }
+- fprintf(file, XML_VER);
+- fprintf(file, "<view xmlns=\"http://oss.tresys.com/projects/setools/seaudit-%s/\" name=\"%s\" match=\"%s\" show=\"%s\">\n",
++ fprintf(file, "%s<view xmlns=\"http://oss.tresys.com/projects/setools/seaudit-%s/\" name=\"%s\" match=\"%s\" show=\"%s\">\n",
++ XML_VER,
+ FILTER_FILE_FORMAT_VERSION, model->name,
+ model->match == SEAUDIT_FILTER_MATCH_ALL ? "all" : "any",
+ model->visible == SEAUDIT_FILTER_VISIBLE_SHOW ? "true" : "false");
+--- setools-3.3.8/sediff/progress.c.orig 2013-01-16 17:36:24.000000000 +0100
++++ setools-3.3.8/sediff/progress.c 2014-03-05 10:57:45.037044450 +0100
+@@ -115,10 +115,10 @@
+ }
+ g_mutex_unlock(progress->mutex);
+ if (progress->done < 0) {
+- toplevel_ERR(progress->top, GTK_LABEL(progress->label2)->label);
++ toplevel_ERR(progress->top, "%s", GTK_LABEL(progress->label2)->label);
+ return progress->done;
+ } else if (progress->done > 1) {
+- toplevel_WARN(progress->top, GTK_LABEL(progress->label2)->label);
++ toplevel_WARN(progress->top, "%s", GTK_LABEL(progress->label2)->label);
+ return progress->done - 1;
+ } else {
+ progress->done = 0;
+--- setools-3.3.8/sediff/toplevel.c.orig 2013-01-16 17:36:24.000000000 +0100
++++ setools-3.3.8/sediff/toplevel.c 2014-03-05 11:04:39.027027078 +0100
+@@ -453,7 +453,7 @@
+ ERR(NULL, "%s", strerror(errno));
+ return;
+ }
+- dialog = gtk_message_dialog_new(top->w, GTK_DIALOG_DESTROY_WITH_PARENT, msg_type, GTK_BUTTONS_CLOSE, msg);
++ dialog = gtk_message_dialog_new(top->w, GTK_DIALOG_DESTROY_WITH_PARENT, msg_type, GTK_BUTTONS_CLOSE, "%s", msg);
+ free(msg);
+ gtk_dialog_run(GTK_DIALOG(dialog));
+ gtk_widget_destroy(dialog);
+--- setools-3.3.8/sediff/utilgui.c.orig 2013-01-16 17:36:24.000000000 +0100
++++ setools-3.3.8/sediff/utilgui.c 2014-03-05 11:06:56.727021298 +0100
+@@ -31,7 +31,7 @@
+ void util_message(GtkWindow * parent, GtkMessageType msg_type, const char *msg)
+ {
+ GtkWidget *dialog;
+- dialog = gtk_message_dialog_new(parent, GTK_DIALOG_DESTROY_WITH_PARENT, msg_type, GTK_BUTTONS_CLOSE, msg);
++ dialog = gtk_message_dialog_new(parent, GTK_DIALOG_DESTROY_WITH_PARENT, msg_type, GTK_BUTTONS_CLOSE, "%s", msg);
+ gtk_dialog_run(GTK_DIALOG(dialog));
+ gtk_widget_destroy(dialog);
+ }
+--- setools-3.3.8/seaudit/progress.c.orig 2013-01-16 17:36:24.000000000 +0100
++++ setools-3.3.8/seaudit/progress.c 2014-03-05 11:23:30.663646251 +0100
+@@ -114,10 +114,10 @@
+ }
+ g_mutex_unlock(progress->mutex);
+ if (progress->done < 0) {
+- toplevel_ERR(progress->top, GTK_LABEL(progress->label2)->label);
++ toplevel_ERR(progress->top, "%s", GTK_LABEL(progress->label2)->label);
+ return progress->done;
+ } else if (progress->done > 1) {
+- toplevel_WARN(progress->top, GTK_LABEL(progress->label2)->label);
++ toplevel_WARN(progress->top, "%s", GTK_LABEL(progress->label2)->label);
+ return progress->done - 1;
+ } else {
+ progress->done = 0;
+--- setools-3.3.8/seaudit/toplevel.c.orig 2013-01-16 17:36:24.000000000 +0100
++++ setools-3.3.8/seaudit/toplevel.c 2014-03-05 11:23:58.290311759 +0100
+@@ -902,7 +902,7 @@
+ ERR(NULL, "%s", strerror(errno));
+ return;
+ }
+- dialog = gtk_message_dialog_new(top->w, GTK_DIALOG_DESTROY_WITH_PARENT, msg_type, GTK_BUTTONS_CLOSE, msg);
++ dialog = gtk_message_dialog_new(top->w, GTK_DIALOG_DESTROY_WITH_PARENT, msg_type, GTK_BUTTONS_CLOSE, "%s", msg);
+ free(msg);
+ gtk_dialog_run(GTK_DIALOG(dialog));
+ gtk_widget_destroy(dialog);
+--- setools-3.3.8/seaudit/utilgui.c.orig 2013-01-16 17:36:24.000000000 +0100
++++ setools-3.3.8/seaudit/utilgui.c 2014-03-05 11:24:33.873643600 +0100
+@@ -30,7 +30,7 @@
+ void util_message(GtkWindow * parent, GtkMessageType msg_type, const char *msg)
+ {
+ GtkWidget *dialog;
+- dialog = gtk_message_dialog_new(parent, GTK_DIALOG_DESTROY_WITH_PARENT, msg_type, GTK_BUTTONS_CLOSE, msg);
++ dialog = gtk_message_dialog_new(parent, GTK_DIALOG_DESTROY_WITH_PARENT, msg_type, GTK_BUTTONS_CLOSE, "%s", msg);
+ gtk_dialog_run(GTK_DIALOG(dialog));
+ gtk_widget_destroy(dialog);
+ }
diff --git a/setools-link.patch b/setools-link.patch
new file mode 100644
index 0000000..4abea49
--- /dev/null
+++ b/setools-link.patch
@@ -0,0 +1,55 @@
+--- setools-3.3.8/libapol/swig/tcl/Makefile.am.orig 2013-01-16 17:36:23.000000000 +0100
++++ setools-3.3.8/libapol/swig/tcl/Makefile.am 2014-03-05 11:45:32.136924128 +0100
+@@ -21,7 +21,7 @@
+ $(SWIG) $(SWIG_TCL_OPT) -pkgversion @libapol_version@ -o $@ -I$(top_srcdir)/libapol/include -I$(top_srcdir)/libqpol/swig $<
+
+ $(wrappedso_DATA): $(BUILT_SOURCES)
+- $(CC) -shared -o $@ $^ $(AM_CFLAGS) $(CFLAGS) $(SWIG_TCL_CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -Wl,-soname,$(wrappedso_SONAME)
++ $(CC) -shared -o $@ $^ $(AM_CFLAGS) $(CFLAGS) $(SWIG_TCL_CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -Wl,-soname,$(wrappedso_SONAME) $(TCL_LIB_FLAG)
+ $(LN_S) -f $@ $(wrappedso_SONAME)
+ $(LN_S) -f $@ $(short_name)
+
+--- setools-3.3.8/libpoldiff/swig/tcl/Makefile.am.orig 2013-01-16 17:36:24.000000000 +0100
++++ setools-3.3.8/libpoldiff/swig/tcl/Makefile.am 2014-03-05 11:46:09.480255895 +0100
+@@ -22,7 +22,7 @@
+ $(SWIG) $(SWIG_TCL_OPT) -pkgversion @libpoldiff_version@ -o $@ -I$(top_srcdir)/libpoldiff/include -I$(top_srcdir)/libapol/include -I$(top_srcdir)/libapol/swig -I$(top_srcdir)/libqpol/swig $<
+
+ $(wrappedso_DATA): $(BUILT_SOURCES)
+- $(CC) -shared -o $@ $^ $(AM_CFLAGS) $(CFLAGS) $(SWIG_TCL_CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -Wl,-soname,$(wrappedso_SONAME)
++ $(CC) -shared -o $@ $^ $(AM_CFLAGS) $(CFLAGS) $(SWIG_TCL_CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -Wl,-soname,$(wrappedso_SONAME) $(TCL_LIB_FLAG)
+ $(LN_S) -f $@ $(wrappedso_SONAME)
+ $(LN_S) -f $@ $(short_name)
+
+--- setools-3.3.8/libqpol/swig/tcl/Makefile.am.orig 2013-01-16 17:36:24.000000000 +0100
++++ setools-3.3.8/libqpol/swig/tcl/Makefile.am 2014-03-05 11:46:52.190254102 +0100
+@@ -18,7 +18,7 @@
+ $(SWIG) $(SWIG_TCL_OPT) -pkgversion @libqpol_version@ -o $@ $<
+
+ $(wrappedso_DATA): $(BUILT_SOURCES)
+- $(CC) -shared -o $@ $^ $(AM_CFLAGS) $(CFLAGS) $(SWIG_TCL_CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -Wl,-soname,$(wrappedso_SONAME)
++ $(CC) -shared -o $@ $^ $(AM_CFLAGS) $(CFLAGS) $(SWIG_TCL_CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -Wl,-soname,$(wrappedso_SONAME) $(TCL_LIB_FLAG)
+ $(LN_S) -f $@ $(wrappedso_SONAME)
+ $(LN_S) -f $@ $(short_name)
+
+--- setools-3.3.8/libseaudit/swig/tcl/Makefile.am.orig 2013-01-16 17:36:23.000000000 +0100
++++ setools-3.3.8/libseaudit/swig/tcl/Makefile.am 2014-03-05 11:47:16.393586419 +0100
+@@ -22,7 +22,7 @@
+ $(SWIG) $(SWIG_TCL_OPT) -pkgversion @libseaudit_version@ -o $@ -I$(top_srcdir)/libseaudit/include -I$(top_srcdir)/libapol/include -I$(top_srcdir)/libapol/swig -I$(top_srcdir)/libqpol/swig $<
+
+ $(wrappedso_DATA): $(BUILT_SOURCES)
+- $(CC) -shared -o $@ $^ $(AM_CFLAGS) $(CFLAGS) $(SWIG_TCL_CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -Wl,-soname,$(wrappedso_SONAME)
++ $(CC) -shared -o $@ $^ $(AM_CFLAGS) $(CFLAGS) $(SWIG_TCL_CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -Wl,-soname,$(wrappedso_SONAME) $(TCL_LIB_FLAG)
+ $(LN_S) -f $@ $(wrappedso_SONAME)
+ $(LN_S) -f $@ $(short_name)
+
+--- setools-3.3.8/apol/Makefile.am.orig 2013-01-16 17:36:23.000000000 +0100
++++ setools-3.3.8/apol/Makefile.am 2014-03-05 12:13:28.716853768 +0100
+@@ -85,7 +85,7 @@
+ -I$(top_srcdir)/libqpol/swig $<
+
+ $(wrappedso_DATA): apol_tcl.cc apol_tcl_wrap.cc
+- $(CXX) -shared -o $@ $^ $(AM_CXXFLAGS) $(CXXFLAGS) $(SWIG_TCL_CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -Wl,-soname,$(wrappedso_SONAME)
++ $(CXX) -shared -o $@ $^ $(AM_CXXFLAGS) $(CXXFLAGS) $(SWIG_TCL_CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -Wl,-soname,$(wrappedso_SONAME) $(TCL_LIB_FLAG)
+
+ $(package_SCRIPTS): $(wrappedso_DATA) mkIndex.tcl
+ cat mkIndex.tcl | LD_LIBRARY_PATH=$(top_builddir)/libqpol/src:$(top_builddir)/libapol/src:$(top_builddir)/libsefs/src $(TCLSH_PROG)
diff --git a/setools-opt.patch b/setools-opt.patch
deleted file mode 100644
index cf9a497..0000000
--- a/setools-opt.patch
+++ /dev/null
@@ -1,81 +0,0 @@
-diff -ur setools.org/libapol/Makefile setools.new/libapol/Makefile
---- setools.org/libapol/Makefile 2006-01-23 16:58:42.000000000 +0100
-+++ setools.new/libapol/Makefile 2006-04-17 00:31:08.188294750 +0200
-@@ -21,7 +21,7 @@
- CFLAGS += -DLIBAPOL_POLICY_INSTALL_DIR='"$(POLICY_INSTALL_DIR)"'
- CFLAGS += -DLIBAPOL_SELINUX_DIR='"$(SELINUX_DIR)"'
- CFLAGS += -DLIBAPOL_DEFAULT_POLICY='"$(POLICY_SRC_FILE)"'
--CFLAGS += -I.
-+CFLAGS += -I. -fPIC
-
- LDFLAGS += -lfl
-
-diff -ur setools.org/libseaudit/Makefile setools.new/libseaudit/Makefile
---- setools.org/libseaudit/Makefile 2006-01-23 16:58:42.000000000 +0100
-+++ setools.new/libseaudit/Makefile 2006-04-17 00:32:42.678200000 +0200
-@@ -4,6 +4,8 @@
- SEAUDIT_LIBS = libseaudit.a ../libapol/libapol.a $(LIBS)
- CFLAGS += -D_GNU_SOURCE
- CFLAGS += -DLIBSEAUDIT_VERSION_STRING='"$(shell cat VERSION)"'
-+CFLAGS += -fPIC
-+LDFLAGS += -lxml2
- LIBXML_FLAGS = `pkg-config --cflags libxml-2.0`
-
- TARGET = libseaudit.so
-diff -ur setools.org/libsefs/fsdata.c setools.new/libsefs/fsdata.c
---- setools.org/libsefs/fsdata.c 2006-01-23 16:58:42.000000000 +0100
-+++ setools.new/libsefs/fsdata.c 2006-04-17 00:30:06.880463250 +0200
-@@ -10,7 +10,7 @@
-
- #include "fsdata.h"
- /* sqlite db stuff */
--#include "sqlite/sqlite3.h"
-+#include <sqlite3.h>
-
- /* SE Linux includes*/
- #include <selinux/selinux.h>
-diff -ur setools.org/libsefs/Makefile setools.new/libsefs/Makefile
---- setools.org/libsefs/Makefile 2006-01-23 16:58:42.000000000 +0100
-+++ setools.new/libsefs/Makefile 2006-04-17 00:29:01.912403000 +0200
-@@ -25,10 +25,10 @@
- $(MAKE) -C sqlite all
-
--$(LIBSO): sqlite $(LIB-OBJ)
-- $(CC) $(LDFLAGS) -shared -o $(LIBSO) $(LIB-OBJ) $(SQL-OBJ) -Wl,-soname,$(SONAME)
-+$(LIBSO): $(LIB-OBJ)
-+ $(CC) $(LDFLAGS) -shared -o $(LIBSO) $(LIB-OBJ) -Wl,-soname,$(SONAME) -lsqlite3
-
--libsefs.a: sqlite $(LIB-OBJ)
-- ar cr $@ $(LIB-OBJ) $(SQL-OBJ)
-+libsefs.a: $(LIB-OBJ)
-+ ar cr $@ $(LIB-OBJ)
-
- install-libsefs-shared: $(LIBSO) install-includes
- install -m 755 $(LIBSO) $(SHARED_LIB_INSTALL_DIR)
-diff -ur setools.org/Makefile setools.new/Makefile
---- setools.org/Makefile 2006-01-23 16:58:42.000000000 +0100
-+++ setools.new/Makefile 2006-04-17 00:24:58.009160000 +0200
-@@ -89,9 +89,9 @@
- endif
-
- ifeq ($(DEBUG), 0)
--CFLAGS += -Wall -O2 -fPIC $(CC_DEFINES)
-+CFLAGS += $(OPT) -Wall -fPIC $(CC_DEFINES)
- else
--CFLAGS += -Wall -g -fPIC $(CC_DEFINES) -DDEBUG
-+CFLAGS += $(OPT) -Wall -fPIC $(CC_DEFINES) -DDEBUG
- #CFLAGS = -Wall -ansi -pedantic -g $(CC_DEFINES)
- endif
-
-diff -ur setools.org/secmds/Makefile setools.new/secmds/Makefile
---- setools.org/secmds/Makefile 2006-01-20 23:01:04.000000000 +0100
-+++ setools.new/secmds/Makefile 2006-04-17 00:52:47.641505500 +0200
-@@ -47,7 +47,7 @@
- $(CC) -c indexcon.c $(CFLAGS) $(INCLUDE)
-
- indexcon: indexcon.o $(LIBSEFS) $(LIBAPOL)
-- $(CC) -o $@ indexcon.o $(LDFLAGS) $(STATICSEFS) $(LIBSELINUXSO) $(STATICAPOL) $(LIBS)
-+ $(CC) -o $@ indexcon.o $(LDFLAGS) $(STATICSEFS) $(LIBSELINUXSO) $(STATICAPOL) $(LIBS) -lsqlite3
-
- searchcon.o: searchcon.c
- $(CC) -c searchcon.c $(CFLAGS) $(INCLUDE)
diff --git a/setools-sh.patch b/setools-sh.patch
new file mode 100644
index 0000000..7aed98f
--- /dev/null
+++ b/setools-sh.patch
@@ -0,0 +1,25 @@
+--- setools-3.3.8/configure.ac.orig 2013-01-16 17:36:24.000000000 +0100
++++ setools-3.3.8/configure.ac 2014-03-04 15:44:31.839948212 +0100
+@@ -368,9 +368,9 @@
+ fi
+
+ if test "x${enable_debug}" = xyes; then
+- TCL_AUTOPATH+=' $(top_builddir)/libqpol/swig/tcl $(top_builddir)/libapol/swig/tcl $(top_builddir)/libsefs/swig/tcl $(top_builddir)/libpolsearch/swig/tcl $(top_builddir)/apol'
++ TCL_AUTOPATH="$TCL_AUTOPATH"' $(top_builddir)/libqpol/swig/tcl $(top_builddir)/libapol/swig/tcl $(top_builddir)/libsefs/swig/tcl $(top_builddir)/libpolsearch/swig/tcl $(top_builddir)/apol'
+ else
+- TCL_AUTOPATH+=' $(libdir)/setools'
++ TCL_AUTOPATH="$TCL_AUTOPATH"' $(libdir)/setools'
+ fi
+ AC_SUBST(TCL_AUTOPATH)
+
+@@ -688,8 +688,8 @@
+ AC_SUBST(SQLITE3_CFLAGS)
+ AC_SUBST(SQLITE3_LIBS)
+
+-SEAUDIT_LIB_FLAG+=" ${XML_LIBS}"
+-SEFS_LIB_FLAG+=" ${SQLITE3_LIBS}"
++SEAUDIT_LIB_FLAG="$SEAUDIT_LIB_FLAG ${XML_LIBS}"
++SEFS_LIB_FLAG="$SEFS_LIB_FLAG ${SQLITE3_LIBS}"
+
+ gtk_version_2_8=1
+ if test "x${build_gui}" = xyes; then
diff --git a/setools-swig-part2.patch b/setools-swig-part2.patch
new file mode 100644
index 0000000..5836ec2
--- /dev/null
+++ b/setools-swig-part2.patch
@@ -0,0 +1,6434 @@
+--- setools-3.3.8/libapol/swig/apol.i.orig 2014-03-04 18:06:00.769591966 +0100
++++ setools-3.3.8/libapol/swig/apol.i 2014-03-05 07:50:17.377516469 +0100
+@@ -255,7 +255,7 @@
+ return ip;
+ }
+ %}
+-%extend apol_ip_t {
++%extend apol_ip {
+ apol_ip(const char *str) {
+ apol_ip_t *ip = NULL;
+ BEGIN_EXCEPTION
+@@ -302,7 +302,16 @@
+ typedef struct apol_string_vector apol_string_vector_t;
+ %}
+ typedef struct apol_vector {} apol_vector_t;
+-%extend apol_vector_t {
++%rename(apol_vector_get_size) apol_vector_wrap_get_size;
++%rename(apol_vector_get_capacity) apol_vector_wrap_get_capacity;
++%rename(apol_vector_get_element) apol_vector_wrap_get_element;
++%rename(apol_vector_append) apol_vector_wrap_append;
++%rename(apol_vector_append_unique) apol_vector_wrap_append_unique;
++%rename(apol_vector_cat) apol_vector_wrap_cat;
++%rename(apol_vector_remove) apol_vector_wrap_remove;
++%rename(apol_vector_sort) apol_vector_wrap_sort;
++%rename(apol_vector_sort_uniquify) apol_vector_wrap_sort_uniquify;
++%extend apol_vector {
+ apol_vector() {
+ return apol_vector_create(NULL);
+ };
+@@ -315,19 +324,19 @@
+ apol_vector(apol_vector_t *a, apol_vector_t *b) {
+ return apol_vector_create_from_intersection(a, b, NULL, NULL);
+ };
+- size_t get_size() {
++ size_t wrap_get_size() {
+ return apol_vector_get_size(self);
+ };
+- size_t get_capacity() {
++ size_t wrap_get_capacity() {
+ return apol_vector_get_capacity(self);
+ };
+- void *get_element(size_t i) {
++ void *wrap_get_element(size_t i) {
+ return apol_vector_get_element(self, i);
+ };
+ ~apol_vector() {
+ apol_vector_destroy(&self);
+ };
+- void append(void *x) {
++ void wrap_append(void *x) {
+ BEGIN_EXCEPTION
+ if (apol_vector_append(self, x)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -336,7 +345,7 @@
+ fail:
+ return;
+ };
+- void append_unique(void *x) {
++ void wrap_append_unique(void *x) {
+ BEGIN_EXCEPTION
+ if (apol_vector_append_unique(self, x, NULL, NULL)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -345,7 +354,7 @@
+ fail:
+ return;
+ };
+- void cat(apol_vector_t *src) {
++ void wrap_cat(apol_vector_t *src) {
+ BEGIN_EXCEPTION
+ if (apol_vector_cat(self, src)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -354,7 +363,7 @@
+ fail:
+ return;
+ };
+- void remove(size_t idx) {
++ void wrap_remove(size_t idx) {
+ BEGIN_EXCEPTION
+ if (apol_vector_remove(self, idx)) {
+ SWIG_exception(SWIG_RuntimeError, "Error removing vector element");
+@@ -363,10 +372,10 @@
+ fail:
+ return;
+ };
+- void sort() {
++ void wrap_sort() {
+ apol_vector_sort(self, NULL, NULL);
+ };
+- void sort_uniquify() {
++ void wrap_sort_uniquify() {
+ apol_vector_sort_uniquify(self, NULL, NULL);
+ };
+ };
+@@ -378,7 +387,7 @@
+ }
+ %}
+ typedef struct apol_string_vector {} apol_string_vector_t;
+-%extend apol_string_vector_t {
++%extend apol_string_vector {
+ apol_string_vector() {
+ return (apol_string_vector_t*)apol_vector_create(free);
+ };
+@@ -461,7 +470,12 @@
+ APOL_POLICY_PATH_TYPE_MODULAR
+ } apol_policy_path_type_e;
+ typedef struct apol_policy_path {} apol_policy_path_t;
+-%extend apol_policy_path_t {
++%rename(apol_policy_path_get_type) apol_policy_path_wrap_get_type;
++%rename(apol_policy_path_get_primary) apol_policy_path_wrap_get_primary;
++%rename(apol_policy_path_get_modules) apol_policy_path_wrap_get_modules;
++%rename(apol_policy_path_to_string) apol_policy_path_wrap_to_string;
++%rename(apol_policy_path_to_file) apol_policy_path_wrap_to_file;
++%extend apol_policy_path {
+ apol_policy_path(apol_policy_path_type_e type, char * primary, apol_string_vector_t *modules = NULL) {
+ apol_policy_path_t *p;
+ BEGIN_EXCEPTION
+@@ -505,17 +519,17 @@
+ ~apol_policy_path() {
+ apol_policy_path_destroy(&self);
+ };
+- apol_policy_path_type_e get_type() {
++ apol_policy_path_type_e wrap_get_type() {
+ return apol_policy_path_get_type(self);
+ };
+- const char *get_primary() {
++ const char *wrap_get_primary() {
+ return apol_policy_path_get_primary(self);
+ };
+- const apol_string_vector_t *get_modules() {
++ const apol_string_vector_t *wrap_get_modules() {
+ return (apol_string_vector_t*)apol_policy_path_get_modules(self);
+ };
+ %newobject to_string();
+- char *to_string() {
++ char *wrap_to_string() {
+ char *str;
+ BEGIN_EXCEPTION
+ str = apol_policy_path_to_string(self);
+@@ -526,7 +540,7 @@
+ fail:
+ return str;
+ };
+- void to_file(char *path) {
++ void wrap_to_file(char *path) {
+ BEGIN_EXCEPTION
+ if (apol_policy_path_to_file(self, path)) {
+ SWIG_exception(SWIG_RuntimeError, "Input/outpet error");
+@@ -548,7 +562,16 @@
+ #define APOL_PERMMAP_WRITE 0x02
+ #define APOL_PERMMAP_BOTH (APOL_PERMMAP_READ | APOL_PERMMAP_WRITE)
+ #define APOL_PERMMAP_NONE 0x10
+-%extend apol_policy_t {
++%rename(apol_policy_get_policy_type) apol_policy_wrap_get_policy_type;
++%rename(apol_policy_get_qpol) apol_policy_wrap_get_qpol;
++%rename(apol_policy_is_mls) apol_policy_wrap_is_mls;
++%rename(apol_policy_get_version_type_mls_str) apol_policy_wrap_get_version_type_mls_str;
++%rename(apol_policy_open_permmap) apol_policy_wrap_open_permmap;
++%rename(apol_policy_save_permmap) apol_policy_wrap_save_permmap;
++%rename(apol_policy_set_permmap) apol_policy_wrap_set_permmap;
++%rename(apol_policy_build_domain_trans_table) apol_policy_wrap_build_domain_trans_table;
++%rename(apol_policy_reset_domain_trans_table) apol_policy_wrap_reset_domain_trans_table;
++%extend apol_policy {
+ apol_policy(apol_policy_path_t *path, int options = 0) {
+ apol_policy_t *p;
+ BEGIN_EXCEPTION
+@@ -567,17 +590,17 @@
+ ~apol_policy() {
+ apol_policy_destroy(&self);
+ };
+- int get_policy_type() {
++ int wrap_get_policy_type() {
+ return apol_policy_get_policy_type(self);
+ };
+- qpol_policy_t *get_qpol() {
++ qpol_policy_t *wrap_get_qpol() {
+ return apol_policy_get_qpol(self);
+ };
+- int is_mls() {
++ int wrap_is_mls() {
+ return apol_policy_is_mls(self);
+ };
+ %newobject get_version_type_mls_str();
+- char *get_version_type_mls_str() {
++ char *wrap_get_version_type_mls_str() {
+ char *str;
+ BEGIN_EXCEPTION
+ str = apol_policy_get_version_type_mls_str(self);
+@@ -588,7 +611,7 @@
+ fail:
+ return str;
+ };
+- void open_permmap(const char *path) {
++ void wrap_open_permmap(const char *path) {
+ BEGIN_EXCEPTION
+ if (apol_policy_open_permmap(self, path) < 0) {
+ SWIG_exception(SWIG_RuntimeError, "Error loading permission map");
+@@ -597,7 +620,7 @@
+ fail:
+ return;
+ };
+- void save_permmap(const char *path) {
++ void wrap_save_permmap(const char *path) {
+ BEGIN_EXCEPTION
+ if (apol_policy_save_permmap(self, path)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not save permission map");
+@@ -626,7 +649,7 @@
+ fail:
+ return dir;
+ };
+- void set_permmap(const char *class_name, const char *perm_name, int direction, int weight) {
++ void wrap_set_permmap(const char *class_name, const char *perm_name, int direction, int weight) {
+ BEGIN_EXCEPTION
+ if (apol_policy_set_permmap(self, class_name, perm_name, direction, weight)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set permission mapping");
+@@ -635,7 +658,7 @@
+ fail:
+ return;
+ };
+- void build_domain_trans_table() {
++ void wrap_build_domain_trans_table() {
+ BEGIN_EXCEPTION
+ if (apol_policy_build_domain_trans_table(self)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not build domain transition table");
+@@ -644,14 +667,16 @@
+ fail:
+ return;
+ };
+- void reset_domain_trans_table() {
++ void wrap_reset_domain_trans_table() {
+ apol_policy_reset_domain_trans_table(self);
+ }
+ };
+
+ /* apol type query */
+ typedef struct apol_type_query {} apol_type_query_t;
+-%extend apol_type_query_t {
++%rename(apol_type_query_set_type) apol_type_query_wrap_set_type;
++%rename(apol_type_query_set_regex) apol_type_query_wrap_set_regex;
++%extend apol_type_query {
+ apol_type_query() {
+ apol_type_query_t *tq;
+ BEGIN_EXCEPTION
+@@ -677,7 +702,7 @@
+ fail:
+ return v;
+ };
+- void set_type(apol_policy_t *p, char *name) {
++ void wrap_set_type(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_type_query_set_type(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -686,14 +711,16 @@
+ fail:
+ return;
+ };
+- void set_regex(apol_policy_t *p, int regex) {
++ void wrap_set_regex(apol_policy_t *p, int regex) {
+ apol_type_query_set_regex(p, self, regex);
+ };
+ };
+
+ /* apol attribute query */
+ typedef struct apol_attr_query {} apol_attr_query_t;
+-%extend apol_attr_query_t {
++%rename(apol_attr_query_set_attr) apol_attr_query_wrap_set_attr;
++%rename(apol_attr_query_set_regex) apol_attr_query_wrap_set_regex;
++%extend apol_attr_query {
+ apol_attr_query() {
+ apol_attr_query_t *aq;
+ BEGIN_EXCEPTION
+@@ -719,7 +746,7 @@
+ fail:
+ return v;
+ };
+- void set_attr(apol_policy_t *p, char *name) {
++ void wrap_set_attr(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_attr_query_set_attr(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -728,14 +755,17 @@
+ fail:
+ return;
+ };
+- void set_regex(apol_policy_t *p, int regex) {
++ void wrap_set_regex(apol_policy_t *p, int regex) {
+ apol_attr_query_set_regex(p, self, regex);
+ };
+ };
+
+ /* apol role query */
+ typedef struct apol_role_query {} apol_role_query_t;
+-%extend apol_role_query_t {
++%rename(apol_role_query_set_role) apol_role_query_wrap_set_role;
++%rename(apol_role_query_set_type) apol_role_query_wrap_set_type;
++%rename(apol_role_query_set_regex) apol_role_query_wrap_set_regex;
++%extend apol_role_query {
+ apol_role_query() {
+ apol_role_query_t *rq;
+ BEGIN_EXCEPTION
+@@ -761,7 +791,7 @@
+ fail:
+ return v;
+ };
+- void set_role(apol_policy_t *p, char *name) {
++ void wrap_set_role(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_role_query_set_role(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -770,7 +800,7 @@
+ fail:
+ return;
+ };
+- void set_type(apol_policy_t *p, char *name) {
++ void wrap_set_type(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_role_query_set_type(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -779,7 +809,7 @@
+ fail:
+ return;
+ };
+- void set_regex(apol_policy_t *p, int regex) {
++ void wrap_set_regex(apol_policy_t *p, int regex) {
+ apol_role_query_set_regex(p, self, regex);
+ };
+ };
+@@ -787,7 +817,10 @@
+
+ /* apol class query */
+ typedef struct apol_class_query {} apol_class_query_t;
+-%extend apol_class_query_t {
++%rename(apol_class_query_set_class) apol_class_query_wrap_set_class;
++%rename(apol_class_query_set_common) apol_class_query_wrap_set_common;
++%rename(apol_class_query_set_regex) apol_class_query_wrap_set_regex;
++%extend apol_class_query {
+ apol_class_query() {
+ apol_class_query_t *cq;
+ BEGIN_EXCEPTION
+@@ -813,7 +846,7 @@
+ fail:
+ return v;
+ };
+- void set_class(apol_policy_t *p, char *name) {
++ void wrap_set_class(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_class_query_set_class(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -822,7 +855,7 @@
+ fail:
+ return;
+ };
+- void set_common(apol_policy_t *p, char *name) {
++ void wrap_set_common(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_class_query_set_common(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -831,14 +864,16 @@
+ fail:
+ return;
+ };
+- void set_regex(apol_policy_t *p, int regex) {
++ void wrap_set_regex(apol_policy_t *p, int regex) {
+ apol_class_query_set_regex(p, self, regex);
+ };
+ };
+
+ /* apol common query */
+ typedef struct apol_common_query {} apol_common_query_t;
+-%extend apol_common_query_t {
++%rename(apol_common_query_set_common) apol_common_query_wrap_set_common;
++%rename(apol_common_query_set_regex) apol_common_query_wrap_set_regex;
++%extend apol_common_query {
+ apol_common_query() {
+ apol_common_query_t *cq;
+ BEGIN_EXCEPTION
+@@ -864,7 +899,7 @@
+ fail:
+ return v;
+ };
+- void set_common(apol_policy_t *p, char *name) {
++ void wrap_set_common(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_common_query_set_common(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -873,14 +908,16 @@
+ fail:
+ return;
+ };
+- void set_regex(apol_policy_t *p, int regex) {
++ void wrap_set_regex(apol_policy_t *p, int regex) {
+ apol_common_query_set_regex(p, self, regex);
+ };
+ };
+
+ /* apol perm query */
+ typedef struct apol_perm_query {} apol_perm_query_t;
+-%extend apol_perm_query_t {
++%rename(apol_perm_query_set_perm) apol_perm_query_wrap_set_perm;
++%rename(apol_perm_query_set_regex) apol_perm_query_wrap_set_regex;
++%extend apol_perm_query {
+ apol_perm_query() {
+ apol_perm_query_t *pq;
+ BEGIN_EXCEPTION
+@@ -906,7 +943,7 @@
+ fail:
+ return (apol_string_vector_t*)v;
+ };
+- void set_perm(apol_policy_t *p, char *name) {
++ void wrap_set_perm(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_perm_query_set_perm(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -915,14 +952,16 @@
+ fail:
+ return;
+ };
+- void set_regex(apol_policy_t *p, int regex) {
++ void wrap_set_regex(apol_policy_t *p, int regex) {
+ apol_perm_query_set_regex(p, self, regex);
+ };
+ };
+
+ /* apol bool query */
+ typedef struct apol_bool_query {} apol_bool_query_t;
+-%extend apol_bool_query_t {
++%rename(apol_bool_query_set_bool) apol_bool_query_wrap_set_bool;
++%rename(apol_bool_query_set_regex) apol_bool_query_wrap_set_regex;
++%extend apol_bool_query {
+ apol_bool_query() {
+ apol_bool_query_t *bq;
+ BEGIN_EXCEPTION
+@@ -948,7 +987,7 @@
+ fail:
+ return v;
+ };
+- void set_bool(apol_policy_t *p, char *name) {
++ void wrap_set_bool(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_bool_query_set_bool(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -957,14 +996,22 @@
+ fail:
+ return;
+ };
+- void set_regex(apol_policy_t *p, int regex) {
++ void wrap_set_regex(apol_policy_t *p, int regex) {
+ apol_bool_query_set_regex(p, self, regex);
+ };
+ };
+
+ /* apol mls level */
+ typedef struct apol_mls_level {} apol_mls_level_t;
+-%extend apol_mls_level_t {
++%rename(apol_mls_level_set_sens) apol_mls_level_wrap_set_sens;
++%rename(apol_mls_level_get_sens) apol_mls_level_wrap_get_sens;
++%rename(apol_mls_level_append_cats) apol_mls_level_wrap_append_cats;
++%rename(apol_mls_level_get_cats) apol_mls_level_wrap_get_cats;
++%rename(apol_mls_level_validate) apol_mls_level_wrap_validate;
++%rename(apol_mls_level_render) apol_mls_level_wrap_render;
++%rename(apol_mls_level_convert) apol_mls_level_wrap_convert;
++%rename(apol_mls_level_is_literal) apol_mls_level_wrap_is_literal;
++%extend apol_mls_level {
+ apol_mls_level() {
+ apol_mls_level_t *aml;
+ BEGIN_EXCEPTION
+@@ -1034,7 +1081,7 @@
+ ~apol_mls_level() {
+ apol_mls_level_destroy(&self);
+ };
+- void set_sens(apol_policy_t *p, char *sens) {
++ void wrap_set_sens(apol_policy_t *p, char *sens) {
+ BEGIN_EXCEPTION
+ if (apol_mls_level_set_sens(p, self, sens)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set level sensitivity");
+@@ -1043,10 +1090,10 @@
+ fail:
+ return;
+ };
+- const char *get_sens() {
++ const char *wrap_get_sens() {
+ return apol_mls_level_get_sens(self);
+ };
+- void append_cats(apol_policy_t *p, char *cats) {
++ void wrap_append_cats(apol_policy_t *p, char *cats) {
+ BEGIN_EXCEPTION
+ if (apol_mls_level_append_cats(p, self, cats)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not append level category");
+@@ -1055,10 +1102,10 @@
+ fail:
+ return;
+ };
+- const apol_string_vector_t *get_cats() {
++ const apol_string_vector_t *wrap_get_cats() {
+ return (apol_string_vector_t *) apol_mls_level_get_cats(self);
+ };
+- int validate(apol_policy_t *p) {
++ int wrap_validate(apol_policy_t *p) {
+ int ret = -1;
+ BEGIN_EXCEPTION
+ ret = apol_mls_level_validate(p, self);
+@@ -1070,7 +1117,7 @@
+ return ret;
+ }
+ %newobject render(apol_policy_t*);
+- char *render(apol_policy_t *p) {
++ char *wrap_render(apol_policy_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = apol_mls_level_render(p, self);
+@@ -1081,7 +1128,7 @@
+ fail:
+ return str;
+ };
+- int convert(apol_policy_t *p) {
++ int wrap_convert(apol_policy_t *p) {
+ int ret = -1;
+ BEGIN_EXCEPTION
+ ret = apol_mls_level_convert(p, self);
+@@ -1092,7 +1139,7 @@
+ fail:
+ return ret;
+ }
+- int is_literal() {
++ int wrap_is_literal() {
+ int ret = -1;
+ BEGIN_EXCEPTION
+ ret = apol_mls_level_is_literal(self);
+@@ -1127,7 +1174,16 @@
+ }
+ #endif
+ typedef struct apol_mls_range {} apol_mls_range_t;
+-%extend apol_mls_range_t {
++%rename(apol_mls_range_set_low) apol_mls_range_wrap_set_low;
++%rename(apol_mls_range_set_high) apol_mls_range_wrap_set_high;
++%rename(apol_mls_range_get_low) apol_mls_range_wrap_get_low;
++%rename(apol_mls_range_get_high) apol_mls_range_wrap_get_high;
++%rename(apol_mls_range_render) apol_mls_range_wrap_render;
++%rename(apol_mls_range_get_levels) apol_mls_range_wrap_get_levels;
++%rename(apol_mls_range_validate) apol_mls_range_wrap_validate;
++%rename(apol_mls_range_is_literal) apol_mls_range_wrap_is_literal;
++%rename(apol_mls_range_convert) apol_mls_range_wrap_convert;
++%extend apol_mls_range {
+ apol_mls_range() {
+ apol_mls_range_t *amr;
+ BEGIN_EXCEPTION
+@@ -1186,7 +1242,7 @@
+ ~apol_mls_range() {
+ apol_mls_range_destroy(&self);
+ };
+- void set_low(apol_policy_t *p, apol_mls_level_t *lvl) {
++ void wrap_set_low(apol_policy_t *p, apol_mls_level_t *lvl) {
+ BEGIN_EXCEPTION
+ if (apol_mls_range_set_low(p, self, lvl)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set low level");
+@@ -1195,7 +1251,7 @@
+ fail:
+ return;
+ };
+- void set_high(apol_policy_t *p, apol_mls_level_t *lvl) {
++ void wrap_set_high(apol_policy_t *p, apol_mls_level_t *lvl) {
+ BEGIN_EXCEPTION
+ if (apol_mls_range_set_high(p, self, lvl)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set high level");
+@@ -1204,14 +1260,14 @@
+ fail:
+ return;
+ };
+- const apol_mls_level_t *get_low() {
++ const apol_mls_level_t *wrap_get_low() {
+ return apol_mls_range_get_low(self);
+ }
+- const apol_mls_level_t *get_high() {
++ const apol_mls_level_t *wrap_get_high() {
+ return apol_mls_range_get_high(self);
+ }
+ %newobject render(apol_policy_t*);
+- char *render(apol_policy_t *p) {
++ char *wrap_render(apol_policy_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = apol_mls_range_render(p, self);
+@@ -1223,7 +1279,7 @@
+ return str;
+ };
+ %newobject get_levels(apol_policy_t*);
+- apol_vector_t *get_levels(apol_policy_t *p) {
++ apol_vector_t *wrap_get_levels(apol_policy_t *p) {
+ apol_vector_t *v;
+ BEGIN_EXCEPTION
+ v = apol_mls_range_get_levels(p, self);
+@@ -1234,7 +1290,7 @@
+ fail:
+ return v;
+ };
+- int validate(apol_policy_t *p) {
++ int wrap_validate(apol_policy_t *p) {
+ int ret = apol_mls_range_validate(p, self);
+ BEGIN_EXCEPTION
+ if (ret < 0) {
+@@ -1244,7 +1300,7 @@
+ fail:
+ return ret;
+ }
+- int is_literal() {
++ int wrap_is_literal() {
+ int ret = -1;
+ BEGIN_EXCEPTION
+ ret = apol_mls_range_is_literal(self);
+@@ -1255,7 +1311,7 @@
+ fail:
+ return ret;
+ }
+- int convert(apol_policy_t *p) {
++ int wrap_convert(apol_policy_t *p) {
+ int ret = -1;
+ BEGIN_EXCEPTION
+ ret = apol_mls_range_convert(p, self);
+@@ -1277,7 +1333,10 @@
+
+ /* apol level query */
+ typedef struct apol_level_query {} apol_level_query_t;
+-%extend apol_level_query_t {
++%rename(apol_level_query_set_sens) apol_level_query_wrap_set_sens;
++%rename(apol_level_query_set_cat) apol_level_query_wrap_set_cat;
++%rename(apol_level_query_set_regex) apol_level_query_wrap_set_regex;
++%extend apol_level_query {
+ apol_level_query() {
+ apol_level_query_t * alq;
+ BEGIN_EXCEPTION
+@@ -1303,7 +1362,7 @@
+ fail:
+ return v;
+ };
+- void set_sens(apol_policy_t *p, char *name) {
++ void wrap_set_sens(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_level_query_set_sens(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -1312,7 +1371,7 @@
+ fail:
+ return;
+ };
+- void set_cat(apol_policy_t *p, char *name) {
++ void wrap_set_cat(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_level_query_set_cat(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -1321,14 +1380,16 @@
+ fail:
+ return;
+ };
+- void set_regex(apol_policy_t *p, int regex) {
++ void wrap_set_regex(apol_policy_t *p, int regex) {
+ apol_level_query_set_regex(p, self, regex);
+ };
+ };
+
+ /* apol cat query */
+ typedef struct apol_cat_query {} apol_cat_query_t;
+-%extend apol_cat_query_t {
++%rename(apol_cat_query_set_cat) apol_cat_query_wrap_set_cat;
++%rename(apol_cat_query_set_regex) apol_cat_query_wrap_set_regex;
++%extend apol_cat_query {
+ apol_cat_query() {
+ apol_cat_query_t * acq;
+ BEGIN_EXCEPTION
+@@ -1354,7 +1415,7 @@
+ fail:
+ return v;
+ };
+- void set_cat(apol_policy_t *p, char *name) {
++ void wrap_set_cat(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_cat_query_set_cat(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -1363,7 +1424,7 @@
+ fail:
+ return;
+ };
+- void set_regex(apol_policy_t *p, int regex) {
++ void wrap_set_regex(apol_policy_t *p, int regex) {
+ apol_cat_query_set_regex(p, self, regex);
+ };
+ };
+@@ -1378,7 +1439,12 @@
+ }
+ #endif
+ typedef struct apol_user_query {} apol_user_query_t;
+-%extend apol_user_query_t {
++%rename(apol_user_query_set_user) apol_user_query_wrap_set_user;
++%rename(apol_user_query_set_role) apol_user_query_wrap_set_role;
++%rename(apol_user_query_set_default_level) apol_user_query_wrap_set_default_level;
++%rename(apol_user_query_set_range) apol_user_query_wrap_set_range;
++%rename(apol_user_query_set_regex) apol_user_query_wrap_set_regex;
++%extend apol_user_query {
+ apol_user_query() {
+ apol_user_query_t *auq;
+ BEGIN_EXCEPTION
+@@ -1404,7 +1470,7 @@
+ fail:
+ return v;
+ };
+- void set_user(apol_policy_t *p, char *name) {
++ void wrap_set_user(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_user_query_set_user(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -1413,7 +1479,7 @@
+ fail:
+ return;
+ };
+- void set_role(apol_policy_t *p, char *name) {
++ void wrap_set_role(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_user_query_set_role(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -1422,7 +1488,7 @@
+ fail:
+ return;
+ };
+- void set_default_level(apol_policy_t *p, apol_mls_level_t *lvl) {
++ void wrap_set_default_level(apol_policy_t *p, apol_mls_level_t *lvl) {
+ BEGIN_EXCEPTION
+ if (apol_user_query_set_default_level(p, self, lvl)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -1431,7 +1497,7 @@
+ fail:
+ return;
+ };
+- void set_range(apol_policy_t *p, apol_mls_range_t *rng, int range_match) {
++ void wrap_set_range(apol_policy_t *p, apol_mls_range_t *rng, int range_match) {
+ BEGIN_EXCEPTION
+ if (apol_user_query_set_range(p, self, rng, range_match)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -1440,14 +1506,26 @@
+ fail:
+ return;
+ };
+- void set_regex(apol_policy_t *p, int regex) {
++ void wrap_set_regex(apol_policy_t *p, int regex) {
+ apol_user_query_set_regex(p, self, regex);
+ };
+ };
+
+ /* apol context */
+ typedef struct apol_context {} apol_context_t;
+-%extend apol_context_t {
++%rename(apol_context_set_user) apol_context_wrap_set_user;
++%rename(apol_context_get_user) apol_context_wrap_get_user;
++%rename(apol_context_set_role) apol_context_wrap_set_role;
++%rename(apol_context_get_role) apol_context_wrap_get_role;
++%rename(apol_context_set_type) apol_context_wrap_set_type;
++%rename(apol_context_get_type) apol_context_wrap_get_type;
++%rename(apol_context_set_range) apol_context_wrap_set_range;
++%rename(apol_context_get_range) apol_context_wrap_get_range;
++%rename(apol_context_validate) apol_context_wrap_validate;
++%rename(apol_context_validate_partial) apol_context_wrap_validate_partial;
++%rename(apol_context_render) apol_context_wrap_render;
++%rename(apol_context_convert) apol_context_wrap_convert;
++%extend apol_context {
+ apol_context() {
+ apol_context_t *ctx;
+ BEGIN_EXCEPTION
+@@ -1484,7 +1562,7 @@
+ ~apol_context() {
+ apol_context_destroy(&self);
+ };
+- void set_user(apol_policy_t *p, char *name) {
++ void wrap_set_user(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_context_set_user(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -1493,10 +1571,10 @@
+ fail:
+ return;
+ };
+- const char *get_user() {
++ const char *wrap_get_user() {
+ return apol_context_get_user(self);
+ };
+- void set_role(apol_policy_t *p, char *name) {
++ void wrap_set_role(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_context_set_role(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -1505,10 +1583,10 @@
+ fail:
+ return;
+ };
+- const char *get_role() {
++ const char *wrap_get_role() {
+ return apol_context_get_role(self);
+ };
+- void set_type(apol_policy_t *p, char *name) {
++ void wrap_set_type(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_context_set_type(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -1517,10 +1595,10 @@
+ fail:
+ return;
+ };
+- const char *get_type() {
++ const char *wrap_get_type() {
+ return apol_context_get_type(self);
+ };
+- void set_range(apol_policy_t *p, apol_mls_range_t *rng) {
++ void wrap_set_range(apol_policy_t *p, apol_mls_range_t *rng) {
+ BEGIN_EXCEPTION
+ if (apol_context_set_range(p, self, rng)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -1529,10 +1607,10 @@
+ fail:
+ return;
+ };
+- const apol_mls_range_t *get_range() {
++ const apol_mls_range_t *wrap_get_range() {
+ return apol_context_get_range(self);
+ };
+- int validate(apol_policy_t *p) {
++ int wrap_validate(apol_policy_t *p) {
+ int ret = -1;
+ BEGIN_EXCEPTION
+ ret = apol_context_validate(p, self);
+@@ -1543,7 +1621,7 @@
+ fail:
+ return ret;
+ }
+- int validate_partial(apol_policy_t *p) {
++ int wrap_validate_partial(apol_policy_t *p) {
+ int ret = -1;
+ BEGIN_EXCEPTION
+ ret = apol_context_validate_partial(p, self);
+@@ -1555,7 +1633,7 @@
+ return ret;
+ }
+ %newobject render(apol_policy_t*);
+- char *render(apol_policy_t *p) {
++ char *wrap_render(apol_policy_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = apol_context_render(p, self);
+@@ -1566,7 +1644,7 @@
+ fail:
+ return str;
+ };
+- int convert(apol_policy_t *p) {
++ int wrap_convert(apol_policy_t *p) {
+ int ret = -1;
+ BEGIN_EXCEPTION
+ ret = apol_context_convert(p, self);
+@@ -1582,7 +1660,10 @@
+
+ /* apol constraint query */
+ typedef struct apol_constraint_query {} apol_constraint_query_t;
+-%extend apol_constraint_query_t {
++%rename(apol_constraint_query_set_class) apol_constraint_query_wrap_set_class;
++%rename(apol_constraint_query_set_perm) apol_constraint_query_wrap_set_perm;
++%rename(apol_constraint_query_set_regex) apol_constraint_query_wrap_set_regex;
++%extend apol_constraint_query {
+ apol_constraint_query() {
+ apol_constraint_query_t *acq;
+ BEGIN_EXCEPTION
+@@ -1608,7 +1689,7 @@
+ fail:
+ return v;
+ };
+- void set_class(apol_policy_t *p, char *name) {
++ void wrap_set_class(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_constraint_query_set_class(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -1617,7 +1698,7 @@
+ fail:
+ return;
+ }
+- void set_perm(apol_policy_t *p, char *name) {
++ void wrap_set_perm(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_constraint_query_set_perm(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -1626,14 +1707,16 @@
+ fail:
+ return;
+ }
+- void set_regex(apol_policy_t *p, int regex) {
++ void wrap_set_regex(apol_policy_t *p, int regex) {
+ apol_constraint_query_set_regex(p, self, regex);
+ };
+ };
+
+ /* apol validatetrans query */
+ typedef struct apol_validatetrans_query {} apol_validatetrans_query_t;
+-%extend apol_validatetrans_query_t {
++%rename(apol_validatetrans_query_set_class) apol_validatetrans_query_wrap_set_class;
++%rename(apol_validatetrans_query_set_regex) apol_validatetrans_query_wrap_set_regex;
++%extend apol_validatetrans_query {
+ apol_validatetrans_query() {
+ apol_validatetrans_query_t *avq;
+ BEGIN_EXCEPTION
+@@ -1659,7 +1742,7 @@
+ fail:
+ return v;
+ };
+- void set_class(apol_policy_t *p, char *name) {
++ void wrap_set_class(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_validatetrans_query_set_class(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -1668,7 +1751,7 @@
+ fail:
+ return;
+ }
+- void set_regex(apol_policy_t *p, int regex) {
++ void wrap_set_regex(apol_policy_t *p, int regex) {
+ apol_validatetrans_query_set_regex(p, self, regex);
+ };
+ };
+@@ -1683,7 +1766,11 @@
+ }
+ #endif
+ typedef struct apol_genfscon_query {} apol_genfscon_query_t;
+-%extend apol_genfscon_query_t {
++%rename(apol_genfscon_query_set_filesystem) apol_genfscon_query_wrap_set_filesystem;
++%rename(apol_genfscon_query_set_path) apol_genfscon_query_wrap_set_path;
++%rename(apol_genfscon_query_set_objclass) apol_genfscon_query_wrap_set_objclass;
++%rename(apol_genfscon_query_set_context) apol_genfscon_query_wrap_set_context;
++%extend apol_genfscon_query {
+ apol_genfscon_query() {
+ apol_genfscon_query_t *agq;
+ BEGIN_EXCEPTION
+@@ -1709,7 +1796,7 @@
+ fail:
+ return v;
+ };
+- void set_filesystem(apol_policy_t *p, char *fs) {
++ void wrap_set_filesystem(apol_policy_t *p, char *fs) {
+ BEGIN_EXCEPTION
+ if (apol_genfscon_query_set_filesystem(p, self, fs)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -1718,7 +1805,7 @@
+ fail:
+ return;
+ };
+- void set_path(apol_policy_t *p, char *path) {
++ void wrap_set_path(apol_policy_t *p, char *path) {
+ BEGIN_EXCEPTION
+ if (apol_genfscon_query_set_path(p, self, path)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -1727,7 +1814,7 @@
+ fail:
+ return;
+ };
+- void set_objclass(apol_policy_t *p, int objclass) {
++ void wrap_set_objclass(apol_policy_t *p, int objclass) {
+ BEGIN_EXCEPTION
+ if (apol_genfscon_query_set_objclass(p, self, objclass)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set object class for genfscon query");
+@@ -1736,7 +1823,7 @@
+ fail:
+ return;
+ };
+- void set_context(apol_policy_t *p, apol_context_t *ctx, int range_match) {
++ void wrap_set_context(apol_policy_t *p, apol_context_t *ctx, int range_match) {
+ apol_genfscon_query_set_context(p, self, ctx, range_match);
+ };
+ };
+@@ -1745,7 +1832,10 @@
+
+ /* apol fs_use query */
+ typedef struct apol_fs_use_query {} apol_fs_use_query_t;
+-%extend apol_fs_use_query_t {
++%rename(apol_fs_use_query_set_filesystem) apol_fs_use_query_wrap_set_filesystem;
++%rename(apol_fs_use_query_set_behavior) apol_fs_use_query_wrap_set_behavior;
++%rename(apol_fs_use_query_set_context) apol_fs_use_query_wrap_set_context;
++%extend apol_fs_use_query {
+ apol_fs_use_query() {
+ apol_fs_use_query_t *afq;
+ BEGIN_EXCEPTION
+@@ -1771,7 +1861,7 @@
+ fail:
+ return v;
+ };
+- void set_filesystem(apol_policy_t *p, char *fs) {
++ void wrap_set_filesystem(apol_policy_t *p, char *fs) {
+ BEGIN_EXCEPTION
+ if (apol_fs_use_query_set_filesystem(p, self, fs)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -1780,7 +1870,7 @@
+ fail:
+ return;
+ };
+- void set_behavior(apol_policy_t *p, int behavior) {
++ void wrap_set_behavior(apol_policy_t *p, int behavior) {
+ BEGIN_EXCEPTION
+ if (apol_fs_use_query_set_behavior(p, self, behavior)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set behavior for fs_use query");
+@@ -1789,7 +1879,7 @@
+ fail:
+ return;
+ };
+- void set_context(apol_policy_t *p, apol_context_t *ctx, int range_match) {
++ void wrap_set_context(apol_policy_t *p, apol_context_t *ctx, int range_match) {
+ apol_fs_use_query_set_context(p, self, ctx, range_match);
+ };
+ };
+@@ -1798,7 +1888,9 @@
+
+ /* apol initial sid query */
+ typedef struct apol_isid_query {} apol_isid_query_t;
+-%extend apol_isid_query_t {
++%rename(apol_isid_query_set_name) apol_isid_query_wrap_set_name;
++%rename(apol_isid_query_set_context) apol_isid_query_wrap_set_context;
++%extend apol_isid_query {
+ apol_isid_query() {
+ apol_isid_query_t *aiq;
+ BEGIN_EXCEPTION
+@@ -1824,7 +1916,7 @@
+ fail:
+ return v;
+ };
+- void set_name(apol_policy_t *p, char *name) {
++ void wrap_set_name(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_isid_query_set_name(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -1833,14 +1925,18 @@
+ fail:
+ return;
+ };
+- void set_context(apol_policy_t *p, apol_context_t *ctx, int range_match) {
++ void wrap_set_context(apol_policy_t *p, apol_context_t *ctx, int range_match) {
+ apol_isid_query_set_context(p, self, ctx, range_match);
+ };
+ };
+
+ /* apol portcon query */
+ typedef struct apol_portcon_query {} apol_portcon_query_t;
+-%extend apol_portcon_query_t {
++%rename(apol_portcon_query_set_protocol) apol_portcon_query_wrap_set_protocol;
++%rename(apol_portcon_query_set_low) apol_portcon_query_wrap_set_low;
++%rename(apol_portcon_query_set_high) apol_portcon_query_wrap_set_high;
++%rename(apol_portcon_query_set_context) apol_portcon_query_wrap_set_context;
++%extend apol_portcon_query {
+ apol_portcon_query() {
+ apol_portcon_query_t *apq;
+ BEGIN_EXCEPTION
+@@ -1866,16 +1962,16 @@
+ fail:
+ return v;
+ };
+- void set_protocol(apol_policy_t *p, int protocol) {
++ void wrap_set_protocol(apol_policy_t *p, int protocol) {
+ apol_portcon_query_set_protocol(p, self, protocol);
+ };
+- void set_low(apol_policy_t *p, int port) {
++ void wrap_set_low(apol_policy_t *p, int port) {
+ apol_portcon_query_set_low(p, self, port);
+ };
+- void set_high(apol_policy_t *p, int port) {
++ void wrap_set_high(apol_policy_t *p, int port) {
+ apol_portcon_query_set_high(p, self, port);
+ };
+- void set_context(apol_policy_t *p, apol_context_t *ctx, int range_match) {
++ void wrap_set_context(apol_policy_t *p, apol_context_t *ctx, int range_match) {
+ apol_portcon_query_set_context(p, self, ctx, range_match);
+ };
+ };
+@@ -1884,7 +1980,10 @@
+
+ /* apol netifcon query */
+ typedef struct apol_netifcon_query {} apol_netifcon_query_t;
+-%extend apol_netifcon_query_t {
++%rename(apol_netifcon_query_set_device) apol_netifcon_query_wrap_set_device;
++%rename(apol_netifcon_query_set_if_context) apol_netifcon_query_wrap_set_if_context;
++%rename(apol_netifcon_query_set_msg_context) apol_netifcon_query_set_msg_context;
++%extend apol_netifcon_query {
+ apol_netifcon_query() {
+ apol_netifcon_query_t *anq;
+ BEGIN_EXCEPTION
+@@ -1910,7 +2009,7 @@
+ fail:
+ return v;
+ };
+- void set_device(apol_policy_t *p, char *name) {
++ void wrap_set_device(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_netifcon_query_set_device(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -1919,10 +2018,10 @@
+ fail:
+ return;
+ };
+- void set_if_context(apol_policy_t *p, apol_context_t *ctx, int range_match) {
++ void wrap_set_if_context(apol_policy_t *p, apol_context_t *ctx, int range_match) {
+ apol_netifcon_query_set_if_context(p, self, ctx, range_match);
+ };
+- void set_msg_context(apol_policy_t *p, apol_context_t *ctx, int range_match) {
++ void wrap_set_msg_context(apol_policy_t *p, apol_context_t *ctx, int range_match) {
+ apol_netifcon_query_set_msg_context(p, self, ctx, range_match);
+ };
+ };
+@@ -1931,7 +2030,11 @@
+
+ /* apol nodecon query */
+ typedef struct apol_nodecon_query {} apol_nodecon_query_t;
+-%extend apol_nodecon_query_t {
++%rename(apol_nodecon_query_set_protocol) apol_nodecon_query_wrap_set_protocol;
++%rename(apol_nodecon_query_set_addr) apol_nodecon_query_wrap_set_addr;
++%rename(apol_nodecon_query_set_mask) apol_nodecon_query_wrap_set_mask;
++%rename(apol_nodecon_query_set_context) apol_nodecon_query_wrap_set_context;
++%extend apol_nodecon_query {
+ apol_nodecon_query() {
+ apol_nodecon_query_t *anq;
+ BEGIN_EXCEPTION
+@@ -1957,7 +2060,7 @@
+ fail:
+ return v;
+ };
+- void set_protocol(apol_policy_t *p, int protocol) {
++ void wrap_set_protocol(apol_policy_t *p, int protocol) {
+ BEGIN_EXCEPTION
+ if (apol_nodecon_query_set_protocol(p, self, protocol)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set protocol for nodecon query");
+@@ -1966,7 +2069,7 @@
+ fail:
+ return;
+ };
+- void set_addr(apol_policy_t *p, uint32_t *addr, int protocol) {
++ void wrap_set_addr(apol_policy_t *p, uint32_t *addr, int protocol) {
+ BEGIN_EXCEPTION
+ if (apol_nodecon_query_set_addr(p, self, addr, protocol)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set address for nodecon query");
+@@ -1975,7 +2078,7 @@
+ fail:
+ return;
+ };
+- void set_addr(apol_policy_t *p, apol_ip_t *addr) {
++ void wrap_set_addr(apol_policy_t *p, apol_ip_t *addr) {
+ BEGIN_EXCEPTION
+ if (apol_nodecon_query_set_addr(p, self, addr->ip, addr->proto)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set address for nodecon query");
+@@ -1984,7 +2087,7 @@
+ fail:
+ return;
+ };
+- void set_mask(apol_policy_t *p, uint32_t *mask, int protocol) {
++ void wrap_set_mask(apol_policy_t *p, uint32_t *mask, int protocol) {
+ BEGIN_EXCEPTION
+ if (apol_nodecon_query_set_mask(p, self, mask, protocol)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set mask for nodecon query");
+@@ -1993,7 +2096,7 @@
+ fail:
+ return;
+ };
+- void set_mask(apol_policy_t *p, apol_ip_t *mask) {
++ void wrap_set_mask(apol_policy_t *p, apol_ip_t *mask) {
+ BEGIN_EXCEPTION
+ if (apol_nodecon_query_set_mask(p, self, mask->ip, mask->proto)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set mask for nodecon query");
+@@ -2002,7 +2105,7 @@
+ fail:
+ return;
+ };
+- void set_context(apol_policy_t *p, apol_context_t *ctx, int range_match) {
++ void wrap_set_context(apol_policy_t *p, apol_context_t *ctx, int range_match) {
+ apol_nodecon_query_set_context(p, self, ctx, range_match);
+ };
+ };
+@@ -2011,7 +2114,19 @@
+
+ /* apol avrule query */
+ typedef struct apol_avrule_query {} apol_avrule_query_t;
+-%extend apol_avrule_query_t {
++%rename(apol_avrule_query_set_rules) apol_avrule_query_wrap_set_rules;
++%rename(apol_avrule_query_set_source) apol_avrule_query_wrap_set_source;
++%rename(apol_avrule_query_set_source_component) apol_avrule_query_wrap_set_source_component;
++%rename(apol_avrule_query_set_target) apol_avrule_query_wrap_set_target;
++%rename(apol_avrule_query_set_target_component) apol_avrule_query_wrap_set_target_component;
++%rename(apol_avrule_query_append_class) apol_avrule_query_wrap_append_class;
++%rename(apol_avrule_query_append_perm) apol_avrule_query_wrap_append_perm;
++%rename(apol_avrule_query_set_bool) apol_avrule_query_wrap_set_bool;
++%rename(apol_avrule_query_set_enabled) apol_avrule_query_wrap_set_enabled;
++%rename(apol_avrule_query_set_all_perms) apol_avrule_query_wrap_set_all_perms;
++%rename(apol_avrule_query_set_source_any) apol_avrule_query_wrap_set_source_any;
++%rename(apol_avrule_query_set_regex) apol_avrule_query_wrap_set_regex;
++%extend apol_avrule_query {
+ apol_avrule_query() {
+ apol_avrule_query_t *avq;
+ BEGIN_EXCEPTION
+@@ -2048,10 +2163,10 @@
+ fail:
+ return v;
+ };
+- void set_rules(apol_policy_t *p, int rules) {
++ void wrap_set_rules(apol_policy_t *p, int rules) {
+ apol_avrule_query_set_rules(p, self, rules);
+ };
+- void set_source(apol_policy_t *p, char *name, int indirect) {
++ void wrap_set_source(apol_policy_t *p, char *name, int indirect) {
+ BEGIN_EXCEPTION
+ if (apol_avrule_query_set_source(p, self, name, indirect)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set source for avrule query");
+@@ -2060,7 +2175,7 @@
+ fail:
+ return;
+ };
+- void set_source_component(apol_policy_t *p, int component) {
++ void wrap_set_source_component(apol_policy_t *p, int component) {
+ BEGIN_EXCEPTION
+ if (apol_avrule_query_set_source_component(p, self, component)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set source component for avrule query");
+@@ -2069,7 +2184,7 @@
+ fail:
+ return;
+ };
+- void set_target(apol_policy_t *p, char *name, int indirect) {
++ void wrap_set_target(apol_policy_t *p, char *name, int indirect) {
+ BEGIN_EXCEPTION
+ if (apol_avrule_query_set_target(p, self, name, indirect)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set target for avrule query");
+@@ -2078,7 +2193,7 @@
+ fail:
+ return;
+ };
+- void set_target_component(apol_policy_t *p, int component) {
++ void wrap_set_target_component(apol_policy_t *p, int component) {
+ BEGIN_EXCEPTION
+ if (apol_avrule_query_set_target_component(p, self, component)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set target component for avrule query");
+@@ -2087,7 +2202,7 @@
+ fail:
+ return;
+ };
+- void append_class(apol_policy_t *p, char *name) {
++ void wrap_append_class(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_avrule_query_append_class(p, self, name)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not append class to avrule query");
+@@ -2096,7 +2211,7 @@
+ fail:
+ return;
+ };
+- void append_perm(apol_policy_t *p, char *name) {
++ void wrap_append_perm(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_avrule_query_append_perm(p, self, name)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not append permission to avrule query");
+@@ -2105,7 +2220,7 @@
+ fail:
+ return;
+ };
+- void set_bool(apol_policy_t *p, char *name) {
++ void wrap_set_bool(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_avrule_query_set_bool(p, self, name)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set boolean for avrule query");
+@@ -2114,16 +2229,16 @@
+ fail:
+ return;
+ };
+- void set_enabled(apol_policy_t *p, int enabled) {
++ void wrap_set_enabled(apol_policy_t *p, int enabled) {
+ apol_avrule_query_set_enabled(p, self, enabled);
+ };
+- void set_all_perms(apol_policy_t *p, int all_perms) {
++ void wrap_set_all_perms(apol_policy_t *p, int all_perms) {
+ apol_avrule_query_set_all_perms(p, self, all_perms);
+ };
+- void set_source_any(apol_policy_t *p, int is_any) {
++ void wrap_set_source_any(apol_policy_t *p, int is_any) {
+ apol_avrule_query_set_source_any(p, self, is_any);
+ };
+- void set_regex(apol_policy_t *p, int regex) {
++ void wrap_set_regex(apol_policy_t *p, int regex) {
+ apol_avrule_query_set_regex(p, self, regex);
+ };
+ };
+@@ -2162,7 +2277,18 @@
+
+ /* apol terule query */
+ typedef struct apol_terule_query {} apol_terule_query_t;
+-%extend apol_terule_query_t {
++%rename(apol_terule_query_set_rules) apol_terule_query_wrap_set_rules;
++%rename(apol_terule_query_set_source) apol_terule_query_wrap_set_source;
++%rename(apol_terule_query_set_source_component) apol_terule_query_wrap_set_source_component;
++%rename(apol_terule_query_set_target) apol_terule_query_wrap_set_target;
++%rename(apol_terule_query_set_target_component) apol_terule_query_wrap_set_target_component;
++%rename(apol_terule_query_append_class) apol_terule_query_wrap_append_class;
++%rename(apol_terule_query_set_default) apol_terule_query_wrap_set_default;
++%rename(apol_terule_query_set_bool) apol_terule_query_wrap_set_bool;
++%rename(apol_terule_query_set_enabled) apol_terule_query_wrap_set_enabled;
++%rename(apol_terule_query_set_source_any) apol_terule_query_wrap_set_source_any;
++%rename(apol_terule_query_set_regex) apol_terule_query_wrap_set_regex;
++%extend apol_terule_query {
+ apol_terule_query() {
+ apol_terule_query_t *atq;
+ BEGIN_EXCEPTION
+@@ -2199,10 +2325,10 @@
+ fail:
+ return v;
+ };
+- void set_rules(apol_policy_t *p, int rules) {
++ void wrap_set_rules(apol_policy_t *p, int rules) {
+ apol_terule_query_set_rules(p, self, rules);
+ };
+- void set_source(apol_policy_t *p, char *name, int indirect) {
++ void wrap_set_source(apol_policy_t *p, char *name, int indirect) {
+ BEGIN_EXCEPTION
+ if (apol_terule_query_set_source(p, self, name, indirect)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set source for terule query");
+@@ -2211,7 +2337,7 @@
+ fail:
+ return;
+ };
+- void set_source_component(apol_policy_t *p, int component) {
++ void wrap_set_source_component(apol_policy_t *p, int component) {
+ BEGIN_EXCEPTION
+ if (apol_terule_query_set_source_component(p, self, component)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set source component for terule query");
+@@ -2220,7 +2346,7 @@
+ fail:
+ return;
+ };
+- void set_target(apol_policy_t *p, char *name, int indirect) {
++ void wrap_set_target(apol_policy_t *p, char *name, int indirect) {
+ BEGIN_EXCEPTION
+ if (apol_terule_query_set_target(p, self, name, indirect)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set target for terule query");
+@@ -2229,7 +2355,7 @@
+ fail:
+ return;
+ };
+- void set_target_component(apol_policy_t *p, int component) {
++ void wrap_set_target_component(apol_policy_t *p, int component) {
+ BEGIN_EXCEPTION
+ if (apol_terule_query_set_target_component(p, self, component)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set target component for terule query");
+@@ -2238,7 +2364,7 @@
+ fail:
+ return;
+ };
+- void append_class(apol_policy_t *p, char *name) {
++ void wrap_append_class(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_terule_query_append_class(p, self, name)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not append class to terule query");
+@@ -2247,7 +2373,7 @@
+ fail:
+ return;
+ };
+- void set_default(apol_policy_t *p, char *name) {
++ void wrap_set_default(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_terule_query_set_default(p, self, name)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set default for terule query");
+@@ -2256,7 +2382,7 @@
+ fail:
+ return;
+ };
+- void set_bool(apol_policy_t *p, char *name) {
++ void wrap_set_bool(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_terule_query_set_bool(p, self, name)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set boolean for terule query");
+@@ -2265,13 +2391,13 @@
+ fail:
+ return;
+ };
+- void set_enabled(apol_policy_t *p, int enabled) {
++ void wrap_set_enabled(apol_policy_t *p, int enabled) {
+ apol_terule_query_set_enabled(p, self, enabled);
+ };
+- void set_source_any(apol_policy_t *p, int is_any) {
++ void wrap_set_source_any(apol_policy_t *p, int is_any) {
+ apol_terule_query_set_source_any(p, self, is_any);
+ };
+- void set_regex(apol_policy_t *p, int regex) {
++ void wrap_set_regex(apol_policy_t *p, int regex) {
+ apol_terule_query_set_regex(p, self, regex);
+ };
+ };
+@@ -2286,7 +2412,9 @@
+
+ /* apol cond rule query */
+ typedef struct apol_cond_query {} apol_cond_query_t;
+-%extend apol_cond_query_t {
++%rename(apol_cond_query_set_bool) apol_cond_query_wrap_set_bool;
++%rename(apol_cond_query_set_regex) apol_cond_query_wrap_set_regex;
++%extend apol_cond_query {
+ apol_cond_query() {
+ apol_cond_query_t *acq;
+ BEGIN_EXCEPTION
+@@ -2312,7 +2440,7 @@
+ fail:
+ return v;
+ };
+- void set_bool(apol_policy_t *p, char *name) {
++ void wrap_set_bool(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_cond_query_set_bool(p, self, name)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set boolean for condiional query");
+@@ -2321,7 +2449,7 @@
+ fail:
+ return;
+ };
+- void set_regex(apol_policy_t *p, int regex) {
++ void wrap_set_regex(apol_policy_t *p, int regex) {
+ apol_cond_query_set_regex(p, self, regex);
+ };
+ };
+@@ -2330,7 +2458,11 @@
+
+ /* apol role allow query */
+ typedef struct apol_role_allow_query {} apol_role_allow_query_t;
+-%extend apol_role_allow_query_t {
++%rename(apol_role_allow_query_set_source) apol_role_allow_query_wrap_set_source;
++%rename(apol_role_allow_query_set_target) apol_role_allow_query_wrap_set_target;
++%rename(apol_role_allow_query_set_source_any) apol_role_allow_query_wrap_set_source_any;
++%rename(apol_role_allow_query_set_regex) apol_role_allow_query_wrap_set_regex;
++%extend apol_role_allow_query {
+ apol_role_allow_query() {
+ apol_role_allow_query_t *arq;
+ BEGIN_EXCEPTION
+@@ -2356,7 +2488,7 @@
+ fail:
+ return v;
+ };
+- void set_source(apol_policy_t *p, char *name) {
++ void wrap_set_source(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_role_allow_query_set_source(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -2365,7 +2497,7 @@
+ fail:
+ return;
+ };
+- void set_target(apol_policy_t *p, char *name) {
++ void wrap_set_target(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_role_allow_query_set_target(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -2374,10 +2506,10 @@
+ fail:
+ return;
+ };
+- void set_source_any(apol_policy_t *p, int is_any) {
++ void wrap_set_source_any(apol_policy_t *p, int is_any) {
+ apol_role_allow_query_set_source_any(p, self, is_any);
+ };
+- void set_regex(apol_policy_t *p, int regex) {
++ void wrap_set_regex(apol_policy_t *p, int regex) {
+ apol_role_allow_query_set_regex(p, self, regex);
+ };
+ };
+@@ -2386,7 +2518,12 @@
+
+ /* apol role transition rule query */
+ typedef struct apol_role_trans_query {} apol_role_trans_query_t;
+-%extend apol_role_trans_query_t {
++%rename(apol_role_trans_query_set_source) apol_role_trans_query_wrap_set_source;
++%rename(apol_role_trans_query_set_target) apol_role_trans_query_wrap_set_target;
++%rename(apol_role_trans_query_set_default) apol_role_trans_query_wrap_set_default;
++%rename(apol_role_trans_query_set_source_any) apol_role_trans_query_wrap_set_source_any;
++%rename(apol_role_trans_query_set_regex) apol_role_trans_query_wrap_set_regex;
++%extend apol_role_trans_query {
+ apol_role_trans_query() {
+ apol_role_trans_query_t *arq;
+ BEGIN_EXCEPTION
+@@ -2412,7 +2549,7 @@
+ fail:
+ return v;
+ };
+- void set_source(apol_policy_t *p, char *name) {
++ void wrap_set_source(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_role_trans_query_set_source(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -2421,7 +2558,7 @@
+ fail:
+ return;
+ };
+- void set_target(apol_policy_t *p, char *name, int indirect) {
++ void wrap_set_target(apol_policy_t *p, char *name, int indirect) {
+ BEGIN_EXCEPTION
+ if (apol_role_trans_query_set_target(p, self, name, indirect)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -2430,7 +2567,7 @@
+ fail:
+ return;
+ };
+- void set_default(apol_policy_t *p, char *name) {
++ void wrap_set_default(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_role_trans_query_set_default(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -2439,10 +2576,10 @@
+ fail:
+ return;
+ };
+- void set_source_any(apol_policy_t *p, int is_any) {
++ void wrap_set_source_any(apol_policy_t *p, int is_any) {
+ apol_role_trans_query_set_source_any(p, self, is_any);
+ };
+- void set_regex(apol_policy_t *p, int regex) {
++ void wrap_set_regex(apol_policy_t *p, int regex) {
+ apol_role_trans_query_set_regex(p, self, regex);
+ };
+ };
+@@ -2451,7 +2588,13 @@
+
+ /* apol range transition rule query */
+ typedef struct apol_range_trans_query {} apol_range_trans_query_t;
+-%extend apol_range_trans_query_t {
++%rename(apol_range_trans_query_set_source) apol_range_trans_query_wrap_set_source;
++%rename(apol_range_trans_query_set_target) apol_range_trans_query_wrap_set_target;
++%rename(apol_range_trans_query_append_class) apol_range_trans_query_wrap_append_class;
++%rename(apol_range_trans_query_set_range) apol_range_trans_query_wrap_set_range;
++%rename(apol_range_trans_query_set_source_any) apol_range_trans_query_wrap_set_source_any;
++%rename(apol_range_trans_query_set_regex) apol_range_trans_query_wrap_set_regex;
++%extend apol_range_trans_query {
+ apol_range_trans_query() {
+ apol_range_trans_query_t *arq;
+ BEGIN_EXCEPTION
+@@ -2477,7 +2620,7 @@
+ fail:
+ return v;
+ };
+- void set_source(apol_policy_t *p, char *name, int indirect) {
++ void wrap_set_source(apol_policy_t *p, char *name, int indirect) {
+ BEGIN_EXCEPTION
+ if (apol_range_trans_query_set_source(p, self, name, indirect)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -2486,7 +2629,7 @@
+ fail:
+ return;
+ };
+- void set_target(apol_policy_t *p, char *name, int indirect) {
++ void wrap_set_target(apol_policy_t *p, char *name, int indirect) {
+ BEGIN_EXCEPTION
+ if (apol_range_trans_query_set_target(p, self, name, indirect)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -2495,7 +2638,7 @@
+ fail:
+ return;
+ };
+- void append_class(apol_policy_t *p, char *name) {
++ void wrap_append_class(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_range_trans_query_append_class(p, self, name)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not append class to range transition query");
+@@ -2504,7 +2647,7 @@
+ fail:
+ return;
+ };
+- void set_range(apol_policy_t *p, apol_mls_range_t *rng, int range_match) {
++ void wrap_set_range(apol_policy_t *p, apol_mls_range_t *rng, int range_match) {
+ BEGIN_EXCEPTION
+ if (apol_range_trans_query_set_range(p, self, rng, range_match)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -2513,10 +2656,10 @@
+ fail:
+ return;
+ };
+- void set_source_any(apol_policy_t *p, int is_any) {
++ void wrap_set_source_any(apol_policy_t *p, int is_any) {
+ apol_range_trans_query_set_source_any(p, self, is_any);
+ };
+- void set_regex(apol_policy_t *p, int regex) {
++ void wrap_set_regex(apol_policy_t *p, int regex) {
+ apol_range_trans_query_set_regex(p, self, regex);
+ };
+ };
+@@ -2530,7 +2673,14 @@
+ #define APOL_DOMAIN_TRANS_SEARCH_INVALID 0x02
+ #define APOL_DOMAIN_TRANS_SEARCH_BOTH (APOL_DOMAIN_TRANS_SEARCH_VALID|APOL_DOMAIN_TRANS_SEARCH_INVALID)
+ typedef struct apol_domain_trans_analysis {} apol_domain_trans_analysis_t;
+-%extend apol_domain_trans_analysis_t {
++%rename(apol_domain_trans_analysis_set_direction) apol_domain_trans_analysis_wrap_set_direction;
++%rename(apol_domain_trans_analysis_set_valid) apol_domain_trans_analysis_wrap_set_valid;
++%rename(apol_domain_trans_analysis_set_start_type) apol_domain_trans_analysis_wrap_set_start_type;
++%rename(apol_domain_trans_analysis_set_result_regex) apol_domain_trans_analysis_wrap_set_result_regex;
++%rename(apol_domain_trans_analysis_append_access_type) apol_domain_trans_analysis_wrap_append_access_type;
++%rename(apol_domain_trans_analysis_append_class) apol_domain_trans_analysis_wrap_append_class;
++%rename(apol_domain_trans_analysis_append_perm) apol_domain_trans_analysis_wrap_append_perm;
++%extend apol_domain_trans_analysis {
+ apol_domain_trans_analysis() {
+ apol_domain_trans_analysis_t *dta;
+ BEGIN_EXCEPTION
+@@ -2545,7 +2695,7 @@
+ ~apol_domain_trans_analysis() {
+ apol_domain_trans_analysis_destroy(&self);
+ };
+- void set_direction(apol_policy_t *p, int direction) {
++ void wrap_set_direction(apol_policy_t *p, int direction) {
+ BEGIN_EXCEPTION
+ if (apol_domain_trans_analysis_set_direction(p, self, (unsigned char)direction)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set direction for domain transition analysis");
+@@ -2554,7 +2704,7 @@
+ fail:
+ return;
+ };
+- void set_valid(apol_policy_t *p, int valid) {
++ void wrap_set_valid(apol_policy_t *p, int valid) {
+ BEGIN_EXCEPTION
+ if (apol_domain_trans_analysis_set_valid(p, self, (unsigned char)valid)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set valid flag for domain transition analysis");
+@@ -2563,7 +2713,7 @@
+ fail:
+ return;
+ };
+- void set_start_type(apol_policy_t *p, char *name) {
++ void wrap_set_start_type(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_domain_trans_analysis_set_start_type(p, self, name)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -2572,7 +2722,7 @@
+ fail:
+ return;
+ };
+- void set_result_regex(apol_policy_t *p, char *regex) {
++ void wrap_set_result_regex(apol_policy_t *p, char *regex) {
+ BEGIN_EXCEPTION
+ if (apol_domain_trans_analysis_set_result_regex(p, self, regex)) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+@@ -2581,7 +2731,7 @@
+ fail:
+ return;
+ };
+- void append_access_type(apol_policy_t *p, char *name) {
++ void wrap_append_access_type(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_domain_trans_analysis_append_access_type(p, self, name)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not append access type for domain transition analysis");
+@@ -2590,7 +2740,7 @@
+ fail:
+ return;
+ };
+- void append_class(apol_policy_t *p, char *class_name) {
++ void wrap_append_class(apol_policy_t *p, char *class_name) {
+ BEGIN_EXCEPTION
+ if (apol_domain_trans_analysis_append_class(p, self, class_name)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not append access class for domain transition analysis");
+@@ -2599,7 +2749,7 @@
+ fail:
+ return;
+ };
+- void append_perm(apol_policy_t *p, char *perm_name) {
++ void wrap_append_perm(apol_policy_t *p, char *perm_name) {
+ BEGIN_EXCEPTION
+ if (apol_domain_trans_analysis_append_perm(p, self, perm_name)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not append access permission for domain transition analysis");
+@@ -2621,7 +2771,16 @@
+ };
+ };
+ typedef struct apol_domain_trans_result {} apol_domain_trans_result_t;
+-%extend apol_domain_trans_result_t {
++%rename(apol_domain_trans_result_get_start_type) apol_domain_trans_result_wrap_get_start_type;
++%rename(apol_domain_trans_result_get_entrypoint_type) apol_domain_trans_result_wrap_get_entrypoint_type;
++%rename(apol_domain_trans_result_get_end_type) apol_domain_trans_result_wrap_get_end_type;
++%rename(apol_domain_trans_result_get_proc_trans_rules) apol_domain_trans_result_wrap_get_proc_trans_rules;
++%rename(apol_domain_trans_result_get_entrypoint_rules) apol_domain_trans_result_wrap_get_entrypoint_rules;
++%rename(apol_domain_trans_result_get_exec_rules) apol_domain_trans_result_wrap_get_exec_rules;
++%rename(apol_domain_trans_result_get_setexec_rules) apol_domain_trans_result_wrap_get_setexec_rules;
++%rename(apol_domain_trans_result_get_type_trans_rules) apol_domain_trans_result_wrap_get_type_trans_rules;
++%rename(apol_domain_trans_result_get_access_rules) apol_domain_trans_result_wrap_get_access_rules;
++%extend apol_domain_trans_result {
+ apol_domain_trans_result(apol_domain_trans_result_t *in) {
+ apol_domain_trans_result_t *dtr;
+ BEGIN_EXCEPTION
+@@ -2636,34 +2795,34 @@
+ ~apol_domain_trans_result() {
+ apol_domain_trans_result_destroy(&self);
+ };
+- const qpol_type_t *get_start_type() {
++ const qpol_type_t *wrap_get_start_type() {
+ return apol_domain_trans_result_get_start_type(self);
+ };
+- const qpol_type_t *get_entrypoint_type() {
++ const qpol_type_t *wrap_get_entrypoint_type() {
+ return apol_domain_trans_result_get_entrypoint_type(self);
+ };
+- const qpol_type_t *get_end_type() {
++ const qpol_type_t *wrap_get_end_type() {
+ return apol_domain_trans_result_get_end_type(self);
+ };
+- int get_is_valid() {
++ int wrap_get_is_valid() {
+ return apol_domain_trans_result_is_trans_valid(self);
+ };
+- const apol_vector_t *get_proc_trans_rules() {
++ const apol_vector_t *wrap_get_proc_trans_rules() {
+ return apol_domain_trans_result_get_proc_trans_rules(self);
+ };
+- const apol_vector_t *get_entrypoint_rules() {
++ const apol_vector_t *wrap_get_entrypoint_rules() {
+ return apol_domain_trans_result_get_entrypoint_rules(self);
+ };
+- const apol_vector_t *get_exec_rules() {
++ const apol_vector_t *wrap_get_exec_rules() {
+ return apol_domain_trans_result_get_exec_rules(self);
+ };
+- const apol_vector_t *get_setexec_rules() {
++ const apol_vector_t *wrap_get_setexec_rules() {
+ return apol_domain_trans_result_get_setexec_rules(self);
+ };
+- const apol_vector_t *get_type_trans_rules() {
++ const apol_vector_t *wrap_get_type_trans_rules() {
+ return apol_domain_trans_result_get_type_trans_rules(self);
+ };
+- const apol_vector_t *get_access_rules() {
++ const apol_vector_t *wrap_get_access_rules() {
+ return apol_domain_trans_result_get_access_rules(self);
+ };
+ };
+@@ -2704,7 +2863,7 @@
+ }
+ %}
+ typedef struct apol_infoflow {} apol_infoflow_t;
+-%extend apol_infoflow_t {
++%extend apol_infoflow {
+ apol_infoflow() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create apol_infoflow_t objects");
+@@ -2729,7 +2888,14 @@
+ };
+ };
+ typedef struct apol_infoflow_analysis {} apol_infoflow_analysis_t;
+-%extend apol_infoflow_analysis_t {
++%rename(apol_infoflow_analysis_set_mode) apol_infoflow_analysis_wrap_set_mode;
++%rename(apol_infoflow_analysis_set_dir) apol_infoflow_analysis_wrap_set_dir;
++%rename(apol_infoflow_analysis_set_type) apol_infoflow_analysis_wrap_set_type;
++%rename(apol_infoflow_analysis_append_intermediate) apol_infoflow_analysis_wrap_append_intermediate;
++%rename(apol_infoflow_analysis_append_class_perm) apol_infoflow_analysis_wrap_append_class_perm;
++%rename(apol_infoflow_analysis_set_min_weight) apol_infoflow_analysis_wrap_set_min_weight;
++%rename(apol_infoflow_analysis_set_result_regex) apol_infoflow_analysis_wrap_set_result_regex;
++%extend apol_infoflow_analysis {
+ apol_infoflow_analysis() {
+ apol_infoflow_analysis_t *aia;
+ BEGIN_EXCEPTION
+@@ -2763,7 +2929,7 @@
+ apol_infoflow_destroy(&ai);
+ return NULL;
+ };
+- void set_mode(apol_policy_t *p, int mode) {
++ void wrap_set_mode(apol_policy_t *p, int mode) {
+ BEGIN_EXCEPTION
+ if (apol_infoflow_analysis_set_mode(p, self, (unsigned int)mode)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set mode for information flow analysis");
+@@ -2772,7 +2938,7 @@
+ fail:
+ return;
+ };
+- void set_dir(apol_policy_t *p, int direction) {
++ void wrap_set_dir(apol_policy_t *p, int direction) {
+ BEGIN_EXCEPTION
+ if (apol_infoflow_analysis_set_dir(p, self, (unsigned int)direction)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set direction for information flow analysis");
+@@ -2781,7 +2947,7 @@
+ fail:
+ return;
+ };
+- void set_type(apol_policy_t *p, char *name) {
++ void wrap_set_type(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_infoflow_analysis_set_type(p, self, name)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set type for information flow analysis");
+@@ -2790,7 +2956,7 @@
+ fail:
+ return;
+ };
+- void append_intermediate(apol_policy_t *p, char *name) {
++ void wrap_append_intermediate(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_infoflow_analysis_append_intermediate(p, self, name)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not append intermediate type for information flow analysis");
+@@ -2799,7 +2965,7 @@
+ fail:
+ return;
+ };
+- void append_class_perm(apol_policy_t *p, char *class_name, char *perm_name) {
++ void wrap_append_class_perm(apol_policy_t *p, char *class_name, char *perm_name) {
+ BEGIN_EXCEPTION
+ if (apol_infoflow_analysis_append_class_perm(p, self, class_name, perm_name)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not append class and permission for information flow analysis");
+@@ -2808,10 +2974,10 @@
+ fail:
+ return;
+ };
+- void set_min_weight(apol_policy_t *p, int weight) {
++ void wrap_set_min_weight(apol_policy_t *p, int weight) {
+ apol_infoflow_analysis_set_min_weight(p, self, weight);
+ };
+- void set_result_regex(apol_policy_t *p, char *regex) {
++ void wrap_set_result_regex(apol_policy_t *p, char *regex) {
+ BEGIN_EXCEPTION
+ if (apol_infoflow_analysis_set_result_regex(p, self, regex)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set result regular expression for information flow analysis");
+@@ -2822,7 +2988,7 @@
+ };
+ };
+ typedef struct apol_infoflow_graph {} apol_infoflow_graph_t;
+-%extend apol_infoflow_graph_t {
++%extend apol_infoflow_graph {
+ apol_infoflow_graph() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create apol_infoflow_graph_t objects");
+@@ -2866,7 +3032,12 @@
+ };
+ };
+ typedef struct apol_infoflow_result {} apol_infoflow_result_t;
+-%extend apol_infoflow_result_t {
++%rename(apol_infoflow_result_get_dir) apol_infoflow_result_wrap_get_dir;
++%rename(apol_infoflow_result_get_start_type) apol_infoflow_result_wrap_get_start_type;
++%rename(apol_infoflow_result_get_end_type) apol_infoflow_result_wrap_get_end_type;
++%rename(apol_infoflow_result_get_length) apol_infoflow_result_wrap_get_length;
++%rename(apol_infoflow_result_get_steps) apol_infoflow_result_wrap_get_steps;
++%extend apol_infoflow_result {
+ apol_infoflow_result() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create apol_infoflow_result_t objects");
+@@ -2878,19 +3049,19 @@
+ /* no op - vector will destroy */
+ return;
+ };
+- int get_dir() {
++ int wrap_get_dir() {
+ return (int)apol_infoflow_result_get_dir(self);
+ };
+- const qpol_type_t *get_start_type() {
++ const qpol_type_t *wrap_get_start_type() {
+ return apol_infoflow_result_get_start_type(self);
+ };
+- const qpol_type_t *get_end_type() {
++ const qpol_type_t *wrap_get_end_type() {
+ return apol_infoflow_result_get_end_type(self);
+ };
+- int get_length() {
++ int wrap_get_length() {
+ return (int) apol_infoflow_result_get_length(self);
+ }
+- const apol_vector_t *get_steps() {
++ const apol_vector_t *wrap_get_steps() {
+ return apol_infoflow_result_get_steps(self);
+ };
+ };
+@@ -2900,7 +3071,11 @@
+ };
+ %}
+ typedef struct apol_infoflow_step {} apol_infoflow_step_t;
+-%extend apol_infoflow_step_t {
++%rename(apol_infoflow_step_get_start_type) apol_infoflow_step_wrap_get_start_type;
++%rename(apol_infoflow_step_get_end_type) apol_infoflow_step_wrap_get_end_type;
++%rename(apol_infoflow_step_get_weight) apol_infoflow_step_wrap_get_weight;
++%rename(apol_infoflow_step_get_rules) apol_infoflow_step_wrap_get_rules;
++%extend apol_infoflow_step {
+ apol_infoflow_step() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create apol_infoflow_step_t objects");
+@@ -2912,16 +3087,16 @@
+ /* no op */
+ return;
+ };
+- const qpol_type_t *get_start_type() {
++ const qpol_type_t *wrap_get_start_type() {
+ return apol_infoflow_step_get_start_type(self);
+ };
+- const qpol_type_t *get_end_type() {
++ const qpol_type_t *wrap_get_end_type() {
+ return apol_infoflow_step_get_end_type(self);
+ };
+- int get_weight() {
++ int wrap_get_weight() {
+ return apol_infoflow_step_get_weight(self);
+ };
+- const apol_vector_t *get_rules() {
++ const apol_vector_t *wrap_get_rules() {
+ return apol_infoflow_step_get_rules(self);
+ };
+ };
+@@ -2937,7 +3112,12 @@
+ #define APOL_RELABEL_DIR_BOTH (APOL_RELABEL_DIR_TO|APOL_RELABEL_DIR_FROM)
+ #define APOL_RELABEL_DIR_SUBJECT 0x04
+ typedef struct apol_relabel_analysis {} apol_relabel_analysis_t;
+-%extend apol_relabel_analysis_t {
++%rename(apol_relabel_analysis_set_dir) apol_relabel_analysis_wrap_set_dir;
++%rename(apol_relabel_analysis_set_type) apol_relabel_analysis_wrap_set_type;
++%rename(apol_relabel_analysis_append_class) apol_relabel_analysis_wrap_append_class;
++%rename(apol_relabel_analysis_append_subject) apol_relabel_analysis_wrap_append_subject;
++%rename(apol_relabel_analysis_set_result_regex) apol_relabel_analysis_wrap_set_result_regex;
++%extend apol_relabel_analysis {
+ apol_relabel_analysis() {
+ apol_relabel_analysis_t *ara;
+ BEGIN_EXCEPTION
+@@ -2963,7 +3143,7 @@
+ fail:
+ return v;
+ };
+- void set_dir(apol_policy_t *p, int direction) {
++ void wrap_set_dir(apol_policy_t *p, int direction) {
+ BEGIN_EXCEPTION
+ if (apol_relabel_analysis_set_dir(p, self, (unsigned int)direction)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set direction for relabel analysis");
+@@ -2972,7 +3152,7 @@
+ fail:
+ return;
+ };
+- void set_type(apol_policy_t *p, char *name) {
++ void wrap_set_type(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_relabel_analysis_set_type(p, self, name)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set type for relabel analysis");
+@@ -2981,7 +3161,7 @@
+ fail:
+ return;
+ };
+- void append_class(apol_policy_t *p, char *name) {
++ void wrap_append_class(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_relabel_analysis_append_class(p, self, name)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not append class to relabel analysis");
+@@ -2990,7 +3170,7 @@
+ fail:
+ return;
+ };
+- void append_subject(apol_policy_t *p, char *name) {
++ void wrap_append_subject(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_relabel_analysis_append_subject(p, self, name)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not append subject to relabel analysis");
+@@ -2999,7 +3179,7 @@
+ fail:
+ return;
+ };
+- void set_result_regex(apol_policy_t *p, char *regex) {
++ void wrap_set_result_regex(apol_policy_t *p, char *regex) {
+ BEGIN_EXCEPTION
+ if (apol_relabel_analysis_set_result_regex(p, self, regex)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set result regular expression for relabel analysis");
+@@ -3010,7 +3190,11 @@
+ };
+ };
+ typedef struct apol_relabel_result {} apol_relabel_result_t;
+-%extend apol_relabel_result_t {
++%rename(apol_relabel_result_get_to) apol_relabel_result_wrap_get_to;
++%rename(apol_relabel_result_get_from) apol_relabel_result_wrap_get_from;
++%rename(apol_relabel_result_get_both) apol_relabel_result_wrap_get_both;
++%rename(apol_relabel_result_get_result_type) apol_relabel_result_wrap_get_result_type;
++%extend apol_relabel_result {
+ apol_relabel_result() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create apol_relabel_result_t objects");
+@@ -3022,16 +3206,16 @@
+ /* no op - vector will destroy */
+ return;
+ };
+- const apol_vector_t *get_to() {
++ const apol_vector_t *wrap_get_to() {
+ return apol_relabel_result_get_to(self);
+ };
+- const apol_vector_t *get_from() {
++ const apol_vector_t *wrap_get_from() {
+ return apol_relabel_result_get_from(self);
+ };
+- const apol_vector_t *get_both() {
++ const apol_vector_t *wrap_get_both() {
+ return apol_relabel_result_get_both(self);
+ };
+- const qpol_type_t *get_result_type() {
++ const qpol_type_t *wrap_get_result_type() {
+ return apol_relabel_result_get_result_type(self);
+ };
+ };
+@@ -3041,7 +3225,10 @@
+ };
+ %}
+ typedef struct apol_relabel_result_pair {} apol_relabel_result_pair_t;
+-%extend apol_relabel_result_pair_t {
++%rename(apol_relabel_result_pair_get_ruleA) apol_relabel_result_pair_wrap_get_ruleA;
++%rename(apol_relabel_result_pair_get_ruleB) apol_relabel_result_pair_wrap_get_ruleB;
++%rename(apol_relabel_result_pair_get_intermediate_type) apol_relabel_result_pair_wrap_get_intermediate_type;
++%extend apol_relabel_result_pair {
+ apol_relabel_result_pair() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create apol_relabel_result_pair_t objects");
+@@ -3053,13 +3240,13 @@
+ /* no op - owned and free()'d by apol_relabel_result_t */
+ return;
+ };
+- const qpol_avrule_t *get_ruleA() {
++ const qpol_avrule_t *wrap_get_ruleA() {
+ return apol_relabel_result_pair_get_ruleA(self);
+ };
+- const qpol_avrule_t *get_ruleB() {
++ const qpol_avrule_t *wrap_get_ruleB() {
+ return apol_relabel_result_pair_get_ruleB(self);
+ };
+- const qpol_type_t *get_intermediate_type() {
++ const qpol_type_t *wrap_get_intermediate_type() {
+ return apol_relabel_result_pair_get_intermediate_type(self);
+ };
+ };
+@@ -3083,7 +3270,10 @@
+ #define APOL_TYPES_RELATION_TRANS_FLOW_AB 0x4000
+ #define APOL_TYPES_RELATION_TRANS_FLOW_BA 0x8000
+ typedef struct apol_types_relation_analysis {} apol_types_relation_analysis_t;
+-%extend apol_types_relation_analysis_t {
++%rename(apol_types_relation_analysis_set_first_type) apol_types_relation_analysis_wrap_set_first_type;
++%rename(apol_types_relation_analysis_set_other_type) apol_types_relation_analysis_wrap_set_other_type;
++%rename(apol_types_relation_analysis_set_analyses) apol_types_relation_analysis_wrap_set_analyses;
++%extend apol_types_relation_analysis {
+ apol_types_relation_analysis() {
+ apol_types_relation_analysis_t *atr;
+ BEGIN_EXCEPTION
+@@ -3109,7 +3299,7 @@
+ fail:
+ return res;
+ };
+- void set_first_type(apol_policy_t *p, char *name) {
++ void wrap_set_first_type(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_types_relation_analysis_set_first_type(p, self, name)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set first type for types relation analysis");
+@@ -3118,7 +3308,7 @@
+ fail:
+ return;
+ };
+- void set_other_type(apol_policy_t *p, char *name) {
++ void wrap_set_other_type(apol_policy_t *p, char *name) {
+ BEGIN_EXCEPTION
+ if (apol_types_relation_analysis_set_other_type(p, self, name)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set other type for types relation analysis");
+@@ -3127,7 +3317,7 @@
+ fail:
+ return;
+ };
+- void set_analyses(apol_policy_t *p, int analyses) {
++ void wrap_set_analyses(apol_policy_t *p, int analyses) {
+ BEGIN_EXCEPTION
+ if (apol_types_relation_analysis_set_analyses(p, self, (unsigned int)analyses)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not set analyses to run for types relation analysis");
+@@ -3138,7 +3328,21 @@
+ };
+ };
+ typedef struct apol_types_relation_result {} apol_types_relation_result_t;
+-%extend apol_types_relation_result_t {
++%rename(apol_types_relation_result_get_attributes) apol_types_relation_result_wrap_get_attributes;
++%rename(apol_types_relation_result_get_roles) apol_types_relation_result_wrap_get_roles;
++%rename(apol_types_relation_result_get_users) apol_types_relation_result_wrap_get_users;
++%rename(apol_types_relation_result_get_similar_first) apol_types_relation_result_wrap_get_similar_first;
++%rename(apol_types_relation_result_get_similar_other) apol_types_relation_result_wrap_get_similar_other;
++%rename(apol_types_relation_result_get_dissimilar_first) apol_types_relation_result_wrap_get_dissimilar_first;
++%rename(apol_types_relation_result_get_dissimilar_other) apol_types_relation_result_wrap_get_dissimilar_other;
++%rename(apol_types_relation_result_get_allowrules) apol_types_relation_result_wrap_get_allowrules;
++%rename(apol_types_relation_result_get_typerules) apol_types_relation_result_wrap_get_typerules;
++%rename(apol_types_relation_result_get_directflows) apol_types_relation_result_wrap_get_directflows;
++%rename(apol_types_relation_result_get_transflowsAB) apol_types_relation_result_wrap_get_transflowsAB;
++%rename(apol_types_relation_result_get_transflowsBA) apol_types_relation_result_wrap_get_transflowsBA;
++%rename(apol_types_relation_result_get_domainsAB) apol_types_relation_result_wrap_get_domainsAB;
++%rename(apol_types_relation_result_get_domainsBA) apol_types_relation_result_wrap_get_domainsBA;
++%extend apol_types_relation_result {
+ apol_types_relation_result() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create apol_types_relation_result_t objects");
+@@ -3149,51 +3353,53 @@
+ ~apol_types_relation_result() {
+ apol_types_relation_result_destroy(&self);
+ };
+- const apol_vector_t *get_attributes() {
++ const apol_vector_t *wrap_get_attributes() {
+ return apol_types_relation_result_get_attributes(self);
+ };
+- const apol_vector_t *get_roles() {
++ const apol_vector_t *wrap_get_roles() {
+ return apol_types_relation_result_get_roles(self);
+ };
+- const apol_vector_t *get_users() {
++ const apol_vector_t *wrap_get_users() {
+ return apol_types_relation_result_get_users(self);
+ };
+- const apol_vector_t *get_similar_first() {
++ const apol_vector_t *wrap_get_similar_first() {
+ return apol_types_relation_result_get_similar_first(self);
+ };
+- const apol_vector_t *get_similar_other() {
++ const apol_vector_t *wrap_get_similar_other() {
+ return apol_types_relation_result_get_similar_other(self);
+ };
+- const apol_vector_t *get_dissimilar_first() {
++ const apol_vector_t *wrap_get_dissimilar_first() {
+ return apol_types_relation_result_get_dissimilar_first(self);
+ };
+- const apol_vector_t *get_dissimilar_other() {
++ const apol_vector_t *wrap_get_dissimilar_other() {
+ return apol_types_relation_result_get_dissimilar_other(self);
+ };
+- const apol_vector_t *get_allowrules() {
++ const apol_vector_t *wrap_get_allowrules() {
+ return apol_types_relation_result_get_allowrules(self);
+ };
+- const apol_vector_t *get_typerules() {
++ const apol_vector_t *wrap_get_typerules() {
+ return apol_types_relation_result_get_typerules(self);
+ };
+- const apol_vector_t *get_directflows() {
++ const apol_vector_t *wrap_get_directflows() {
+ return apol_types_relation_result_get_directflows(self);
+ };
+- const apol_vector_t *get_transflowsAB() {
++ const apol_vector_t *wrap_get_transflowsAB() {
+ return apol_types_relation_result_get_transflowsAB(self);
+ };
+- const apol_vector_t *get_transflowsBA() {
++ const apol_vector_t *wrap_get_transflowsBA() {
+ return apol_types_relation_result_get_transflowsBA(self);
+ };
+- const apol_vector_t*get_domainsAB() {
++ const apol_vector_t*wrap_get_domainsAB() {
+ return apol_types_relation_result_get_domainsAB(self);
+ };
+- const apol_vector_t*get_domainsBA() {
++ const apol_vector_t*wrap_get_domainsBA() {
+ return apol_types_relation_result_get_domainsBA(self);
+ };
+ };
+ typedef struct apol_types_relation_access {} apol_types_relation_access_t;
+-%extend apol_types_relation_access_t {
++%rename(apol_types_relation_access_get_type) apol_types_relation_access_wrap_get_type;
++%rename(apol_types_relation_access_get_rules) apol_types_relation_access_wrap_get_rules;
++%extend apol_types_relation_access {
+ apol_types_relation_access() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create apol_types_relation_access_t objects");
+@@ -3205,10 +3411,10 @@
+ /* no op - vector will destroy */
+ return;
+ };
+- const qpol_type_t *get_type() {
++ const qpol_type_t *wrap_get_type() {
+ return apol_types_relation_access_get_type(self);
+ };
+- const apol_vector_t *get_rules() {
++ const apol_vector_t *wrap_get_rules() {
+ return apol_types_relation_access_get_rules(self);
+ };
+ };
+--- setools-3.3.8/libpoldiff/swig/poldiff.i.orig 2013-01-16 17:36:24.000000000 +0100
++++ setools-3.3.8/libpoldiff/swig/poldiff.i 2014-03-05 07:46:56.307524907 +0100
+@@ -272,8 +272,8 @@
+ }
+ %}
+ typedef struct poldiff_stats {} poldiff_stats_t;
+-%extend poldiff_stats_t {
+- poldiff_stats_t() {
++%extend poldiff_stats {
++ poldiff_stats() {
+ poldiff_stats_t *s;
+ BEGIN_EXCEPTION
+ s = poldiff_stats_create();
+@@ -284,7 +284,7 @@
+ fail:
+ return s;
+ };
+- ~poldiff_stats_t() {
++ ~poldiff_stats() {
+ poldiff_stats_destroy(&self);
+ };
+ size_t get_stat(poldiff_form_e form) {
+@@ -347,8 +347,32 @@
+ }
+ #endif
+ typedef struct poldiff {} poldiff_t;
+-%extend poldiff_t {
+- poldiff_t(apol_policy_t *op, apol_policy_t *mp) {
++%rename(poldiff_run) poldiff_wrap_run;
++%rename(poldiff_is_run) poldiff_wrap_is_run;
++%rename(poldiff_get_stats) poldiff_wrap_get_stats;
++%rename(poldiff_enable_line_numbers) poldiff_wrap_enable_line_numbers;
++%rename(poldiff_get_attrib_vector) poldiff_wrap_get_attrib_vector;
++%rename(poldiff_get_avrule_vector_allow) poldiff_wrap_get_avrule_vector_allow;
++%rename(poldiff_get_avrule_vector_auditallow) poldiff_wrap_get_avrule_vector_auditallow;
++%rename(poldiff_get_avrule_vector_dontaudit) poldiff_wrap_get_avrule_vector_dontaudit;
++%rename(poldiff_get_avrule_vector_neverallow) poldiff_wrap_get_avrule_vector_neverallow;
++%rename(poldiff_get_bool_vector) poldiff_wrap_get_bool_vector;
++%rename(poldiff_get_cat_vector) poldiff_wrap_get_cat_vector;
++%rename(poldiff_get_class_vector) poldiff_wrap_get_class_vector;
++%rename(poldiff_get_common_vector) poldiff_wrap_get_common_vector;
++%rename(poldiff_get_level_vector) poldiff_wrap_get_level_vector;
++%rename(poldiff_get_range_trans_vector) poldiff_wrap_get_range_trans_vector;
++%rename(poldiff_get_role_allow_vector) poldiff_wrap_get_role_allow_vector;
++%rename(poldiff_get_role_trans_vector) poldiff_wrap_get_role_trans_vector;
++%rename(poldiff_get_role_vector) poldiff_wrap_get_role_vector;
++%rename(poldiff_get_terule_vector_change) poldiff_wrap_get_terule_vector_change;
++%rename(poldiff_get_terule_vector_member) poldiff_wrap_get_terule_vector_member;
++%rename(poldiff_get_terule_vector_trans) poldiff_wrap_get_terule_vector_trans;
++%rename(poldiff_get_type_vector) poldiff_wrap_get_type_vector;
++%rename(poldiff_get_user_vector) poldiff_wrap_get_user_vector;
++%rename(poldiff_type_remap_create) poldiff_wrap_type_remap_create;
++%extend poldiff {
++ poldiff(apol_policy_t *op, apol_policy_t *mp) {
+ poldiff_t *p;
+ BEGIN_EXCEPTION
+ p = poldiff_create(op, mp, poldiff_swig_message_callback, poldiff_swig_message_callback_arg);
+@@ -360,10 +384,10 @@
+ fail:
+ return NULL;
+ };
+- ~poldiff_t() {
++ ~poldiff() {
+ poldiff_destroy(&self);
+ };
+- void run(uint32_t flags) {
++ void wrap_run(uint32_t flags) {
+ BEGIN_EXCEPTION
+ if (poldiff_run(self, flags)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not run diff");
+@@ -372,11 +396,11 @@
+ fail:
+ return;
+ };
+- int is_run(uint32_t flags) {
++ int wrap_is_run(uint32_t flags) {
+ return poldiff_is_run(self, flags);
+ };
+ %newobject get_stats(uint32_t);
+- poldiff_stats_t *get_stats(uint32_t flags) {
++ poldiff_stats_t *wrap_get_stats(uint32_t flags) {
+ poldiff_stats_t *s = NULL;
+ BEGIN_EXCEPTION
+ s = poldiff_stats_create();
+@@ -392,7 +416,7 @@
+ poldiff_stats_destroy(&s);
+ return NULL;
+ };
+- void enable_line_numbers() {
++ void wrap_enable_line_numbers() {
+ BEGIN_EXCEPTION
+ if (poldiff_enable_line_numbers(self)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not enable line numbers");
+@@ -401,67 +425,67 @@
+ fail:
+ return;
+ };
+- const apol_vector_t *get_attrib_vector() {
++ const apol_vector_t *wrap_get_attrib_vector() {
+ return poldiff_get_attrib_vector(self);
+ };
+- const apol_vector_t *get_avrule_vector_allow() {
++ const apol_vector_t *wrap_get_avrule_vector_allow() {
+ return poldiff_get_avrule_vector_allow(self);
+ };
+- const apol_vector_t *get_avrule_vector_auditallow() {
++ const apol_vector_t *wrap_get_avrule_vector_auditallow() {
+ return poldiff_get_avrule_vector_auditallow(self);
+ };
+- const apol_vector_t *get_avrule_vector_dontaudit() {
++ const apol_vector_t *wrap_get_avrule_vector_dontaudit() {
+ return poldiff_get_avrule_vector_dontaudit(self);
+ };
+- const apol_vector_t *get_avrule_vector_neverallow() {
++ const apol_vector_t *wrap_get_avrule_vector_neverallow() {
+ return poldiff_get_avrule_vector_neverallow(self);
+ };
+- const apol_vector_t *get_bool_vector() {
++ const apol_vector_t *wrap_get_bool_vector() {
+ return poldiff_get_bool_vector(self);
+ };
+- const apol_vector_t *get_cat_vector() {
++ const apol_vector_t *wrap_get_cat_vector() {
+ return poldiff_get_cat_vector(self);
+ };
+- const apol_vector_t *get_class_vector() {
++ const apol_vector_t *wrap_get_class_vector() {
+ return poldiff_get_class_vector(self);
+ };
+- const apol_vector_t *get_common_vector() {
++ const apol_vector_t *wrap_get_common_vector() {
+ return poldiff_get_common_vector(self);
+ };
+- const apol_vector_t *get_level_vector() {
++ const apol_vector_t *wrap_get_level_vector() {
+ return poldiff_get_level_vector(self);
+ };
+- const apol_vector_t *get_range_trans_vector() {
++ const apol_vector_t *wrap_get_range_trans_vector() {
+ return poldiff_get_range_trans_vector(self);
+ };
+- const apol_vector_t *get_role_allow_vector() {
++ const apol_vector_t *wrap_get_role_allow_vector() {
+ return poldiff_get_role_allow_vector(self);
+ };
+- const apol_vector_t *get_role_trans_vector() {
++ const apol_vector_t *wrap_get_role_trans_vector() {
+ return poldiff_get_role_trans_vector(self);
+ };
+- const apol_vector_t *get_role_vector() {
++ const apol_vector_t *wrap_get_role_vector() {
+ return poldiff_get_role_vector(self);
+ };
+- const apol_vector_t *get_terule_vector_change() {
++ const apol_vector_t *wrap_get_terule_vector_change() {
+ return poldiff_get_terule_vector_change(self);
+ };
+- const apol_vector_t *get_terule_vector_member() {
++ const apol_vector_t *wrap_get_terule_vector_member() {
+ return poldiff_get_terule_vector_member(self);
+ };
+- const apol_vector_t *get_terule_vector_trans() {
++ const apol_vector_t *wrap_get_terule_vector_trans() {
+ return poldiff_get_terule_vector_trans(self);
+ };
+- const apol_vector_t *get_type_vector() {
++ const apol_vector_t *wrap_get_type_vector() {
+ return poldiff_get_type_vector(self);
+ };
+- const apol_vector_t *get_user_vector() {
++ const apol_vector_t *wrap_get_user_vector() {
+ return poldiff_get_user_vector(self);
+ };
+- const apol_vector_t *get_type_remap_entries() {
++ const apol_vector_t *wrap_get_type_remap_entries() {
+ return poldiff_type_remap_get_entries(self);
+ };
+- void type_remap_create(apol_string_vector_t *orig_types, apol_string_vector_t *mod_types) {
++ void wrap_type_remap_create(apol_string_vector_t *orig_types, apol_string_vector_t *mod_types) {
+ BEGIN_EXCEPTION
+ if (poldiff_type_remap_create(self, (apol_vector_t*)orig_types, (apol_vector_t*)mod_types)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not remap types");
+@@ -477,20 +501,25 @@
+
+ /* attribute diff */
+ typedef struct poldiff_attrib {} poldiff_attrib_t;
+-%extend poldiff_attrib_t {
+- poldiff_attrib_t () {
++%rename(poldiff_attrib_to_string) poldiff_attrib_wrap_to_string;
++%rename(poldiff_attrib_get_name) poldiff_attrib_wrap_get_name;
++%rename(poldiff_attrib_get_form) poldiff_attrib_wrap_get_form;
++%rename(poldiff_attrib_get_added_types) poldiff_attrib_wrap_get_added_types;
++%rename(poldiff_attrib_get_removed_types) poldiff_attrib_wrap_get_removed_types;
++%extend poldiff_attrib {
++ poldiff_attrib () {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_attrib_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+- ~poldiff_attrib_t() {
++ ~poldiff_attrib() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+- char *to_string(poldiff_t *p) {
++ char *wrap_to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_attrib_to_string(p, self);
+@@ -501,16 +530,16 @@
+ fail:
+ return str;
+ };
+- const char *get_name() {
++ const char *wrap_get_name() {
+ return poldiff_attrib_get_name(self);
+ };
+- poldiff_form_e get_form() {
++ poldiff_form_e wrap_get_form() {
+ return poldiff_attrib_get_form(self);
+ };
+- const apol_string_vector_t *get_added_types() {
++ const apol_string_vector_t *wrap_get_added_types() {
+ return (apol_string_vector_t*)poldiff_attrib_get_added_types(self);
+ };
+- const apol_string_vector_t *get_removed_types() {
++ const apol_string_vector_t *wrap_get_removed_types() {
+ return (apol_string_vector_t*)poldiff_attrib_get_removed_types(self);
+ };
+ };
+@@ -522,20 +551,34 @@
+
+ /* av rule diff */
+ typedef struct poldiff_avrule {} poldiff_avrule_t;
+-%extend poldiff_avrule_t {
+- poldiff_avrule_t() {
++%rename(poldiff_avrule_to_string) poldiff_avrule_wrap_to_string;
++%rename(poldiff_avrule_get_form) poldiff_avrule_wrap_get_form;
++%rename(poldiff_avrule_get_rule_type) poldiff_avrule_wrap_get_rule_type;
++%rename(poldiff_avrule_get_source_type) poldiff_avrule_wrap_get_source_type;
++%rename(poldiff_avrule_get_target_type) poldiff_avrule_wrap_get_target_type;
++%rename(poldiff_avrule_get_object_class) poldiff_avrule_wrap_get_object_class;
++%rename(poldiff_avrule_get_cond) poldiff_avrule_wrap_get_cond;
++%rename(poldiff_avrule_get_unmodified_perms) poldiff_avrule_wrap_get_unmodified_perms;
++%rename(poldiff_avrule_get_added_perms) poldiff_avrule_wrap_get_added_perms;
++%rename(poldiff_avrule_get_removed_perms) poldiff_avrule_wrap_get_removed_perms;
++%rename(poldiff_avrule_get_orig_line_numbers) poldiff_avrule_wrap_get_orig_line_numbers;
++%rename(poldiff_avrule_get_orig_line_numbers_for_perm) poldiff_avrule_wrap_get_orig_line_numbers_for_perm;
++%rename(poldiff_avrule_get_mod_line_numbers) poldiff_avrule_wrap_get_mod_line_numbers;
++%rename(poldiff_avrule_get_mod_line_numbers_for_perm) poldiff_avrule_wrap_get_modline_numbers_for_perm;
++%extend poldiff_avrule {
++ poldiff_avrule() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_avrule_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+- ~poldiff_avrule_t() {
++ ~poldiff_avrule() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+- char *to_string(poldiff_t *p) {
++ char *wrap_to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_avrule_to_string(p, self);
+@@ -546,22 +589,22 @@
+ fail:
+ return str;
+ };
+- poldiff_form_e get_form() {
++ poldiff_form_e wrap_get_form() {
+ return poldiff_avrule_get_form(self);
+ };
+- uint32_t get_rule_type() {
++ uint32_t wrap_get_rule_type() {
+ return poldiff_avrule_get_rule_type(self);
+ };
+- const char *get_source_type() {
++ const char *wrap_get_source_type() {
+ return poldiff_avrule_get_source_type(self);
+ };
+- const char *get_target_type() {
++ const char *wrap_get_target_type() {
+ return poldiff_avrule_get_target_type(self);
+ };
+- const char *get_object_class() {
++ const char *wrap_get_object_class() {
+ return poldiff_avrule_get_object_class(self);
+ };
+- const qpol_cond_t *get_cond(poldiff_t *p) {
++ const qpol_cond_t *wrap_get_cond(poldiff_t *p) {
+ const qpol_cond_t *cond;
+ uint32_t which_list;
+ const apol_policy_t *which_pol;
+@@ -582,20 +625,20 @@
+ poldiff_avrule_get_cond(p, self, &cond, &which_list, &which_pol);
+ return which_pol;
+ };
+- const apol_string_vector_t *get_unmodified_perms() {
++ const apol_string_vector_t *wrap_get_unmodified_perms() {
+ return (apol_string_vector_t*)poldiff_avrule_get_unmodified_perms(self);
+ };
+- const apol_string_vector_t *get_added_perms() {
++ const apol_string_vector_t *wrap_get_added_perms() {
+ return (apol_string_vector_t*)poldiff_avrule_get_added_perms(self);
+ };
+- const apol_string_vector_t *get_removed_perms() {
++ const apol_string_vector_t *wrap_get_removed_perms() {
+ return (apol_string_vector_t*)poldiff_avrule_get_removed_perms(self);
+ };
+- const apol_vector_t *get_orig_line_numbers() {
++ const apol_vector_t *wrap_get_orig_line_numbers() {
+ return poldiff_avrule_get_orig_line_numbers(self);
+ };
+ %newobject get_orig_line_numbers_for_perm(poldiff_t*, char*);
+- apol_vector_t *get_orig_line_numbers_for_perm(poldiff_t *p, char *perm) {
++ apol_vector_t *wrap_get_orig_line_numbers_for_perm(poldiff_t *p, char *perm) {
+ apol_vector_t *v;
+ BEGIN_EXCEPTION
+ v = poldiff_avrule_get_orig_line_numbers_for_perm(p, self, perm);
+@@ -606,11 +649,11 @@
+ fail:
+ return v;
+ };
+- const apol_vector_t *get_mod_line_numbers() {
++ const apol_vector_t *wrap_get_mod_line_numbers() {
+ return poldiff_avrule_get_mod_line_numbers(self);
+ };
+ %newobject get_mod_line_numbers_for_perm(poldiff_t*, char*);
+- apol_vector_t *get_mod_line_numbers_for_perm(poldiff_t *p, char *perm) {
++ apol_vector_t *wrap_get_mod_line_numbers_for_perm(poldiff_t *p, char *perm) {
+ apol_vector_t *v;
+ BEGIN_EXCEPTION
+ v = poldiff_avrule_get_mod_line_numbers_for_perm(p, self, perm);
+@@ -630,20 +673,23 @@
+
+ /* boolean diff */
+ typedef struct poldiff_bool {} poldiff_bool_t;
+-%extend poldiff_bool_t {
+- poldiff_bool_t() {
++%rename(poldiff_bool_to_string) poldiff_bool_wrap_to_string;
++%rename(poldiff_bool_get_name) poldiff_bool_wrap_get_name;
++%rename(poldiff_bool_get_form) poldiff_bool_wrap_get_form;
++%extend poldiff_bool {
++ poldiff_bool() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_bool_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+- ~poldiff_bool_t() {
++ ~poldiff_bool() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+- char *to_string(poldiff_t *p) {
++ char *wrap_to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_bool_to_string(p, self);
+@@ -654,10 +700,10 @@
+ fail:
+ return str;
+ };
+- const char *get_name() {
++ const char *wrap_get_name() {
+ return poldiff_bool_get_name(self);
+ };
+- poldiff_form_e get_form() {
++ poldiff_form_e wrap_get_form() {
+ return poldiff_bool_get_form(self);
+ };
+ };
+@@ -669,20 +715,23 @@
+
+ /* category diff */
+ typedef struct poldiff_cat {} poldiff_cat_t;
+-%extend poldiff_cat_t {
+- poldiff_cat_t() {
++%rename(poldiff_cat_to_string) poldiff_cat_wrap_to_string;
++%rename(poldiff_cat_get_name) poldiff_cat_wrap_get_name;
++%rename(poldiff_cat_get_form) poldiff_cat_wrap_get_form;
++%extend poldiff_cat {
++ poldiff_cat() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_cat_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+- ~poldiff_cat_t() {
++ ~poldiff_cat() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+- char *to_string(poldiff_t *p) {
++ char *wrap_to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_cat_to_string(p, self);
+@@ -693,10 +742,10 @@
+ fail:
+ return str;
+ };
+- const char *get_name() {
++ const char *wrap_get_name() {
+ return poldiff_cat_get_name(self);
+ };
+- poldiff_form_e get_form() {
++ poldiff_form_e wrap_get_form() {
+ return poldiff_cat_get_form(self);
+ };
+ };
+@@ -708,20 +757,25 @@
+
+ /* class diff */
+ typedef struct poldiff_class {} poldiff_class_t;
+-%extend poldiff_class_t {
+- poldiff_class_t() {
++%rename(poldiff_class_to_string) poldiff_class_wrap_to_string;
++%rename(poldiff_class_get_name) poldiff_class_wrap_get_name;
++%rename(poldiff_class_get_form) poldiff_class_wrap_get_form;
++%rename(poldiff_class_get_added_perms) poldiff_class_wrap_get_added_perms;
++%rename(poldiff_class_get_removed_perms) poldiff_class_wrap_get_removed_perms;
++%extend poldiff_class {
++ poldiff_class() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_class_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+- ~poldiff_class_t() {
++ ~poldiff_class() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+- char *to_string(poldiff_t *p) {
++ char *wrap_to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_class_to_string(p, self);
+@@ -732,16 +786,16 @@
+ fail:
+ return str;
+ };
+- const char *get_name() {
++ const char *wrap_get_name() {
+ return poldiff_class_get_name(self);
+ };
+- poldiff_form_e get_form() {
++ poldiff_form_e wrap_get_form() {
+ return poldiff_class_get_form(self);
+ };
+- const apol_string_vector_t *get_added_perms() {
++ const apol_string_vector_t *wrap_get_added_perms() {
+ return (apol_string_vector_t*)poldiff_class_get_added_perms(self);
+ };
+- const apol_string_vector_t *get_removed_perms() {
++ const apol_string_vector_t *wrap_get_removed_perms() {
+ return (apol_string_vector_t*)poldiff_class_get_removed_perms(self);
+ };
+ };
+@@ -753,20 +807,25 @@
+
+ /* common diff */
+ typedef struct poldiff_common {} poldiff_common_t;
+-%extend poldiff_common_t {
+- poldiff_common_t() {
++%rename(poldiff_common_to_string) poldiff_common_wrap_to_string;
++%rename(poldiff_common_get_name) poldiff_common_wrap_get_name;
++%rename(poldiff_common_get_form) poldiff_common_wrap_get_form;
++%rename(poldiff_common_get_added_perms) poldiff_common_wrap_get_added_perms;
++%rename(poldiff_common_get_removed_perms) poldiff_common_wrap_get_removed_perms;
++%extend poldiff_common {
++ poldiff_common() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_common_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+- ~poldiff_common_t() {
++ ~poldiff_common() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+- char *to_string(poldiff_t *p) {
++ char *wrap_to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_common_to_string(p, self);
+@@ -777,16 +836,16 @@
+ fail:
+ return str;
+ };
+- const char *get_name() {
++ const char *wrap_get_name() {
+ return poldiff_common_get_name(self);
+ };
+- poldiff_form_e get_form() {
++ poldiff_form_e wrap_get_form() {
+ return poldiff_common_get_form(self);
+ };
+- const apol_string_vector_t *get_added_perms() {
++ const apol_string_vector_t *wrap_get_added_perms() {
+ return (apol_string_vector_t*)poldiff_common_get_added_perms(self);
+ };
+- const apol_string_vector_t *get_removed_perms() {
++ const apol_string_vector_t *wrap_get_removed_perms() {
+ return (apol_string_vector_t*)poldiff_common_get_removed_perms(self);
+ };
+ };
+@@ -798,20 +857,27 @@
+
+ /* level diff */
+ typedef struct poldiff_level {} poldiff_level_t;
+-%extend poldiff_level_t {
+- poldiff_level_t() {
++%rename(poldiff_level_to_string) poldiff_level_wrap_to_string;
++%rename(poldiff_level_to_string_brief) poldiff_level_wrap_to_string_brief;
++%rename(poldiff_level_get_name) poldiff_level_wrap_get_name;
++%rename(poldiff_level_get_form) poldiff_level_wrap_get_form;
++%rename(poldiff_level_get_unmodified_cats) poldiff_level_wrap_get_unmodified_cats;
++%rename(poldiff_level_get_added_cats) poldiff_level_wrap_get_added_cats;
++%rename(poldiff_level_get_removed_cats) poldiff_level_wrap_get_removed_cats;
++%extend poldiff_level {
++ poldiff_level() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_level_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+- ~poldiff_level_t() {
++ ~poldiff_level() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+- char *to_string(poldiff_t *p) {
++ char *wrap_to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_level_to_string(p, self);
+@@ -823,7 +889,7 @@
+ return str;
+ };
+ %newobject to_string_brief(poldiff_t*);
+- char *to_string(poldiff_t *p) {
++ char *wrap_to_string_brief(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_level_to_string_brief(p, self);
+@@ -834,19 +900,19 @@
+ fail:
+ return str;
+ };
+- const char *get_name() {
++ const char *wrap_get_name() {
+ return poldiff_level_get_name(self);
+ };
+- poldiff_form_e get_form() {
++ poldiff_form_e wrap_get_form() {
+ return poldiff_level_get_form(self);
+ };
+- const apol_string_vector_t *get_unmodified_cats() {
++ const apol_string_vector_t *wrap_get_unmodified_cats() {
+ return (apol_string_vector_t*)poldiff_level_get_unmodified_cats(self);
+ };
+- const apol_string_vector_t *get_added_cats() {
++ const apol_string_vector_t *wrap_get_added_cats() {
+ return (apol_string_vector_t*)poldiff_level_get_added_cats(self);
+ };
+- const apol_string_vector_t *get_removed_cats() {
++ const apol_string_vector_t *wrap_get_removed_cats() {
+ return (apol_string_vector_t*)poldiff_level_get_removed_cats(self);
+ };
+ };
+@@ -858,15 +924,21 @@
+
+ /* range diff */
+ typedef struct poldiff_range {} poldiff_range_t;
+-%extend poldiff_range_t {
+- poldiff_range_t() {
++%rename(poldiff_range_get_levels) poldiff_range_wrap_get_levels;
++%rename(poldiff_range_get_original_range) poldiff_range_wrap_get_original_range;
++%rename(poldiff_range_get_modified_range) poldiff_range_wrap_get_modified_range;
++%rename(poldiff_range_get_min_added_cats) poldiff_range_wrap_get_min_added_cats;
++%rename(poldiff_range_get_min_removed_cats) poldiff_range_wrap_get_min_removed_cats;
++%rename(poldiff_range_get_min_unmodified_cats) poldiff_range_wrap_get_min_unmodified_cats;
++%extend poldiff_range {
++ poldiff_range() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_range_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+- ~poldiff_range_t() {
++ ~poldiff_range() {
+ /* no op */
+ return;
+ };
+@@ -882,22 +954,22 @@
+ fail:
+ return str;
+ };
+- const apol_vector_t *get_levels() {
++ const apol_vector_t *wrap_get_levels() {
+ return poldiff_range_get_levels(self);
+ };
+- const apol_mls_range_t *get_original_range() {
++ const apol_mls_range_t *wrap_get_original_range() {
+ return poldiff_range_get_original_range(self);
+ };
+- const apol_mls_range_t *get_modified_range() {
++ const apol_mls_range_t *wrap_get_modified_range() {
+ return poldiff_range_get_modified_range(self);
+ };
+- const apol_string_vector_t *get_min_added_cats() {
++ const apol_string_vector_t *wrap_get_min_added_cats() {
+ return (apol_string_vector_t*)poldiff_range_get_min_added_cats(self);
+ };
+- const apol_string_vector_t *get_min_removed_cats() {
++ const apol_string_vector_t *wrap_get_min_removed_cats() {
+ return (apol_string_vector_t*)poldiff_range_get_min_removed_cats(self);
+ };
+- const apol_string_vector_t *get_min_unmodified_cats() {
++ const apol_string_vector_t *wrap_get_min_unmodified_cats() {
+ return (apol_string_vector_t*)poldiff_range_get_min_unmodified_cats(self);
+ };
+ };
+@@ -909,20 +981,26 @@
+
+ /* range_transition rule diff */
+ typedef struct poldiff_range_trans {} poldiff_range_trans_t;
+-%extend poldiff_range_trans_t {
+- poldiff_range_trans_t() {
++%rename(poldiff_range_trans_to_string) poldiff_range_trans_wrap_to_string;
++%rename(poldiff_range_trans_get_form) poldiff_range_trans_wrap_get_form;
++%rename(poldiff_range_trans_get_source_type) poldiff_range_trans_wrap_get_source_type;
++%rename(poldiff_range_trans_get_target_type) poldiff_range_trans_wrap_get_target_type;
++%rename(poldiff_range_trans_get_target_class) poldiff_range_trans_wrap_get_target_class;
++%rename(poldiff_range_trans_get_range) poldiff_range_trans_wrap_get_range;
++%extend poldiff_range_trans {
++ poldiff_range_trans() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_range_trans_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+- ~poldiff_range_trans_t() {
++ ~poldiff_range_trans() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+- char *to_string(poldiff_t *p) {
++ char *wrap_to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_range_trans_to_string(p, self);
+@@ -933,19 +1011,19 @@
+ fail:
+ return str;
+ };
+- poldiff_form_e get_form() {
++ poldiff_form_e wrap_get_form() {
+ return poldiff_range_trans_get_form(self);
+ };
+- const char *get_source_type() {
++ const char *wrap_get_source_type() {
+ return poldiff_range_trans_get_source_type(self);
+ };
+- const char *get_target_type() {
++ const char *wrap_get_target_type() {
+ return poldiff_range_trans_get_target_type(self);
+ };
+- const char *get_target_class() {
++ const char *wrap_get_target_class() {
+ return poldiff_range_trans_get_target_class(self);
+ };
+- const poldiff_range_t *get_range() {
++ const poldiff_range_t *wrap_get_range() {
+ return poldiff_range_trans_get_range(self);
+ };
+ };
+@@ -957,20 +1035,26 @@
+
+ /* role allow rule diff */
+ typedef struct poldiff_role_allow {} poldiff_role_allow_t;
+-%extend poldiff_role_allow_t {
+- poldiff_role_allow_t() {
++%rename(poldiff_role_allow_to_string) poldiff_role_allow_wrap_to_string;
++%rename(poldiff_role_allow_get_name) poldiff_role_allow_wrap_get_name;
++%rename(poldiff_role_allow_get_form) poldiff_role_allow_wrap_get_form;
++%rename(poldiff_role_allow_get_unmodified_roles) poldiff_role_allow_wrap_get_unmodified_roles;
++%rename(poldiff_role_allow_get_added_roles) poldiff_role_allow_wrap_get_added_roles;
++%rename(poldiff_role_allow_get_removed_roles) poldiff_role_allow_wrap_get_removed_roles;
++%extend poldiff_role_allow {
++ poldiff_role_allow() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_role_allow_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+- ~poldiff_role_allow_t() {
++ ~poldiff_role_allow() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+- char *to_string(poldiff_t *p) {
++ char *wrap_to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_role_allow_to_string(p, self);
+@@ -981,19 +1065,19 @@
+ fail:
+ return str;
+ };
+- const char *get_name() {
++ const char *wrap_get_name() {
+ return poldiff_role_allow_get_name(self);
+ };
+- poldiff_form_e get_form() {
++ poldiff_form_e wrap_get_form() {
+ return poldiff_role_allow_get_form(self);
+ };
+- const apol_string_vector_t *get_unmodified_roles() {
++ const apol_string_vector_t *wrap_get_unmodified_roles() {
+ return (apol_string_vector_t*)poldiff_role_allow_get_unmodified_roles(self);
+ };
+- const apol_string_vector_t *get_added_roles() {
++ const apol_string_vector_t *wrap_get_added_roles() {
+ return (apol_string_vector_t*)poldiff_role_allow_get_added_roles(self);
+ };
+- const apol_string_vector_t *get_removed_roles() {
++ const apol_string_vector_t *wrap_get_removed_roles() {
+ return (apol_string_vector_t*)poldiff_role_allow_get_removed_roles(self);
+ };
+ };
+@@ -1005,20 +1089,26 @@
+
+ /* role_transition rule diff */
+ typedef struct poldiff_role_trans {} poldiff_role_trans_t;
+-%extend poldiff_role_trans_t {
+- poldiff_role_trans_t() {
++%rename(poldiff_role_trans_to_string) poldiff_role_trans_wrap_to_string;
++%rename(poldiff_role_trans_get_form) poldiff_role_trans_wrap_get_form;
++%rename(poldiff_role_trans_get_source_role) poldiff_role_trans_wrap_get_source_role;
++%rename(poldiff_role_trans_get_target_type) poldiff_role_trans_wrap_get_target_type;
++%rename(poldiff_role_trans_get_original_default) poldiff_role_trans_wrap_get_original_default;
++%rename(poldiff_role_trans_get_modified_default) poldiff_role_trans_wrap_get_modified_default;
++%extend poldiff_role_trans {
++ poldiff_role_trans() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_role_trans_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+- ~poldiff_role_trans_t() {
++ ~poldiff_role_trans() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+- char *to_string(poldiff_t *p) {
++ char *wrap_to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_role_trans_to_string(p, self);
+@@ -1029,19 +1119,19 @@
+ fail:
+ return str;
+ };
+- poldiff_form_e get_form() {
++ poldiff_form_e wrap_get_form() {
+ return poldiff_role_trans_get_form(self);
+ };
+- const char *get_source_role() {
++ const char *wrap_get_source_role() {
+ return poldiff_role_trans_get_source_role(self);
+ };
+- const char *get_target_type() {
++ const char *wrap_get_target_type() {
+ return poldiff_role_trans_get_target_type(self);
+ };
+- const char *get_original_default() {
++ const char *wrap_get_original_default() {
+ return poldiff_role_trans_get_original_default(self);
+ };
+- const char *get_modified_default() {
++ const char *wrap_get_modified_default() {
+ return poldiff_role_trans_get_modified_default(self);
+ };
+ };
+@@ -1053,20 +1143,25 @@
+
+ /* role diff */
+ typedef struct poldiff_role {} poldiff_role_t;
+-%extend poldiff_role_t {
+- poldiff_role_t() {
++%rename(poldiff_role_to_string) poldiff_role_wrap_to_string;
++%rename(poldiff_role_get_name) poldiff_role_wrap_get_name;
++%rename(poldiff_role_get_form) poldiff_role_wrap_get_form;
++%rename(poldiff_role_get_added_types) poldiff_role_wrap_get_added_types;
++%rename(poldiff_role_get_removed_types) poldiff_role_wrap_get_removed_types;
++%extend poldiff_role {
++ poldiff_role() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_role_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+- ~poldiff_role_t() {
++ ~poldiff_role() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+- char *to_string(poldiff_t *p) {
++ char *wrap_to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_role_to_string(p, self);
+@@ -1077,16 +1172,16 @@
+ fail:
+ return str;
+ };
+- const char *get_name() {
++ const char *wrap_get_name() {
+ return poldiff_role_get_name(self);
+ };
+- poldiff_form_e get_form() {
++ poldiff_form_e wrap_get_form() {
+ return poldiff_role_get_form(self);
+ };
+- const apol_string_vector_t *get_added_types() {
++ const apol_string_vector_t *wrap_get_added_types() {
+ return (apol_string_vector_t*)poldiff_role_get_added_types(self);
+ };
+- const apol_string_vector_t *get_removed_types() {
++ const apol_string_vector_t *wrap_get_removed_types() {
+ return (apol_string_vector_t*)poldiff_role_get_removed_types(self);
+ };
+ };
+@@ -1098,20 +1193,31 @@
+
+ /* te rule diff */
+ typedef struct poldiff_terule {} poldiff_terule_t;
+-%extend poldiff_terule_t {
+- poldiff_terule_t() {
++%rename(poldiff_terule_to_string) poldiff_terule_wrap_to_string;
++%rename(poldiff_terule_get_form) poldiff_terule_wrap_get_form;
++%rename(poldiff_terule_get_rule_type) poldiff_terule_wrap_get_rule_type;
++%rename(poldiff_terule_get_source_type) poldiff_terule_wrap_get_source_type;
++%rename(poldiff_terule_get_target_type) poldiff_terule_wrap_get_target_type;
++%rename(poldiff_terule_get_object_class) poldiff_terule_wrap_get_object_class;
++%rename(poldiff_terule_get_cond) poldiff_terule_wrap_get_cond;
++%rename(poldiff_terule_get_original_default) poldiff_terule_wrap_get_original_default;
++%rename(poldiff_terule_get_modified_default) poldiff_terule_wrap_get_modified_default;
++%rename(poldiff_terule_get_orig_line_numbers) poldiff_terule_wrap_get_orig_line_numbers;
++%rename(poldiff_terule_get_mod_line_numbers) poldiff_terule_wrap_get_mod_line_numbers;
++%extend poldiff_terule {
++ poldiff_terule() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_terule_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+- ~poldiff_terule_t() {
++ ~poldiff_terule() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+- char *to_string(poldiff_t *p) {
++ char *wrap_to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_terule_to_string(p, self);
+@@ -1122,22 +1228,22 @@
+ fail:
+ return str;
+ };
<Skipped 4962 lines>
================================================================
---- gitweb:
http://git.pld-linux.org/gitweb.cgi/packages/setools.git/commitdiff/4df63b553c7b85067bf2789494d10b47f4774ba4
More information about the pld-cvs-commit
mailing list