summaryrefslogtreecommitdiffstats
path: root/libpoldiff/swig/poldiff.i
diff options
context:
space:
mode:
Diffstat (limited to 'libpoldiff/swig/poldiff.i')
-rw-r--r--libpoldiff/swig/poldiff.i1335
1 files changed, 1335 insertions, 0 deletions
diff --git a/libpoldiff/swig/poldiff.i b/libpoldiff/swig/poldiff.i
new file mode 100644
index 0000000..29767a8
--- /dev/null
+++ b/libpoldiff/swig/poldiff.i
@@ -0,0 +1,1335 @@
+/**
+ * @file
+ * SWIG declarations for libpoldiff.
+ *
+ * @author Jeremy A. Mowery jmowery@tresys.com
+ * @author Jason Tang jtang@tresys.com
+ *
+ * Copyright (C) 2006-2007 Tresys Technology, LLC
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+%module poldiff
+
+%{
+#include <poldiff/attrib_diff.h>
+#include <poldiff/avrule_diff.h>
+#include <poldiff/bool_diff.h>
+#include <poldiff/cat_diff.h>
+#include <poldiff/class_diff.h>
+#include <poldiff/level_diff.h>
+#include <poldiff/poldiff.h>
+#include <poldiff/range_diff.h>
+#include <poldiff/range_trans_diff.h>
+#include <poldiff/rbac_diff.h>
+#include <poldiff/role_diff.h>
+#include <poldiff/terule_diff.h>
+#include <poldiff/type_diff.h>
+#include <poldiff/type_map.h>
+#include <poldiff/user_diff.h>
+#include <poldiff/util.h>
+
+/* Provide hooks so that language-specific modules can define the
+ * callback function, used by the handler in poldiff_create().
+ */
+SWIGEXPORT poldiff_handle_fn_t poldiff_swig_message_callback = NULL;
+SWIGEXPORT void * poldiff_swig_message_callback_arg = NULL;
+
+%}
+
+#ifdef SWIGJAVA
+%javaconst(1);
+/* get the java environment so we can throw exceptions */
+%{
+ static JNIEnv *poldiff_global_jenv;
+ jint JNI_OnLoad(JavaVM *vm, void *reserved) {
+ (*vm)->AttachCurrentThread(vm, (void **)&poldiff_global_jenv, NULL);
+ return JNI_VERSION_1_2;
+ }
+%}
+#endif
+
+%include exception.i
+%include stdint.i
+%import apol.i
+
+%{
+#undef BEGIN_EXCEPTION
+#undef END_EXCEPTION
+%}
+
+#ifdef SWIGJAVA
+
+%exception {
+ poldiff_global_jenv = jenv;
+ $action
+}
+
+%{
+#define BEGIN_EXCEPTION JNIEnv *local_jenv = poldiff_global_jenv; {
+#define END_EXCEPTION }
+%}
+
+/* handle size_t correctly in java as architecture independent */
+%typemap(jni) size_t "jlong"
+%typemap(jtype) size_t "long"
+%typemap(jstype) size_t "long"
+%typemap("javaimports") SWIGTYPE %{
+import com.tresys.setools.qpol.*;
+import com.tresys.setools.apol.*;
+%}
+%typemap(javabody) SWIGTYPE %{
+ private long swigCPtr;
+ protected boolean swigCMemOwn;
+
+ public $javaclassname(long cPtr, boolean cMemoryOwn) {
+ swigCMemOwn = cMemoryOwn;
+ swigCPtr = cPtr;
+ }
+
+ public static long getCPtr($javaclassname obj) {
+ return (obj == null) ? 0 : obj.swigCPtr;
+ }
+%}
+/* the following handles the dependencies on qpol and apol */
+%pragma(java) jniclassimports=%{
+import com.tresys.setools.qpol.*;
+import com.tresys.setools.apol.*;
+%}
+%pragma(java) jniclasscode=%{
+ static {
+ try
+ {
+ libpoldiff_get_version ();
+ }
+ catch (UnsatisfiedLinkError ule)
+ {
+ System.loadLibrary("jpoldiff");
+ }
+ }
+%}
+%pragma(java) moduleimports=%{
+import com.tresys.setools.qpol.*;
+import com.tresys.setools.apol.*;
+%}
+#else
+/* not in java so handle size_t as architecture dependent */
+#ifdef SWIGWORDSIZE64
+typedef uint64_t size_t;
+#else
+typedef uint32_t size_t;
+#endif
+%{
+#define BEGIN_EXCEPTION
+#define END_EXCEPTION
+%}
+#endif
+
+#ifdef SWIGJAVA
+/* if java, pass the new exception macro to C not just SWIG */
+#undef SWIG_exception
+#define SWIG_exception(code, msg) {SWIG_JavaException(local_jenv, code, msg); goto fail;}
+#define SWIG_exception_typemap(code, msg) {SWIG_JavaException(jenv, code, msg);}
+%inline %{
+#undef SWIG_exception
+#define SWIG_exception(code, msg) {SWIG_JavaException(local_jenv, code, msg); goto fail;}
+%}
+#endif
+
+#ifdef SWIGTCL
+/* implement a custom non thread-safe error handler */
+%{
+static char *message = NULL;
+static void tcl_clear_error(void)
+{
+ free(message);
+ message = NULL;
+}
+static void tcl_throw_error(const char *s)
+{
+ free(message);
+ message = strdup(s);
+}
+static char *tcl_get_error(void)
+{
+ return message;
+}
+#undef SWIG_exception
+#define SWIG_exception(code, msg) {tcl_throw_error(msg); goto fail;}
+%}
+
+%wrapper %{
+/* Tcl module's initialization routine is expected to be named
+ * Poldiff_Init(), but the output file will be called libtpoldiff.so instead
+ * of libpoldiff.so. Therefore add an alias from Tpoldiff_Init() to the
+ * real Poldiff_Init().
+ */
+SWIGEXPORT int Tpoldiff_Init(Tcl_Interp *interp) {
+ return SWIG_init(interp);
+}
+%}
+
+%exception {
+ char *err;
+ tcl_clear_error();
+ $action
+ if ((err = tcl_get_error()) != NULL) {
+ Tcl_Obj *obj = Tcl_NewStringObj(message, -1);
+ Tcl_ResetResult(interp);
+ Tcl_SetObjResult(interp, obj);
+ goto fail;
+ }
+}
+#undef SWIG_exception
+#define SWIG_exception(code, msg) {tcl_throw_error(msg); goto fail;}
+#endif
+
+%inline %{
+ typedef struct apol_string_vector apol_string_vector_t;
+%}
+
+const char *libpoldiff_get_version (void);
+
+/* diff element flags */
+#define POLDIFF_DIFF_CLASSES 0x00000001
+#define POLDIFF_DIFF_COMMONS 0x00000002
+#define POLDIFF_DIFF_TYPES 0x00000004
+#define POLDIFF_DIFF_ATTRIBS 0x00000008
+#define POLDIFF_DIFF_ROLES 0x00000010
+#define POLDIFF_DIFF_USERS 0x00000020
+#define POLDIFF_DIFF_BOOLS 0x00000040
+#define POLDIFF_DIFF_LEVELS 0x00000080
+#define POLDIFF_DIFF_CATS 0x00000100
+#define POLDIFF_DIFF_AVRULES 0x00000200
+#define POLDIFF_DIFF_TERULES 0x00000400
+#define POLDIFF_DIFF_ROLE_ALLOWS 0x00000800
+#define POLDIFF_DIFF_ROLE_TRANS 0x00001000
+#define POLDIFF_DIFF_RANGE_TRANS 0x00002000
+#define POLDIFF_DIFF_SYMBOLS (POLDIFF_DIFF_CLASSES|POLDIFF_DIFF_COMMONS|POLDIFF_DIFF_TYPES|POLDIFF_DIFF_ATTRIBS|POLDIFF_DIFF_ROLES|POLDIFF_DIFF_USERS|POLDIFF_DIFF_BOOLS)
+#define POLDIFF_DIFF_RULES (POLDIFF_DIFF_AVRULES|POLDIFF_DIFF_TERULES|POLDIFF_DIFF_ROLE_ALLOWS|POLDIFF_DIFF_ROLE_TRANS)
+#define POLDIFF_DIFF_RBAC (POLDIFF_DIFF_ROLES|POLDIFF_DIFF_ROLE_ALLOWS|POLDIFF_DIFF_ROLE_TRANS)
+#define POLDIFF_DIFF_MLS (POLDIFF_DIFF_LEVELS|POLDIFF_DIFF_CATS|POLDIFF_DIFF_RANGE_TRANS)
+/* NOTE: while defined OCONS are not currently supported */
+#define POLDIFF_DIFF_OCONS 0
+#define POLDIFF_DIFF_REMAPPED (POLDIFF_DIFF_TYPES|POLDIFF_DIFF_ATTRIBS|POLDIFF_DIFF_AVRULES|POLDIFF_DIFF_TERULES|POLDIFF_DIFF_ROLES|POLDIFF_DIFF_ROLE_TRANS|POLDIFF_DIFF_RANGE_TRANS|POLDIFF_DIFF_OCONS)
+#define POLDIFF_DIFF_ALL (POLDIFF_DIFF_SYMBOLS|POLDIFF_DIFF_RULES|POLDIFF_DIFF_MLS|POLDIFF_DIFF_OCONS)
+
+%typemap(check) uint32_t flags {
+ if ($1 & ~(POLDIFF_DIFF_ALL)) {
+#ifdef SWIGJAVA
+ SWIG_exception_typemap(SWIG_ValueError, "Invalid diff flag specified");
+#else
+ SWIG_exception(SWIG_ValueError, "Invalid diff flag specified");
+#endif
+ }
+}
+
+%inline %{
+/* if java, pass the new exception macro to C not just SWIG */
+#ifdef SWIGJAVA
+#undef SWIG_exception
+#define SWIG_exception(code, msg) {SWIG_JavaException(jenv, code, msg); goto fail;}
+#endif
+%}
+
+/* poldiff form */
+typedef enum poldiff_form
+{
+ POLDIFF_FORM_NONE,
+ POLDIFF_FORM_ADDED,
+ POLDIFF_FORM_REMOVED,
+ POLDIFF_FORM_MODIFIED,
+ POLDIFF_FORM_ADD_TYPE,
+ POLDIFF_FORM_REMOVE_TYPE
+} poldiff_form_e;
+
+/* for handling the get_stats function */
+%{
+ typedef struct poldiff_stats {
+ size_t stats[5];
+ } poldiff_stats_t;
+ poldiff_stats_t *poldiff_stats_create() {
+ return calloc(1, sizeof(poldiff_stats_t));
+ }
+ void poldiff_stats_destroy(poldiff_stats_t **x) {
+ if (!x || !(*x))
+ return;
+ free(*x);
+ *x = NULL;
+ }
+%}
+typedef struct poldiff_stats {} poldiff_stats_t;
+%extend poldiff_stats_t {
+ poldiff_stats_t() {
+ poldiff_stats_t *s;
+ BEGIN_EXCEPTION
+ s = poldiff_stats_create();
+ if (!s) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ }
+ END_EXCEPTION
+ fail:
+ return s;
+ };
+ ~poldiff_stats_t() {
+ poldiff_stats_destroy(&self);
+ };
+ size_t get_stat(poldiff_form_e form) {
+ BEGIN_EXCEPTION
+ switch(form) {
+ case POLDIFF_FORM_ADDED:
+ {
+ return self->stats[0];
+ }
+ case POLDIFF_FORM_REMOVED:
+ {
+ return self->stats[1];
+ }
+ case POLDIFF_FORM_MODIFIED:
+ {
+ return self->stats[2];
+ }
+ case POLDIFF_FORM_ADD_TYPE:
+ {
+ return self->stats[3];
+ }
+ case POLDIFF_FORM_REMOVE_TYPE:
+ {
+ return self->stats[4];
+ }
+ case POLDIFF_FORM_NONE:
+ default:
+ {
+ SWIG_exception(SWIG_ValueError, "Invalid poldiff form");
+ }
+ }
+ END_EXCEPTION
+ fail:
+ return 0;
+ };
+};
+
+/* for handling vector of line numbers stored as unsigned long but returned as void* */
+%{
+ unsigned long to_ulong(void *x) {
+ return (unsigned long)x;
+ }
+%}
+unsigned long to_ulong(void *x);
+
+/* poldiff object */
+#ifdef SWIGPYTHON
+/* the following type maps handle the poldiff object taking ownership of the policies */
+%typemap(in) apol_policy_t *op {
+ void *x = NULL;
+ Py_IncRef($input);
+ SWIG_ConvertPtr($input, &x,SWIGTYPE_p_apol_policy, 0 | 0 );
+ $1 = (apol_policy_t*)x;
+}
+%typemap(in) apol_policy_t *mp {
+ void *x = NULL;
+ Py_IncRef($input);
+ SWIG_ConvertPtr($input, &x,SWIGTYPE_p_apol_policy, 0 | 0 );
+ $1 = (apol_policy_t*)x;
+}
+#endif
+typedef struct poldiff {} poldiff_t;
+%extend poldiff_t {
+ poldiff_t(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);
+ if (!p) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ }
+ END_EXCEPTION
+ return p;
+ fail:
+ return NULL;
+ };
+ ~poldiff_t() {
+ poldiff_destroy(&self);
+ };
+ void run(uint32_t flags) {
+ BEGIN_EXCEPTION
+ if (poldiff_run(self, flags)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not run diff");
+ }
+ END_EXCEPTION
+ fail:
+ return;
+ };
+ int 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 *s = NULL;
+ BEGIN_EXCEPTION
+ s = poldiff_stats_create();
+ if (!s) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ }
+ if (poldiff_get_stats(self, flags, s->stats)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not get stats");
+ }
+ END_EXCEPTION
+ return s;
+ fail:
+ poldiff_stats_destroy(&s);
+ return NULL;
+ };
+ void enable_line_numbers() {
+ BEGIN_EXCEPTION
+ if (poldiff_enable_line_numbers(self)) {
+ SWIG_exception(SWIG_RuntimeError, "Could not enable line numbers");
+ }
+ END_EXCEPTION
+ fail:
+ return;
+ };
+ const apol_vector_t *get_attrib_vector() {
+ return poldiff_get_attrib_vector(self);
+ };
+ const apol_vector_t *get_avrule_vector_allow() {
+ return poldiff_get_avrule_vector_allow(self);
+ };
+ const apol_vector_t *get_avrule_vector_auditallow() {
+ return poldiff_get_avrule_vector_auditallow(self);
+ };
+ const apol_vector_t *get_avrule_vector_dontaudit() {
+ return poldiff_get_avrule_vector_dontaudit(self);
+ };
+ const apol_vector_t *get_avrule_vector_neverallow() {
+ return poldiff_get_avrule_vector_neverallow(self);
+ };
+ const apol_vector_t *get_bool_vector() {
+ return poldiff_get_bool_vector(self);
+ };
+ const apol_vector_t *get_cat_vector() {
+ return poldiff_get_cat_vector(self);
+ };
+ const apol_vector_t *get_class_vector() {
+ return poldiff_get_class_vector(self);
+ };
+ const apol_vector_t *get_common_vector() {
+ return poldiff_get_common_vector(self);
+ };
+ const apol_vector_t *get_level_vector() {
+ return poldiff_get_level_vector(self);
+ };
+ const apol_vector_t *get_range_trans_vector() {
+ return poldiff_get_range_trans_vector(self);
+ };
+ const apol_vector_t *get_role_allow_vector() {
+ return poldiff_get_role_allow_vector(self);
+ };
+ const apol_vector_t *get_role_trans_vector() {
+ return poldiff_get_role_trans_vector(self);
+ };
+ const apol_vector_t *get_role_vector() {
+ return poldiff_get_role_vector(self);
+ };
+ const apol_vector_t *get_terule_vector_change() {
+ return poldiff_get_terule_vector_change(self);
+ };
+ const apol_vector_t *get_terule_vector_member() {
+ return poldiff_get_terule_vector_member(self);
+ };
+ const apol_vector_t *get_terule_vector_trans() {
+ return poldiff_get_terule_vector_trans(self);
+ };
+ const apol_vector_t *get_type_vector() {
+ return poldiff_get_type_vector(self);
+ };
+ const apol_vector_t *get_user_vector() {
+ return poldiff_get_user_vector(self);
+ };
+ const apol_vector_t *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) {
+ 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");
+ }
+ END_EXCEPTION
+ fail:
+ return;
+ };
+ void type_remap_remove(poldiff_type_remap_entry_t *ent) {
+ poldiff_type_remap_entry_remove(self, ent);
+ };
+};
+
+/* attribute diff */
+typedef struct poldiff_attrib {} poldiff_attrib_t;
+%extend poldiff_attrib_t {
+ poldiff_attrib_t () {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_attrib_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+ ~poldiff_attrib_t() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+ char *to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_attrib_to_string(p, self);
+ if (!str) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ }
+ END_EXCEPTION
+ fail:
+ return str;
+ };
+ const char *get_name() {
+ return poldiff_attrib_get_name(self);
+ };
+ poldiff_form_e get_form() {
+ return poldiff_attrib_get_form(self);
+ };
+ const apol_string_vector_t *get_added_types() {
+ return (apol_string_vector_t*)poldiff_attrib_get_added_types(self);
+ };
+ const apol_string_vector_t *get_removed_types() {
+ return (apol_string_vector_t*)poldiff_attrib_get_removed_types(self);
+ };
+};
+%inline %{
+ poldiff_attrib_t *poldiff_attrib_from_void(void *x) {
+ return (poldiff_attrib_t*)x;
+ };
+%}
+
+/* av rule diff */
+typedef struct poldiff_avrule {} poldiff_avrule_t;
+%extend poldiff_avrule_t {
+ poldiff_avrule_t() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_avrule_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+ ~poldiff_avrule_t() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+ char *to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_avrule_to_string(p, self);
+ if (!str) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ }
+ END_EXCEPTION
+ fail:
+ return str;
+ };
+ poldiff_form_e get_form() {
+ return poldiff_avrule_get_form(self);
+ };
+ uint32_t get_rule_type() {
+ return poldiff_avrule_get_rule_type(self);
+ };
+ const char *get_source_type() {
+ return poldiff_avrule_get_source_type(self);
+ };
+ const char *get_target_type() {
+ return poldiff_avrule_get_target_type(self);
+ };
+ const char *get_object_class() {
+ return poldiff_avrule_get_object_class(self);
+ };
+ const qpol_cond_t *get_cond(poldiff_t *p) {
+ const qpol_cond_t *cond;
+ uint32_t which_list;
+ const apol_policy_t *which_pol;
+ poldiff_avrule_get_cond(p, self, &cond, &which_list, &which_pol);
+ return cond;
+ };
+ uint32_t get_cond_list(poldiff_t *p) {
+ const qpol_cond_t *cond;
+ uint32_t which_list;
+ const apol_policy_t *which_pol;
+ poldiff_avrule_get_cond(p, self, &cond, &which_list, &which_pol);
+ return which_list;
+ };
+ const apol_policy_t *get_cond_policy(poldiff_t *p) {
+ const qpol_cond_t *cond;
+ uint32_t which_list;
+ const apol_policy_t *which_pol;
+ poldiff_avrule_get_cond(p, self, &cond, &which_list, &which_pol);
+ return which_pol;
+ };
+ const apol_string_vector_t *get_unmodified_perms() {
+ return (apol_string_vector_t*)poldiff_avrule_get_unmodified_perms(self);
+ };
+ const apol_string_vector_t *get_added_perms() {
+ return (apol_string_vector_t*)poldiff_avrule_get_added_perms(self);
+ };
+ const apol_string_vector_t *get_removed_perms() {
+ return (apol_string_vector_t*)poldiff_avrule_get_removed_perms(self);
+ };
+ const apol_vector_t *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 *v;
+ BEGIN_EXCEPTION
+ v = poldiff_avrule_get_orig_line_numbers_for_perm(p, self, perm);
+ if (!v) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ }
+ END_EXCEPTION
+ fail:
+ return v;
+ };
+ const apol_vector_t *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 *v;
+ BEGIN_EXCEPTION
+ v = poldiff_avrule_get_mod_line_numbers_for_perm(p, self, perm);
+ if (!v) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ }
+ END_EXCEPTION
+ fail:
+ return v;
+ };
+};
+%inline %{
+ poldiff_avrule_t *poldiff_avrule_from_void(void *x) {
+ return (poldiff_avrule_t*)x;
+ };
+%}
+
+/* boolean diff */
+typedef struct poldiff_bool {} poldiff_bool_t;
+%extend poldiff_bool_t {
+ poldiff_bool_t() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_bool_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+ ~poldiff_bool_t() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+ char *to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_bool_to_string(p, self);
+ if (!str) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ }
+ END_EXCEPTION
+ fail:
+ return str;
+ };
+ const char *get_name() {
+ return poldiff_bool_get_name(self);
+ };
+ poldiff_form_e get_form() {
+ return poldiff_bool_get_form(self);
+ };
+};
+%inline %{
+ poldiff_bool_t *poldiff_bool_from_void(void *x) {
+ return (poldiff_bool_t*)x;
+ };
+%}
+
+/* category diff */
+typedef struct poldiff_cat {} poldiff_cat_t;
+%extend poldiff_cat_t {
+ poldiff_cat_t() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_cat_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+ ~poldiff_cat_t() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+ char *to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_cat_to_string(p, self);
+ if (!str) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ }
+ END_EXCEPTION
+ fail:
+ return str;
+ };
+ const char *get_name() {
+ return poldiff_cat_get_name(self);
+ };
+ poldiff_form_e get_form() {
+ return poldiff_cat_get_form(self);
+ };
+};
+%inline %{
+ poldiff_cat_t *poldiff_cat_from_void(void *x) {
+ return (poldiff_cat_t*)x;
+ };
+%}
+
+/* class diff */
+typedef struct poldiff_class {} poldiff_class_t;
+%extend poldiff_class_t {
+ poldiff_class_t() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_class_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+ ~poldiff_class_t() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+ char *to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_class_to_string(p, self);
+ if (!str) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ }
+ END_EXCEPTION
+ fail:
+ return str;
+ };
+ const char *get_name() {
+ return poldiff_class_get_name(self);
+ };
+ poldiff_form_e get_form() {
+ return poldiff_class_get_form(self);
+ };
+ const apol_string_vector_t *get_added_perms() {
+ return (apol_string_vector_t*)poldiff_class_get_added_perms(self);
+ };
+ const apol_string_vector_t *get_removed_perms() {
+ return (apol_string_vector_t*)poldiff_class_get_removed_perms(self);
+ };
+};
+%inline %{
+ poldiff_class_t *poldiff_class_from_void(void *x) {
+ return (poldiff_class_t*)x;
+ };
+%}
+
+/* common diff */
+typedef struct poldiff_common {} poldiff_common_t;
+%extend poldiff_common_t {
+ poldiff_common_t() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_common_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+ ~poldiff_common_t() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+ char *to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_common_to_string(p, self);
+ if (!str) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ }
+ END_EXCEPTION
+ fail:
+ return str;
+ };
+ const char *get_name() {
+ return poldiff_common_get_name(self);
+ };
+ poldiff_form_e get_form() {
+ return poldiff_common_get_form(self);
+ };
+ const apol_string_vector_t *get_added_perms() {
+ return (apol_string_vector_t*)poldiff_common_get_added_perms(self);
+ };
+ const apol_string_vector_t *get_removed_perms() {
+ return (apol_string_vector_t*)poldiff_common_get_removed_perms(self);
+ };
+};
+%inline %{
+ poldiff_common_t *poldiff_common_from_void(void *x) {
+ return (poldiff_common_t*)x;
+ };
+%}
+
+/* level diff */
+typedef struct poldiff_level {} poldiff_level_t;
+%extend poldiff_level_t {
+ poldiff_level_t() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_level_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+ ~poldiff_level_t() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+ char *to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_level_to_string(p, self);
+ if (!str) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ }
+ END_EXCEPTION
+ fail:
+ return str;
+ };
+ %newobject to_string_brief(poldiff_t*);
+ char *to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_level_to_string_brief(p, self);
+ if (!str) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ }
+ END_EXCEPTION
+ fail:
+ return str;
+ };
+ const char *get_name() {
+ return poldiff_level_get_name(self);
+ };
+ poldiff_form_e get_form() {
+ return poldiff_level_get_form(self);
+ };
+ const apol_string_vector_t *get_unmodified_cats() {
+ return (apol_string_vector_t*)poldiff_level_get_unmodified_cats(self);
+ };
+ const apol_string_vector_t *get_added_cats() {
+ return (apol_string_vector_t*)poldiff_level_get_added_cats(self);
+ };
+ const apol_string_vector_t *get_removed_cats() {
+ return (apol_string_vector_t*)poldiff_level_get_removed_cats(self);
+ };
+};
+%inline %{
+ poldiff_level_t *poldiff_level_from_void(void *x) {
+ return (poldiff_level_t*)x;
+ };
+%}
+
+/* range diff */
+typedef struct poldiff_range {} poldiff_range_t;
+%extend poldiff_range_t {
+ poldiff_range_t() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_range_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+ ~poldiff_range_t() {
+ /* no op */
+ return;
+ };
+ %newobject to_string_brief(poldiff_t*);
+ char *to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_range_to_string_brief(p, self);
+ if (!str) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ }
+ END_EXCEPTION
+ fail:
+ return str;
+ };
+ const apol_vector_t *get_levels() {
+ return poldiff_range_get_levels(self);
+ };
+ const apol_mls_range_t *get_original_range() {
+ return poldiff_range_get_original_range(self);
+ };
+ const apol_mls_range_t *get_modified_range() {
+ return poldiff_range_get_modified_range(self);
+ };
+ const apol_string_vector_t *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() {
+ return (apol_string_vector_t*)poldiff_range_get_min_removed_cats(self);
+ };
+ const apol_string_vector_t *get_min_unmodified_cats() {
+ return (apol_string_vector_t*)poldiff_range_get_min_unmodified_cats(self);
+ };
+};
+%inline %{
+ poldiff_range_t *poldiff_range_from_void(void *x) {
+ return (poldiff_range_t*)x;
+ };
+%}
+
+/* range_transition rule diff */
+typedef struct poldiff_range_trans {} poldiff_range_trans_t;
+%extend poldiff_range_trans_t {
+ poldiff_range_trans_t() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_range_trans_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+ ~poldiff_range_trans_t() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+ char *to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_range_trans_to_string(p, self);
+ if (!str) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ }
+ END_EXCEPTION
+ fail:
+ return str;
+ };
+ poldiff_form_e get_form() {
+ return poldiff_range_trans_get_form(self);
+ };
+ const char *get_source_type() {
+ return poldiff_range_trans_get_source_type(self);
+ };
+ const char *get_target_type() {
+ return poldiff_range_trans_get_target_type(self);
+ };
+ const char *get_target_class() {
+ return poldiff_range_trans_get_target_class(self);
+ };
+ const poldiff_range_t *get_range() {
+ return poldiff_range_trans_get_range(self);
+ };
+};
+%inline %{
+ poldiff_range_trans_t *poldiff_range_trans_from_void(void *x) {
+ return (poldiff_range_trans_t *)x;
+ };
+%}
+
+/* role allow rule diff */
+typedef struct poldiff_role_allow {} poldiff_role_allow_t;
+%extend poldiff_role_allow_t {
+ poldiff_role_allow_t() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_role_allow_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+ ~poldiff_role_allow_t() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+ char *to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_role_allow_to_string(p, self);
+ if (!str) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ }
+ END_EXCEPTION
+ fail:
+ return str;
+ };
+ const char *get_name() {
+ return poldiff_role_allow_get_name(self);
+ };
+ poldiff_form_e get_form() {
+ return poldiff_role_allow_get_form(self);
+ };
+ const apol_string_vector_t *get_unmodified_roles() {
+ return (apol_string_vector_t*)poldiff_role_allow_get_unmodified_roles(self);
+ };
+ const apol_string_vector_t *get_added_roles() {
+ return (apol_string_vector_t*)poldiff_role_allow_get_added_roles(self);
+ };
+ const apol_string_vector_t *get_removed_roles() {
+ return (apol_string_vector_t*)poldiff_role_allow_get_removed_roles(self);
+ };
+};
+%inline %{
+ poldiff_role_allow_t *poldiff_role_allow_from_void(void *x) {
+ return (poldiff_role_allow_t *)x;
+ };
+%}
+
+/* role_transition rule diff */
+typedef struct poldiff_role_trans {} poldiff_role_trans_t;
+%extend poldiff_role_trans_t {
+ poldiff_role_trans_t() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_role_trans_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+ ~poldiff_role_trans_t() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+ char *to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_role_trans_to_string(p, self);
+ if (!str) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ }
+ END_EXCEPTION
+ fail:
+ return str;
+ };
+ poldiff_form_e get_form() {
+ return poldiff_role_trans_get_form(self);
+ };
+ const char *get_source_role() {
+ return poldiff_role_trans_get_source_role(self);
+ };
+ const char *get_target_type() {
+ return poldiff_role_trans_get_target_type(self);
+ };
+ const char *get_original_default() {
+ return poldiff_role_trans_get_original_default(self);
+ };
+ const char *get_modified_default() {
+ return poldiff_role_trans_get_modified_default(self);
+ };
+};
+%inline %{
+ poldiff_role_trans_t *poldiff_role_trans_from_void(void *x) {
+ return (poldiff_role_trans_t *)x;
+ };
+%}
+
+/* role diff */
+typedef struct poldiff_role {} poldiff_role_t;
+%extend poldiff_role_t {
+ poldiff_role_t() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_role_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+ ~poldiff_role_t() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+ char *to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_role_to_string(p, self);
+ if (!str) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ }
+ END_EXCEPTION
+ fail:
+ return str;
+ };
+ const char *get_name() {
+ return poldiff_role_get_name(self);
+ };
+ poldiff_form_e get_form() {
+ return poldiff_role_get_form(self);
+ };
+ const apol_string_vector_t *get_added_types() {
+ return (apol_string_vector_t*)poldiff_role_get_added_types(self);
+ };
+ const apol_string_vector_t *get_removed_types() {
+ return (apol_string_vector_t*)poldiff_role_get_removed_types(self);
+ };
+};
+%inline %{
+ poldiff_role_t *poldiff_role_from_void(void *x) {
+ return (poldiff_role_t*)x;
+ };
+%}
+
+/* te rule diff */
+typedef struct poldiff_terule {} poldiff_terule_t;
+%extend poldiff_terule_t {
+ poldiff_terule_t() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_terule_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+ ~poldiff_terule_t() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+ char *to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_terule_to_string(p, self);
+ if (!str) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ }
+ END_EXCEPTION
+ fail:
+ return str;
+ };
+ poldiff_form_e get_form() {
+ return poldiff_terule_get_form(self);
+ };
+ uint32_t get_rule_type() {
+ return poldiff_terule_get_rule_type(self);
+ };
+ const char *get_source_type() {
+ return poldiff_terule_get_source_type(self);
+ };
+ const char *get_target_type() {
+ return poldiff_terule_get_target_type(self);
+ };
+ const char *get_object_class() {
+ return poldiff_terule_get_object_class(self);
+ };
+ const qpol_cond_t *get_cond(poldiff_t *p) {
+ const qpol_cond_t *cond;
+ uint32_t which_list;
+ const apol_policy_t *which_pol;
+ poldiff_terule_get_cond(p, self, &cond, &which_list, &which_pol);
+ return cond;
+ };
+ uint32_t get_cond_list(poldiff_t *p) {
+ const qpol_cond_t *cond;
+ uint32_t which_list;
+ const apol_policy_t *which_pol;
+ poldiff_terule_get_cond(p, self, &cond, &which_list, &which_pol);
+ return which_list;
+ };
+ const apol_policy_t *get_cond_policy(poldiff_t *p) {
+ const qpol_cond_t *cond;
+ uint32_t which_list;
+ const apol_policy_t *which_pol;
+ poldiff_terule_get_cond(p, self, &cond, &which_list, &which_pol);
+ return which_pol;
+ };
+ const char *get_original_default() {
+ return poldiff_terule_get_original_default(self);
+ };
+ const char *get_modified_default() {
+ return poldiff_terule_get_modified_default(self);
+ };
+ const apol_vector_t *get_orig_line_numbers() {
+ return poldiff_terule_get_orig_line_numbers(self);
+ };
+ const apol_vector_t *get_mod_line_numbers() {
+ return poldiff_terule_get_mod_line_numbers(self);
+ };
+};
+%inline %{
+ poldiff_terule_t *poldiff_terule_from_void(void *x) {
+ return (poldiff_terule_t*)x;
+ };
+%}
+
+/* type diff */
+typedef struct poldiff_type {} poldiff_type_t;
+%extend poldiff_type_t {
+ poldiff_type_t() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_type_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+ ~poldiff_type_t() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+ char *to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_type_to_string(p, self);
+ if (!str) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ }
+ END_EXCEPTION
+ fail:
+ return str;
+ };
+ const char *get_name() {
+ return poldiff_type_get_name(self);
+ };
+ poldiff_form_e get_form() {
+ return poldiff_type_get_form(self);
+ };
+ const apol_string_vector_t *get_added_attribs() {
+ return (apol_string_vector_t*)poldiff_type_get_added_attribs(self);
+ };
+ const apol_string_vector_t *get_removed_attribs() {
+ return (apol_string_vector_t*)poldiff_type_get_removed_attribs(self);
+ };
+};
+%inline %{
+ poldiff_type_t *poldiff_type_from_void(void *x) {
+ return (poldiff_type_t*)x;
+ };
+%}
+
+/* user diff */
+typedef struct poldiff_user {} poldiff_user_t;
+%extend poldiff_user_t {
+ poldiff_user_t() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_user_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+ ~poldiff_user_t() {
+ /* no op */
+ return;
+ };
+ %newobject to_string(poldiff_t*);
+ char *to_string(poldiff_t *p) {
+ char *str;
+ BEGIN_EXCEPTION
+ str = poldiff_user_to_string(p, self);
+ if (!str) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ }
+ END_EXCEPTION
+ fail:
+ return str;
+ };
+ const char *get_name() {
+ return poldiff_user_get_name(self);
+ };
+ poldiff_form_e get_form() {
+ return poldiff_user_get_form(self);
+ };
+ const apol_string_vector_t *get_unmodified_roles() {
+ return (apol_string_vector_t*)poldiff_user_get_unmodified_roles(self);
+ };
+ const apol_string_vector_t *get_added_roles() {
+ return (apol_string_vector_t*)poldiff_user_get_added_roles(self);
+ };
+ const apol_string_vector_t *get_removed_roles() {
+ return (apol_string_vector_t*)poldiff_user_get_removed_roles(self);
+ };
+ const poldiff_level_t *get_original_dfltlevel() {
+ return poldiff_user_get_original_dfltlevel(self);
+ };
+ const poldiff_level_t *get_modified_dfltlevel() {
+ return poldiff_user_get_modified_dfltlevel(self);
+ };
+ const poldiff_range_t *get_range() {
+ return poldiff_user_get_range(self);
+ };
+};
+%inline %{
+ poldiff_user_t *poldiff_user_from_void(void *x) {
+ return (poldiff_user_t*)x;
+ };
+%}
+
+/* type remap */
+typedef struct poldiff_type_remap_entry {} poldiff_type_remap_entry_t;
+%extend poldiff_type_remap_entry_t {
+ poldiff_type_remap_entry_t() {
+ BEGIN_EXCEPTION
+ SWIG_exception(SWIG_RuntimeError, "Cannot directly create poldiff_type_remap_entry_t objects");
+ END_EXCEPTION
+ fail:
+ return NULL;
+ }
+ ~poldiff_type_remap_entry_t() {
+ /* no op */
+ return;
+ };
+ %newobject get_original_types(poldiff_t*);
+ apol_string_vector_t *get_original_types(poldiff_t *p) {
+ apol_vector_t *v;
+ BEGIN_EXCEPTION
+ v = poldiff_type_remap_entry_get_original_types(p, self);
+ if (!v) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ }
+ END_EXCEPTION
+ fail:
+ return (apol_string_vector_t*)v;
+ };
+ %newobject get_modified_types(poldiff_t*);
+ apol_string_vector_t *get_modified_types(poldiff_t *p) {
+ apol_vector_t *v;
+ BEGIN_EXCEPTION
+ v = poldiff_type_remap_entry_get_modified_types(p, self);
+ if (!v) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ }
+ END_EXCEPTION
+ fail:
+ return (apol_string_vector_t*)v;
+ };
+ int get_is_inferred() {
+ return poldiff_type_remap_entry_get_is_inferred(self);
+ };
+ int get_is_enabled() {
+ return poldiff_type_remap_entry_get_is_enabled(self);
+ };
+ void set_enabled(int enable) {
+ poldiff_type_remap_entry_set_enabled(self, enable);
+ };
+};
+%inline %{
+ poldiff_type_remap_entry_t *poldiff_type_remap_entry_from_void(void *x) {
+ return (poldiff_type_remap_entry_t*)x;
+ };
+%}
+