From 47be9ff57e72906660bb62a515222f482131e1fb Mon Sep 17 00:00:00 2001 From: Miroslav Grepl Date: Fri, 11 Apr 2014 09:37:53 +0200 Subject: Create setools-3.3.7 git repo --- libpoldiff/swig/poldiff.i | 1335 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1335 insertions(+) create mode 100644 libpoldiff/swig/poldiff.i (limited to 'libpoldiff/swig/poldiff.i') 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* 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; + }; +%} + -- cgit