diff options
Diffstat (limited to 'libqpol/swig/qpol.i')
| -rw-r--r-- | libqpol/swig/qpol.i | 2879 |
1 files changed, 2879 insertions, 0 deletions
diff --git a/libqpol/swig/qpol.i b/libqpol/swig/qpol.i new file mode 100644 index 0000000..45a2403 --- /dev/null +++ b/libqpol/swig/qpol.i @@ -0,0 +1,2879 @@ +/** + * SWIG declarations for libqpol. + * + * @author Jeremy A. Mowery jmowery@tresys.com + * @author Jason Tang jtang@tresys.com + * + * Copyright (C) 2006-2008 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 qpol + +%{ +#include "../include/qpol/avrule_query.h" +#include "../include/qpol/bool_query.h" +#include "../include/qpol/class_perm_query.h" +#include "../include/qpol/cond_query.h" +#include "../include/qpol/constraint_query.h" +#include "../include/qpol/context_query.h" +#include "../include/qpol/fs_use_query.h" +#include "../include/qpol/genfscon_query.h" +#include "../include/qpol/isid_query.h" +#include "../include/qpol/iterator.h" +#include "../include/qpol/mls_query.h" +#include "../include/qpol/mlsrule_query.h" +#include "../include/qpol/module.h" +#include "../include/qpol/netifcon_query.h" +#include "../include/qpol/nodecon_query.h" +#include "../include/qpol/policy.h" +#include "../include/qpol/policy_extend.h" +#include "../include/qpol/portcon_query.h" +#include "../include/qpol/rbacrule_query.h" +#include "../include/qpol/role_query.h" +#include "../include/qpol/syn_rule_query.h" +#include "../include/qpol/terule_query.h" +#include "../include/qpol/type_query.h" +#include "../include/qpol/user_query.h" +#include "../include/qpol/util.h" + +/* Provide hooks so that language-specific modules can define the + * callback function, used by the handler in + * qpol_policy_open_from_file(). + */ +SWIGEXPORT qpol_callback_fn_t qpol_swig_message_callback = NULL; +SWIGEXPORT void * qpol_swig_message_callback_arg = NULL; + +%} + +#ifdef SWIGJAVA +%javaconst(1); +/* get the java environment so we can throw exceptions */ +%{ + static JNIEnv *qpol_global_jenv; + jint JNI_OnLoad(JavaVM *vm, void *reserved) { + (*vm)->AttachCurrentThread(vm, (void **)&qpol_global_jenv, NULL); + return JNI_VERSION_1_2; + } +%} +#endif + +%include exception.i +%include stdint.i + +%{ +#undef BEGIN_EXCEPTION +#undef END_EXCEPTION +%} + +#ifdef SWIGJAVA + +%exception { + qpol_global_jenv = jenv; + $action +} + +%{ +#define BEGIN_EXCEPTION JNIEnv *local_jenv = qpol_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(javabody) SWIGTYPE, void* %{ + 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; + } +%} +%pragma(java) jniclasscode=%{ + static { + try + { + libqpol_get_version(); + } + catch (UnsatisfiedLinkError ule) + { + System.loadLibrary("jqpol"); + } + } +%} + +#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 + +/* utility functions */ +const char *libqpol_get_version(void); + +%rename(qpol_default_policy_find) wrap_qpol_default_policy_find; +%newobject wrap_qpol_default_policy_find(); + +/* if java, pass the new exception macro to C not just SWIG */ +#ifdef SWIGJAVA +#undef SWIG_exception +#define SWIG_exception(code, msg) {SWIG_JavaException(local_jenv, code, msg); goto fail;} +%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 + * Qpol_Init(), but the output file will be called libtqpol.so instead + * of libqpol.so. Therefore add an alias from Tqpol_Init() to the + * real Qpol_Init(). + */ +SWIGEXPORT int Tqpol_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 %{ + /* cast void * to char * as it can't have a constructor */ + const char * to_str(void *x) { + return (const char *)x; + } + + char * wrap_qpol_default_policy_find() { + char *path; + int retv; + BEGIN_EXCEPTION + retv = qpol_default_policy_find(&path); + if (retv < 0) { + SWIG_exception(SWIG_IOError, "Error searching for default policy"); + } else if (retv > 0) { + SWIG_exception(SWIG_RuntimeError, "Could not find default policy"); + } else { + return path; + } + END_EXCEPTION + fail: /* SWIG_exception calls goto fail */ + return NULL; + } +%} + +/* qpol_module */ +#define QPOL_MODULE_UNKNOWN 0 +#define QPOL_MODULE_BASE 1 +#define QPOL_MODULE_OTHER 2 +typedef struct qpol_module {} qpol_module_t; +%extend qpol_module_t { + qpol_module_t(const char *path) { + qpol_module_t *m; + BEGIN_EXCEPTION + if (qpol_module_create_from_file(path, &m)) { + SWIG_exception(SWIG_IOError, "Error opening module"); + } + return m; + END_EXCEPTION + fail: + return NULL; + }; + ~qpol_module_t() { + qpol_module_destroy(&self); + }; + const char *get_path() { + const char *p; + BEGIN_EXCEPTION + if (qpol_module_get_path(self, &p)) { + SWIG_exception(SWIG_ValueError,"Could not get module path"); + } + return p; + END_EXCEPTION + fail: + return NULL; + }; + const char *get_name() { + const char *n; + BEGIN_EXCEPTION + if (qpol_module_get_name(self, &n)) { + SWIG_exception(SWIG_ValueError,"Could not get module name"); + } + return n; + END_EXCEPTION + fail: + return NULL; + }; + const char *get_version() { + const char *v; + BEGIN_EXCEPTION + if (qpol_module_get_version(self, &v)) { + SWIG_exception(SWIG_ValueError,"Could not get module version"); + } + return v; + END_EXCEPTION + fail: + return NULL; + }; + int get_type() { + int t; + BEGIN_EXCEPTION + if (qpol_module_get_type(self, &t)) { + SWIG_exception(SWIG_ValueError,"Could not get module type"); + } + END_EXCEPTION + fail: + return t; + }; + int get_enabled() { + int e; + BEGIN_EXCEPTION + if (qpol_module_get_enabled(self, &e)) { + SWIG_exception(SWIG_ValueError,"Could not get module state"); + } + END_EXCEPTION + fail: + return e; + }; + void set_enabled(int state) { + BEGIN_EXCEPTION + if (qpol_module_set_enabled(self, state)) { + SWIG_exception(SWIG_RuntimeError, "Could not set module state"); + } + END_EXCEPTION + fail: + return; + }; +}; + +/* qpol_policy */ +#define QPOL_POLICY_OPTION_NO_NEVERALLOWS 0x00000001 +#define QPOL_POLICY_OPTION_NO_RULES 0x00000002 +#define QPOL_POLICY_OPTION_MATCH_SYSTEM 0x00000004 +typedef struct qpol_policy {} qpol_policy_t; +typedef void (*qpol_callback_fn_t) (void *varg, struct qpol_policy * policy, int level, const char *fmt, va_list va_args); +#define QPOL_POLICY_UNKNOWN -1 +#define QPOL_POLICY_KERNEL_SOURCE 0 +#define QPOL_POLICY_KERNEL_BINARY 1 +#define QPOL_POLICY_MODULE_BINARY 2 +typedef enum qpol_capability +{ + QPOL_CAP_ATTRIB_NAMES, + QPOL_CAP_SYN_RULES, + QPOL_CAP_LINE_NUMBERS, + QPOL_CAP_CONDITIONALS, + QPOL_CAP_MLS, + QPOL_CAP_MODULES, + QPOL_CAP_RULES_LOADED, + QPOL_CAP_SOURCE, + QPOL_CAP_NEVERALLOW +} qpol_capability_e; + +%extend qpol_policy_t { + qpol_policy_t(const char *path, const int options) { + qpol_policy_t *p; + BEGIN_EXCEPTION + if (qpol_policy_open_from_file(path, &p, qpol_swig_message_callback, qpol_swig_message_callback_arg, options) < 0) { + SWIG_exception(SWIG_IOError, "Error opening policy"); + } + END_EXCEPTION + return p; + fail: + return NULL; + } + ~qpol_policy_t() { + qpol_policy_destroy(&self); + }; + void reevaluate_conds() { + BEGIN_EXCEPTION + if (qpol_policy_reevaluate_conds(self)) { + SWIG_exception(SWIG_ValueError, "Error evaluating conditional expressions"); + } + END_EXCEPTION + fail: + return; + }; + void append_module(qpol_module_t *mod) { + BEGIN_EXCEPTION + if (qpol_policy_append_module(self, mod)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + END_EXCEPTION + fail: + return; + }; + void rebuild (const int options) { + BEGIN_EXCEPTION + if (qpol_policy_rebuild(self, options)) { + SWIG_exception(SWIG_RuntimeError, "Failed rebuilding policy"); + } + END_EXCEPTION + fail: + return; + }; + int get_version () { + unsigned int v; + (void)qpol_policy_get_policy_version(self, &v); /* only error is on null parameters neither can be here */ + return (int) v; + }; + int get_type () { + int t; + (void)qpol_policy_get_type(self, &t); /* only error is on null parameters neither can be here */ + return t; + }; + int has_capability (qpol_capability_e cap) { + return qpol_policy_has_capability(self, cap); + }; + void build_syn_rule_table() { + BEGIN_EXCEPTION + if (qpol_policy_build_syn_rule_table(self)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + END_EXCEPTION + fail: + return; + }; + %newobject get_module_iter(); + qpol_iterator_t *get_module_iter() { + BEGIN_EXCEPTION + qpol_iterator_t *iter; + if (qpol_policy_get_module_iter(self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + return iter; + END_EXCEPTION + fail: + return NULL; + }; + %newobject get_type_iter(); + qpol_iterator_t *get_type_iter() { + BEGIN_EXCEPTION + qpol_iterator_t *iter; + if (qpol_policy_get_type_iter(self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + return iter; + END_EXCEPTION + fail: + return NULL; + }; + %newobject get_role_iter(); + qpol_iterator_t *get_role_iter() { + BEGIN_EXCEPTION + qpol_iterator_t *iter; + if (qpol_policy_get_role_iter(self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + return iter; + END_EXCEPTION + fail: + return NULL; + }; + %newobject get_level_iter(); + qpol_iterator_t *get_level_iter() { + BEGIN_EXCEPTION + qpol_iterator_t *iter; + if (qpol_policy_get_level_iter(self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + return iter; + END_EXCEPTION + fail: + return NULL; + }; + %newobject get_cat_iter(); + qpol_iterator_t *get_cat_iter() { + BEGIN_EXCEPTION + qpol_iterator_t *iter; + if (qpol_policy_get_cat_iter(self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + return iter; + END_EXCEPTION + fail: + return NULL; + }; + %newobject get_user_iter(); + qpol_iterator_t *get_user_iter() { + BEGIN_EXCEPTION + qpol_iterator_t *iter; + if (qpol_policy_get_user_iter(self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + return iter; + END_EXCEPTION + fail: + return NULL; + }; + %newobject get_bool_iter(); + qpol_iterator_t *get_bool_iter() { + BEGIN_EXCEPTION + qpol_iterator_t *iter; + if (qpol_policy_get_bool_iter(self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + return iter; + END_EXCEPTION + fail: + return NULL; + }; + %newobject get_class_iter(char*); + qpol_iterator_t *get_class_iter(char *perm=NULL) { + BEGIN_EXCEPTION + qpol_iterator_t *iter; + if (perm) { + if (qpol_perm_get_class_iter(self, perm, &iter)) { + SWIG_exception(SWIG_RuntimeError, "Could not get class iterator"); + } + } else { + if (qpol_policy_get_class_iter(self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + } + return iter; + END_EXCEPTION + fail: + return NULL; + }; + %newobject get_common_iter(char*); + qpol_iterator_t *get_common_iter(char *perm=NULL) { + BEGIN_EXCEPTION + qpol_iterator_t *iter; + if (perm) { + if (qpol_perm_get_common_iter(self, perm, &iter)) { + SWIG_exception(SWIG_RuntimeError, "Could not get common iterator"); + } + } else { + if (qpol_policy_get_common_iter(self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + } + return iter; + END_EXCEPTION + fail: + return NULL; + }; + %newobject get_fs_use_iter(); + qpol_iterator_t *get_fs_use_iter() { + BEGIN_EXCEPTION + qpol_iterator_t *iter; + if (qpol_policy_get_fs_use_iter(self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + return iter; + END_EXCEPTION + fail: + return NULL; + }; + %newobject get_genfscon_iter(); + qpol_iterator_t *get_genfscon_iter() { + BEGIN_EXCEPTION + qpol_iterator_t *iter; + if (qpol_policy_get_genfscon_iter(self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + return iter; + END_EXCEPTION + fail: + return NULL; + }; + %newobject get_isid_iter(); + qpol_iterator_t *get_isid_iter() { + BEGIN_EXCEPTION + qpol_iterator_t *iter; + if (qpol_policy_get_isid_iter(self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + return iter; + END_EXCEPTION + fail: + return NULL; + }; + %newobject get_netifcon_iter(); + qpol_iterator_t *get_netifcon_iter() { + BEGIN_EXCEPTION + qpol_iterator_t *iter; + if (qpol_policy_get_netifcon_iter(self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + return iter; + END_EXCEPTION + fail: + return NULL; + }; + %newobject get_nodecon_iter(); + qpol_iterator_t *get_nodecon_iter() { + BEGIN_EXCEPTION + qpol_iterator_t *iter; + if (qpol_policy_get_nodecon_iter(self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + return iter; + END_EXCEPTION + fail: + return NULL; + }; + %newobject get_portcon_iter(); + qpol_iterator_t *get_portcon_iter() { + BEGIN_EXCEPTION + qpol_iterator_t *iter; + if (qpol_policy_get_portcon_iter(self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + return iter; + END_EXCEPTION + fail: + return NULL; + }; + %newobject get_constraint_iter(); + qpol_iterator_t *get_constraint_iter() { + BEGIN_EXCEPTION + qpol_iterator_t *iter; + if (qpol_policy_get_constraint_iter(self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + return iter; + END_EXCEPTION + fail: + return NULL; + }; + %newobject get_validatetrans_iter(); + qpol_iterator_t *get_validatetrans_iter() { + BEGIN_EXCEPTION + qpol_iterator_t *iter; + if (qpol_policy_get_validatetrans_iter(self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + return iter; + END_EXCEPTION + fail: + return NULL; + }; + %newobject get_role_allow_iter(); + qpol_iterator_t *get_role_allow_iter() { + BEGIN_EXCEPTION + qpol_iterator_t *iter; + if (qpol_policy_get_role_allow_iter(self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + return iter; + END_EXCEPTION + fail: + return NULL; + }; + %newobject get_role_trans_iter(); + qpol_iterator_t *get_role_trans_iter() { + BEGIN_EXCEPTION + qpol_iterator_t *iter; + if (qpol_policy_get_role_trans_iter(self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + return iter; + END_EXCEPTION + fail: + return NULL; + }; + %newobject get_range_trans_iter(); + qpol_iterator_t *get_range_trans_iter() { + BEGIN_EXCEPTION + qpol_iterator_t *iter; + if (qpol_policy_get_range_trans_iter(self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + return iter; + END_EXCEPTION + fail: + return NULL; + }; + %newobject get_avrule_iter(int); + qpol_iterator_t *get_avrule_iter(int rule_types) { + BEGIN_EXCEPTION + qpol_iterator_t *iter; + if (qpol_policy_get_avrule_iter(self, rule_types, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + return iter; + END_EXCEPTION + fail: + return NULL; + }; + %newobject get_terule_iter(int); + qpol_iterator_t *get_terule_iter(int rule_types) { + BEGIN_EXCEPTION + qpol_iterator_t *iter; + if (qpol_policy_get_terule_iter(self, rule_types, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + return iter; + END_EXCEPTION + fail: + return NULL; + }; + %newobject get_cond_iter(); + qpol_iterator_t *get_cond_iter() { + BEGIN_EXCEPTION + qpol_iterator_t *iter; + if (qpol_policy_get_cond_iter(self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + return iter; + END_EXCEPTION + fail: + return NULL; + }; +}; + +/* qpol iterator */ +typedef struct qpol_iterator {} qpol_iterator_t; +%extend qpol_iterator_t { + /* user never directly creates, but SWIG expects a constructor */ + qpol_iterator_t() { + BEGIN_EXCEPTION + SWIG_exception(SWIG_TypeError, "User may not create iterators difectly"); + END_EXCEPTION + fail: + return NULL; + }; + ~qpol_iterator_t() { + qpol_iterator_destroy(&self); + }; + void *get_item() { + BEGIN_EXCEPTION + void *i; + if (qpol_iterator_get_item(self, &i)) { + SWIG_exception(SWIG_RuntimeError, "Could not get item"); + } + return i; + END_EXCEPTION + fail: + return NULL; + }; + void next() { + BEGIN_EXCEPTION + if (qpol_iterator_next(self)) { + SWIG_exception(SWIG_RuntimeError, "Error advancing iterator"); + } + END_EXCEPTION + fail: + return; + }; + int end() { + return qpol_iterator_end(self); + }; + size_t get_size() { + BEGIN_EXCEPTION + size_t s; + if (qpol_iterator_get_size(self, &s)) { + SWIG_exception(SWIG_ValueError, "Could not get iterator size"); + } + return s; + END_EXCEPTION + fail: + return 0; + }; +}; + +/* qpol type */ +typedef struct qpol_type {} qpol_type_t; +%extend qpol_type_t { + qpol_type_t(qpol_policy_t *p, const char *name) { + BEGIN_EXCEPTION + const qpol_type_t *t; + if (qpol_policy_get_type_by_name(p, name, &t)) { + SWIG_exception(SWIG_RuntimeError, "Type does not exist"); + } + return (qpol_type_t*)t; + END_EXCEPTION + fail: + return NULL; + }; + ~qpol_type_t() { + /* no op */ + return; + }; + const char *get_name(qpol_policy_t *p) { + BEGIN_EXCEPTION + const char *name; + if (qpol_type_get_name(p, self, &name)) { + SWIG_exception(SWIG_ValueError, "Could not get type name"); + } + return name; + END_EXCEPTION + fail: + return NULL; + }; + int get_value(qpol_policy_t *p) { + uint32_t v; + BEGIN_EXCEPTION + if (qpol_type_get_value(p, self, &v)) { + SWIG_exception(SWIG_ValueError, "Could not get type value"); + } + END_EXCEPTION + fail: + return (int) v; + }; + int get_isalias(qpol_policy_t *p) { + unsigned char i; + BEGIN_EXCEPTION + if (qpol_type_get_isalias(p, self, &i)) { + SWIG_exception(SWIG_ValueError, "Could not determine whether type is an alias"); + } + END_EXCEPTION + fail: + return (int)i; + }; + int get_isattr(qpol_policy_t *p) { + unsigned char i; + BEGIN_EXCEPTION + if (qpol_type_get_isattr(p, self, &i)) { + SWIG_exception(SWIG_ValueError, "Could not determine whether type is an attribute"); + } + END_EXCEPTION + fail: + return (int)i; + }; + int get_ispermissive(qpol_policy_t *p) { + unsigned char i; + BEGIN_EXCEPTION + if (qpol_type_get_ispermissive(p, self, &i)) { + SWIG_exception(SWIG_ValueError, "Could not determine whether type is permissive"); + } + END_EXCEPTION + fail: + return (int)i; + }; + %newobject get_type_iter(qpol_policy_t*); + qpol_iterator_t *get_type_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + int retv = qpol_type_get_type_iter(p, self, &iter); + if (retv < 0) { + SWIG_exception(SWIG_RuntimeError, "Could not get attribute types"); + } else if (retv > 0) { + SWIG_exception(SWIG_TypeError, "Type is not an attribute"); + } + END_EXCEPTION + fail: + return iter; + }; + %newobject get_attr_iter(qpol_policy_t*); + qpol_iterator_t *get_attr_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + int retv = qpol_type_get_attr_iter(p, self, &iter); + if (retv < 0) { + SWIG_exception(SWIG_RuntimeError, "Could not get type attributes"); + } else if (retv > 0) { + SWIG_exception(SWIG_TypeError, "Type is an attribute"); + } + END_EXCEPTION + fail: + return iter; + }; + %newobject get_alias_iter(qpol_policy_t*); + qpol_iterator_t *get_alias_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_type_get_alias_iter(p, self, &iter)) { + SWIG_exception(SWIG_RuntimeError, "Could not get type aliases"); + } + END_EXCEPTION + fail: + return iter; + }; + }; +%inline %{ + qpol_type_t *qpol_type_from_void(void *x) { + return (qpol_type_t*)x; + }; +%} + +/* qpol role */ +typedef struct qpol_role {} qpol_role_t; +%extend qpol_role_t { + qpol_role_t(qpol_policy_t *p, const char *name) { + const qpol_role_t *r; + BEGIN_EXCEPTION + if (qpol_policy_get_role_by_name(p, name, &r)) { + SWIG_exception(SWIG_RuntimeError, "Role does not exist"); + } + END_EXCEPTION + return (qpol_role_t*)r; + fail: + return NULL; + }; + ~qpol_role_t() { + /* no op */ + return; + }; + int get_value (qpol_policy_t *p) { + uint32_t v; + BEGIN_EXCEPTION + if (qpol_role_get_value(p, self, &v)) { + SWIG_exception(SWIG_ValueError, "Could not get role value"); + } + END_EXCEPTION + fail: + return (int) v; + }; + const char *get_name(qpol_policy_t *p) { + const char *name; + BEGIN_EXCEPTION + if (qpol_role_get_name(p, self, &name)) { + SWIG_exception(SWIG_ValueError, "Could not get role name"); + } + END_EXCEPTION + return name; + fail: + return NULL; + }; + %newobject get_type_iter(qpol_policy_t*); + qpol_iterator_t *get_type_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_role_get_type_iter(p, self, &iter)) { + SWIG_exception(SWIG_RuntimeError, "Could not get role types"); + } + END_EXCEPTION + fail: + return iter; + }; + %newobject get_dominate_iter(qpol_policy_t*); + qpol_iterator_t *get_dominate_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_role_get_dominate_iter(p, self, &iter)) { + SWIG_exception(SWIG_RuntimeError, "Could not get dominated roles"); + } + END_EXCEPTION + fail: + return iter; + }; +}; +%inline %{ + qpol_role_t *qpol_role_from_void(void *x) { + return (qpol_role_t*)x; + }; +%} + +/* qpol level */ +typedef struct qpol_level {} qpol_level_t; +%extend qpol_level_t { + qpol_level_t(qpol_policy_t *p, const char *name) { + const qpol_level_t *l; + BEGIN_EXCEPTION + if (qpol_policy_get_level_by_name(p, name, &l)) { + SWIG_exception(SWIG_RuntimeError, "Level does not exist"); + } + END_EXCEPTION + return (qpol_level_t*)l; + fail: + return NULL; + }; + ~qpol_level_t() { + /* no op */ + return; + }; + int get_isalias(qpol_policy_t *p) { + unsigned char i; + BEGIN_EXCEPTION + if (qpol_level_get_isalias(p, self, &i)) { + SWIG_exception(SWIG_ValueError, "Could not determine whether level is an alias"); + } + END_EXCEPTION + fail: + return (int)i; + }; + int get_value(qpol_policy_t *p) { + uint32_t v; + BEGIN_EXCEPTION + if (qpol_level_get_value(p, self, &v)) { + SWIG_exception(SWIG_ValueError, "Could not get level sensitivity value"); + } + END_EXCEPTION + fail: + return (int) v; + }; + const char *get_name(qpol_policy_t *p) { + const char *name; + BEGIN_EXCEPTION + if (qpol_level_get_name(p, self, &name)) { + SWIG_exception(SWIG_ValueError, "Could not get level sensitivity name"); + } + END_EXCEPTION + return name; + fail: + return NULL; + }; + %newobject get_cat_iter(qpol_policy_t*); + qpol_iterator_t *get_cat_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_level_get_cat_iter(p, self, &iter)) { + SWIG_exception(SWIG_RuntimeError, "Could not get level categories"); + } + END_EXCEPTION + fail: + return iter; + }; + %newobject get_alias_iter(qpol_policy_t*); + qpol_iterator_t *get_alias_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_level_get_alias_iter(p, self, &iter)) { + SWIG_exception(SWIG_RuntimeError, "Could not get level aliases"); + } + END_EXCEPTION + fail: + return iter; + }; +}; +%inline %{ + qpol_level_t *qpol_level_from_void(void *x) { + return (qpol_level_t*)x; + }; +%} + +/* qpol cat */ +typedef struct qpol_cat {} qpol_cat_t; +%extend qpol_cat_t { + qpol_cat_t(qpol_policy_t *p, const char *name) { + const qpol_cat_t *c; + BEGIN_EXCEPTION + if (qpol_policy_get_cat_by_name(p, name, &c)) { + SWIG_exception(SWIG_RuntimeError, "Category does not exist"); + } + END_EXCEPTION + return (qpol_cat_t*)c; + fail: + return NULL; + }; + ~qpol_cat_t() { + /* no op */ + return; + }; + int get_isalias(qpol_policy_t *p) { + unsigned char i; + BEGIN_EXCEPTION + if (qpol_cat_get_isalias(p, self, &i)) { + SWIG_exception(SWIG_ValueError, "Could not determine whether category is an alias"); + } + END_EXCEPTION + fail: + return (int)i; + }; + int get_value(qpol_policy_t *p) { + uint32_t v; + BEGIN_EXCEPTION + if (qpol_cat_get_value(p, self, &v)) { + SWIG_exception(SWIG_ValueError, "Could not get category value"); + } + END_EXCEPTION + fail: + return (int) v; + }; + const char *get_name(qpol_policy_t *p) { + const char *name; + BEGIN_EXCEPTION + if (qpol_cat_get_name(p, self, &name)) { + SWIG_exception(SWIG_ValueError, "Could not get category name"); + } + END_EXCEPTION + return name; + fail: + return NULL; + }; + %newobject get_alias_iter(qpol_policy_t*); + qpol_iterator_t *get_alias_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_cat_get_alias_iter(p, self, &iter)) { + SWIG_exception(SWIG_RuntimeError, "Could not get category aliases"); + } + END_EXCEPTION + fail: + return iter; + }; +}; +%inline %{ + qpol_cat_t *qpol_cat_from_void(void *x) { + return (qpol_cat_t*)x; + }; +%} + +/* qpol mls range */ +typedef struct qpol_mls_range {} qpol_mls_range_t; +%extend qpol_mls_range_t { + qpol_mls_range_t() { + BEGIN_EXCEPTION + SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_mls_range_t objects"); + END_EXCEPTION + fail: + return NULL; + } + ~qpol_mls_range_t() { + /* no op */ + return; + }; + const qpol_mls_level_t *get_high_level(qpol_policy_t *p) { + const qpol_mls_level_t *l; + BEGIN_EXCEPTION + if (qpol_mls_range_get_high_level(p, self, &l)) { + SWIG_exception(SWIG_ValueError, "Could not get range high levl"); + } + END_EXCEPTION + fail: + return l; + }; + const qpol_mls_level_t *get_low_level(qpol_policy_t *p) { + const qpol_mls_level_t *l; + BEGIN_EXCEPTION + if (qpol_mls_range_get_low_level(p, self, &l)) { + SWIG_exception(SWIG_ValueError, "Could not get range low levl"); + } + END_EXCEPTION + fail: + return l; + }; +}; +%inline %{ + qpol_mls_range_t *qpol_mls_range_from_void(void *x) { + return (qpol_mls_range_t*)x; + }; +%} + +/* qpol mls level */ +typedef struct qpol_mls_level {} qpol_mls_level_t; +%extend qpol_mls_level_t { + qpol_mls_level_t() { + BEGIN_EXCEPTION + SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_mls_level_t objects"); + END_EXCEPTION + fail: + return NULL; + } + ~qpol_mls_level_t() { + /* no op */ + return; + }; + const char *get_sens_name(qpol_policy_t *p) { + const char *name; + BEGIN_EXCEPTION + if (qpol_mls_level_get_sens_name(p, self, &name)) { + SWIG_exception(SWIG_ValueError, "Could not get level sensitivity name"); + } + END_EXCEPTION + fail: + return name; + }; + %newobject get_cat_iter(qpol_policy_t*); + qpol_iterator_t *get_cat_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_mls_level_get_cat_iter(p, self, &iter)) { + SWIG_exception(SWIG_RuntimeError, "Could not get level categories"); + } + END_EXCEPTION + fail: + return iter; + }; +}; +%inline %{ + qpol_mls_level_t *qpol_mls_level_from_void(void *x) { + return (qpol_mls_level_t*)x; + }; +%} + +/* qpol user */ +typedef struct qpol_user {} qpol_user_t; +%extend qpol_user_t { + qpol_user_t(qpol_policy_t *p, const char *name) { + const qpol_user_t *u; + BEGIN_EXCEPTION + if (qpol_policy_get_user_by_name(p, name, &u)) { + SWIG_exception(SWIG_RuntimeError, "User does not exist"); + } + END_EXCEPTION + return (qpol_user_t*)u; + fail: + return NULL; + }; + ~qpol_user_t() { + /* no op */ + return; + }; + int get_value(qpol_policy_t *p) { + uint32_t v; + BEGIN_EXCEPTION + if (qpol_user_get_value(p, self, &v)) { + SWIG_exception(SWIG_ValueError, "Could not get user value"); + } + END_EXCEPTION + fail: + return (int) v; + }; + %newobject get_role_iter(qpol_policy_t*); + qpol_iterator_t *get_role_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_user_get_role_iter(p, self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of Memory"); + } + END_EXCEPTION + fail: + return iter; + }; + const qpol_mls_range_t *get_range(qpol_policy_t *p) { + const qpol_mls_range_t *r; + BEGIN_EXCEPTION + if (qpol_user_get_range(p, self, &r)) { + SWIG_exception(SWIG_ValueError, "Could not get user range"); + } + END_EXCEPTION + fail: + return r; + }; + const char *get_name(qpol_policy_t *p) { + const char *name; + BEGIN_EXCEPTION + if (qpol_user_get_name(p, self, &name)) { + SWIG_exception(SWIG_ValueError, "Could not get user name"); + } + END_EXCEPTION + fail: + return name; + }; + const qpol_mls_level_t *get_dfltlevel(qpol_policy_t *p) { + const qpol_mls_level_t *l; + BEGIN_EXCEPTION + if (qpol_user_get_dfltlevel(p, self, &l)) { + SWIG_exception(SWIG_ValueError, "Could not get user default level"); + } + END_EXCEPTION + fail: + return l; + }; +}; +%inline %{ + qpol_user_t *qpol_user_from_void(void *x) { + return (qpol_user_t*)x; + }; +%} + +/* qpol bool */ +typedef struct qpol_bool {} qpol_bool_t; +%extend qpol_bool_t { + qpol_bool_t(qpol_policy_t *p, const char *name) { + qpol_bool_t *b; + BEGIN_EXCEPTION + if (qpol_policy_get_bool_by_name(p, name, &b)) { + SWIG_exception(SWIG_RuntimeError, "Boolean does not exist"); + } + END_EXCEPTION + fail: + return b; + }; + ~qpol_bool_t() { + /* no op */ + return; + }; + int get_value(qpol_policy_t *p) { + uint32_t v; + BEGIN_EXCEPTION + if (qpol_bool_get_value(p, self, &v)) { + SWIG_exception(SWIG_ValueError, "Could not get boolean value"); + } + END_EXCEPTION + fail: + return (int) v; + }; + int get_state(qpol_policy_t *p) { + int s; + BEGIN_EXCEPTION + if (qpol_bool_get_state(p, self, &s)) { + SWIG_exception(SWIG_ValueError, "Could not get boolean state"); + } + END_EXCEPTION + fail: + return s; + }; + void set_state(qpol_policy_t *p, int state) { + BEGIN_EXCEPTION + if (qpol_bool_set_state(p, self, state)) { + SWIG_exception(SWIG_RuntimeError, "Error setting boolean state"); + } + END_EXCEPTION + fail: + return; + }; + void set_state_no_eval(qpol_policy_t *p, int state) { + BEGIN_EXCEPTION + if (qpol_bool_set_state_no_eval(p, self, state)) { + SWIG_exception(SWIG_RuntimeError, "Error setting boolean state"); + } + END_EXCEPTION + fail: + return; + }; + const char *get_name(qpol_policy_t *p) { + const char *name; + BEGIN_EXCEPTION + if (qpol_bool_get_name(p, self, &name)) { + SWIG_exception(SWIG_ValueError, "Could not get boolean name"); + } + END_EXCEPTION + fail: + return name; + }; +}; +%inline %{ + qpol_bool_t *qpol_bool_from_void(void *x) { + return (qpol_bool_t*)x; + }; +%} + +/* qpol context */ +typedef struct qpol_context {} qpol_context_t; +%extend qpol_context_t { + qpol_context_t() { + BEGIN_EXCEPTION + SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_context_t objects"); + END_EXCEPTION + fail: + return NULL; + }; + ~qpol_context_t() { + /* no op */ + return; + }; + const qpol_user_t *get_user(qpol_policy_t *p) { + const qpol_user_t *u; + BEGIN_EXCEPTION + if (qpol_context_get_user(p, self, &u)) { + SWIG_exception(SWIG_ValueError, "Could not get user from context"); + } + END_EXCEPTION + fail: + return u; + }; + const qpol_role_t *get_role(qpol_policy_t *p) { + const qpol_role_t *r; + BEGIN_EXCEPTION + if (qpol_context_get_role(p, self, &r)) { + SWIG_exception(SWIG_ValueError, "Could not get role from context"); + } + END_EXCEPTION + fail: + return r; + }; + const qpol_type_t *get_type(qpol_policy_t *p) { + const qpol_type_t *t; + BEGIN_EXCEPTION + if (qpol_context_get_type(p, self, &t)) { + SWIG_exception(SWIG_ValueError, "Could not get type from context"); + } + END_EXCEPTION + fail: + return t; + }; + const qpol_mls_range_t *get_range(qpol_policy_t *p) { + const qpol_mls_range_t *r; + BEGIN_EXCEPTION + if (qpol_context_get_range(p, self, &r)) { + SWIG_exception(SWIG_ValueError, "Could not get range from context"); + } + END_EXCEPTION + fail: + return r; + }; +}; +%inline %{ + qpol_context_t *qpol_context_from_void(void *x) { + return (qpol_context_t*)x; + }; +%} + +/* qpol class */ +typedef struct qpol_class {} qpol_class_t; +%extend qpol_class_t { + qpol_class_t(qpol_policy_t *p, const char *name) { + const qpol_class_t *c; + BEGIN_EXCEPTION + if (qpol_policy_get_class_by_name(p, name, &c)) { + SWIG_exception(SWIG_RuntimeError, "Class does not exist"); + } + END_EXCEPTION + fail: + return (qpol_class_t*)c; + }; + ~qpol_class_t() { + /* no op */ + return; + }; + int get_value(qpol_policy_t *p) { + uint32_t v; + BEGIN_EXCEPTION + if (qpol_class_get_value(p, self, &v)) { + SWIG_exception(SWIG_ValueError, "Could not get value for class"); + } + END_EXCEPTION + fail: + return (int) v; + }; + const qpol_common_t *get_common(qpol_policy_t *p) { + const qpol_common_t *c; + BEGIN_EXCEPTION + if(qpol_class_get_common(p, self, &c)) { + SWIG_exception(SWIG_ValueError, "Could not get common for class"); + } + END_EXCEPTION + fail: + return c; + }; + %newobject get_perm_iter(qpol_policy_t*); + qpol_iterator_t *get_perm_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if(qpol_class_get_perm_iter(p, self, &iter)) { + SWIG_exception(SWIG_RuntimeError, "Could not get class permissions"); + } + END_EXCEPTION + fail: + return iter; + }; + %newobject get_constraint_iter(qpol_policy_t*); + qpol_iterator_t *get_constraint_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if(qpol_class_get_constraint_iter(p, self, &iter)) { + SWIG_exception(SWIG_RuntimeError, "Could not get class constraints"); + } + END_EXCEPTION + fail: + return iter; + }; + %newobject get_validatetrans_iter(qpol_policy_t*); + qpol_iterator_t *get_validatetrans_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if(qpol_class_get_validatetrans_iter(p, self, &iter)) { + SWIG_exception(SWIG_RuntimeError, "Could not get class validatetrans statements"); + } + END_EXCEPTION + fail: + return iter; + }; + const char *get_name(qpol_policy_t *p) { + const char *name; + BEGIN_EXCEPTION + if (qpol_class_get_name(p, self, &name)) { + SWIG_exception(SWIG_ValueError, "Could not get class name"); + } + END_EXCEPTION + fail: + return name; + }; +}; +%inline %{ + qpol_class_t *qpol_class_from_void(void *x) { + return (qpol_class_t*)x; + }; +%} + +/* qpol common */ +typedef struct qpol_common {} qpol_common_t; +%extend qpol_common_t { + qpol_common_t(qpol_policy_t *p, const char *name) { + const qpol_common_t *c; + BEGIN_EXCEPTION + if (qpol_policy_get_common_by_name(p, name, &c)) { + SWIG_exception(SWIG_RuntimeError, "Common does not exist"); + } + END_EXCEPTION + fail: + return (qpol_common_t*)c; + }; + ~qpol_common_t() { + /* no op */ + return; + }; + int get_value(qpol_policy_t *p) { + uint32_t v; + BEGIN_EXCEPTION + if (qpol_common_get_value(p, self, &v)) { + SWIG_exception(SWIG_ValueError, "Could not get value for common"); + } + END_EXCEPTION + fail: + return (int) v; + }; + %newobject get_perm_iter(qpol_policy_t*); + qpol_iterator_t *get_perm_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if(qpol_common_get_perm_iter(p, self, &iter)) { + SWIG_exception(SWIG_RuntimeError, "Could not get common permissions"); + } + END_EXCEPTION + fail: + return iter; + }; + const char *get_name(qpol_policy_t *p) { + const char *name; + BEGIN_EXCEPTION + if (qpol_common_get_name(p, self, &name)) { + SWIG_exception(SWIG_ValueError, "Could not get common name"); + } + END_EXCEPTION + fail: + return name; + }; +}; +%inline %{ + qpol_common_t *qpol_common_from_void(void *x) { + return (qpol_common_t*)x; + }; +%} + +/* qpol fs_use */ +/* The defines QPOL_FS_USE_XATTR through QPOL_FS_USE_NONE are + * copied from sepol/policydb/services.h. + * QPOL_FS_USE_PSID is an extension to support v12 policies. */ +#ifdef SWIGJAVA /* java does not understand unsigned constants */ +#define QPOL_FS_USE_XATTR 1 +#define QPOL_FS_USE_TRANS 2 +#define QPOL_FS_USE_TASK 3 +#define QPOL_FS_USE_GENFS 4 +#define QPOL_FS_USE_NONE 5 +#define QPOL_FS_USE_PSID 6 +#else +#define QPOL_FS_USE_XATTR 1U +#define QPOL_FS_USE_TRANS 2U +#define QPOL_FS_USE_TASK 3U +#define QPOL_FS_USE_GENFS 4U +#define QPOL_FS_USE_NONE 5U +#define QPOL_FS_USE_PSID 6U +#endif +typedef struct qpol_fs_use {} qpol_fs_use_t; +%extend qpol_fs_use_t { + qpol_fs_use_t(qpol_policy_t *p, const char *name) { + const qpol_fs_use_t *f; + BEGIN_EXCEPTION + if (qpol_policy_get_fs_use_by_name(p, name, &f)) { + SWIG_exception(SWIG_RuntimeError, "FS Use Statement does not exist"); + } + END_EXCEPTION + fail: + return (qpol_fs_use_t*)f; + }; + ~qpol_fs_use_t() { + /* no op */ + return; + }; + const char *get_name(qpol_policy_t *p) { + const char *name; + BEGIN_EXCEPTION + if (qpol_fs_use_get_name(p, self, &name)) { + SWIG_exception(SWIG_ValueError, "Could not get file system name"); + } + END_EXCEPTION + fail: + return name; + }; + int get_behavior(qpol_policy_t *p) { + uint32_t behav; + BEGIN_EXCEPTION + if (qpol_fs_use_get_behavior(p, self, &behav)) { + SWIG_exception(SWIG_ValueError, "Could not get file system labeling behavior"); + } + END_EXCEPTION + fail: + return (int) behav; + }; + const qpol_context_t *get_context(qpol_policy_t *p) { + uint32_t behav; + const qpol_context_t *ctx = NULL; + BEGIN_EXCEPTION + qpol_fs_use_get_behavior(p, self, &behav); + if (behav == QPOL_FS_USE_PSID) { + SWIG_exception(SWIG_TypeError, "Cannot get context for fs_use_psid statements"); + } else if (qpol_fs_use_get_context(p, self, &ctx)) { + SWIG_exception(SWIG_ValueError, "Could not get file system context"); + } + END_EXCEPTION + fail: + return ctx; + }; +}; +%inline %{ + qpol_fs_use_t *qpol_fs_use_from_void(void *x) { + return (qpol_fs_use_t*)x; + }; +%} + +/* qpol genfscon */ +/* values from flask do not change */ +#ifdef SWIGJAVA /* java does not understand unsigned constants */ +#define QPOL_CLASS_ALL 0 +#define QPOL_CLASS_BLK_FILE 11 +#define QPOL_CLASS_CHR_FILE 10 +#define QPOL_CLASS_DIR 7 +#define QPOL_CLASS_FIFO_FILE 13 +#define QPOL_CLASS_FILE 6 +#define QPOL_CLASS_LNK_FILE 9 +#define QPOL_CLASS_SOCK_FILE 12 +#else +#define QPOL_CLASS_ALL 0U +#define QPOL_CLASS_BLK_FILE 11U +#define QPOL_CLASS_CHR_FILE 10U +#define QPOL_CLASS_DIR 7U +#define QPOL_CLASS_FIFO_FILE 13U +#define QPOL_CLASS_FILE 6U +#define QPOL_CLASS_LNK_FILE 9U +#define QPOL_CLASS_SOCK_FILE 12U +#endif +typedef struct qpol_genfscon {} qpol_genfscon_t; +%extend qpol_genfscon_t { + qpol_genfscon_t(qpol_policy_t *p, const char *name, const char *path) { + qpol_genfscon_t *g; + BEGIN_EXCEPTION + if (qpol_policy_get_genfscon_by_name(p, name, path, &g)) { + SWIG_exception(SWIG_RuntimeError, "Genfscon statement does not exist"); + } + END_EXCEPTION + fail: + return g; + }; + ~qpol_genfscon_t() { + free(self); + }; + const char *get_name(qpol_policy_t *p) { + const char *name; + BEGIN_EXCEPTION + if (qpol_genfscon_get_name(p, self, &name)) { + SWIG_exception(SWIG_ValueError, "Could not get file system name"); + } + END_EXCEPTION + fail: + return name; + }; + const char *get_path(qpol_policy_t *p) { + const char *path; + BEGIN_EXCEPTION + if (qpol_genfscon_get_path(p, self, &path)) { + SWIG_exception(SWIG_ValueError, "Could not get file system path"); + } + END_EXCEPTION + fail: + return path; + }; + int get_class(qpol_policy_t *p) { + uint32_t cls; + BEGIN_EXCEPTION + if (qpol_genfscon_get_class(p, self, &cls)) { + SWIG_exception(SWIG_ValueError, "Could not get genfscon statement class"); + } + END_EXCEPTION + fail: + return (int) cls; + }; + const qpol_context_t *get_context(qpol_policy_t *p) { + const qpol_context_t *ctx; + BEGIN_EXCEPTION + if (qpol_genfscon_get_context(p, self, &ctx)) { + SWIG_exception(SWIG_ValueError, "Could not get context for genfscon statement"); + } + END_EXCEPTION + fail: + return ctx; + }; +}; +%inline %{ + qpol_genfscon_t *qpol_genfscon_from_void(void *x) { + return (qpol_genfscon_t*)x; + }; +%} + +/* qpol isid */ +typedef struct qpol_isid {} qpol_isid_t; +%extend qpol_isid_t { + qpol_isid_t(qpol_policy_t *p, const char *name) { + const qpol_isid_t *i; + BEGIN_EXCEPTION + if (qpol_policy_get_isid_by_name(p, name, &i)) { + SWIG_exception(SWIG_RuntimeError, "Isid does not exist"); + } + END_EXCEPTION + fail: + return (qpol_isid_t*)i; + }; + ~qpol_isid_t() { + /* no op */ + return; + }; + const char *get_name(qpol_policy_t *p) { + const char *name; + BEGIN_EXCEPTION + if (qpol_isid_get_name(p, self, &name)) { + SWIG_exception(SWIG_ValueError, "Could not get name for initial sid"); + } + END_EXCEPTION + fail: + return name; + }; + const qpol_context_t *get_context(qpol_policy_t *p) { + const qpol_context_t *ctx; + BEGIN_EXCEPTION + if (qpol_isid_get_context(p, self, &ctx)) { + SWIG_exception(SWIG_ValueError, "Could not get context for initial sid"); + } + END_EXCEPTION + fail: + return ctx; + }; +}; +%inline %{ + qpol_isid_t *qpol_isid_from_void(void *x) { + return (qpol_isid_t*)x; + }; +%} + +/* qpol netifcon */ +typedef struct qpol_netifcon {} qpol_netifcon_t; +%extend qpol_netifcon_t { + qpol_netifcon_t(qpol_policy_t *p, const char *name) { + const qpol_netifcon_t *n; + BEGIN_EXCEPTION + if (qpol_policy_get_netifcon_by_name(p, name, &n)) { + SWIG_exception(SWIG_RuntimeError, "Netifcon statement does not exist"); + } + END_EXCEPTION + fail: + return (qpol_netifcon_t*)n; + }; + ~qpol_netifcon_t() { + /* no op */ + return; + }; + const char *get_name(qpol_policy_t *p) { + const char *name; + BEGIN_EXCEPTION + if (qpol_netifcon_get_name(p, self, &name)) { + SWIG_exception(SWIG_ValueError, "Could not get name for netifcon statement"); + } + END_EXCEPTION + fail: + return name; + }; + const qpol_context_t *get_msg_con(qpol_policy_t *p) { + const qpol_context_t *ctx; + BEGIN_EXCEPTION + if (qpol_netifcon_get_msg_con(p, self, &ctx)) { + SWIG_exception(SWIG_ValueError, "Could not get message context for netifcon statement"); + } + END_EXCEPTION + fail: + return ctx; + }; + const qpol_context_t *get_if_con(qpol_policy_t *p) { + const qpol_context_t *ctx; + BEGIN_EXCEPTION + if (qpol_netifcon_get_if_con(p, self, &ctx)) { + SWIG_exception(SWIG_ValueError, "Could not get interface context for netifcon statement"); + } + END_EXCEPTION + fail: + return ctx; + }; +}; +%inline %{ + qpol_netifcon_t *qpol_netifcon_from_void(void *x) { + return (qpol_netifcon_t*)x; + }; +%} + +/* qpol nodecon */ +#define QPOL_IPV4 0 +#define QPOL_IPV6 1 +typedef struct qpol_nodecon {} qpol_nodecon_t; +%extend qpol_nodecon_t { + qpol_nodecon_t(qpol_policy_t *p, int addr[4], int mask[4], int protocol) { + uint32_t a[4], m[4]; + qpol_nodecon_t *n; + BEGIN_EXCEPTION + a[0] = (uint32_t) addr[0]; a[1] = (uint32_t) addr[1]; + a[2] = (uint32_t) addr[2]; a[3] = (uint32_t) addr[3]; + m[0] = (uint32_t) mask[0]; m[1] = (uint32_t) mask[1]; + m[2] = (uint32_t) mask[2]; m[3] = (uint32_t) mask[3]; + if (qpol_policy_get_nodecon_by_node(p, a, m, protocol, &n)) { + SWIG_exception(SWIG_RuntimeError, "Nodecon statement does not exist"); + } + END_EXCEPTION + fail: + return n; + } + ~qpol_nodecon_t() { + free(self); + }; + uint32_t *get_addr(qpol_policy_t *p) { + uint32_t *a; + BEGIN_EXCEPTION + unsigned char proto; /* currently dropped; stores the protocol - call get_protocol() */ + if (qpol_nodecon_get_addr(p, self, &a, &proto)) { + SWIG_exception(SWIG_ValueError, "Could not get address of nodecon statement"); + } + END_EXCEPTION + fail: + return a; + }; + uint32_t *get_mask(qpol_policy_t *p) { + uint32_t *m; + BEGIN_EXCEPTION + unsigned char proto; /* currently dropped; stores the protocol - call get_protocol() */ + if (qpol_nodecon_get_mask(p, self, &m, &proto)) { + SWIG_exception(SWIG_ValueError, "Could not get mask of nodecon statement"); + } + END_EXCEPTION + fail: + return m; + }; + int get_protocol(qpol_policy_t *p) { + unsigned char proto; + BEGIN_EXCEPTION + if (qpol_nodecon_get_protocol(p, self, &proto)) { + SWIG_exception(SWIG_ValueError, "Could not get protocol for nodecon statement"); + } + END_EXCEPTION + fail: + return proto; + }; + const qpol_context_t *get_context(qpol_policy_t *p) { + const qpol_context_t *ctx; + BEGIN_EXCEPTION + if (qpol_nodecon_get_context(p, self, &ctx)) { + SWIG_exception(SWIG_ValueError, "Could not get context for nodecon statement"); + } + END_EXCEPTION + fail: + return ctx; + }; +}; +%inline %{ + qpol_nodecon_t *qpol_nodecon_from_void(void *x) { + return (qpol_nodecon_t*)x; + }; +%} + +/* qpol portcon */ +/* from netinet/in.h */ +#define IPPROTO_TCP 6 +#define IPPROTO_UDP 17 +typedef struct qpol_portcon {} qpol_portcon_t; +%extend qpol_portcon_t { + qpol_portcon_t(qpol_policy_t *p, uint16_t low, uint16_t high, uint8_t protocol) { + const qpol_portcon_t *qp; + BEGIN_EXCEPTION + if (qpol_policy_get_portcon_by_port(p, low, high, protocol, &qp)) { + SWIG_exception(SWIG_RuntimeError, "Portcon statement does not exist"); + } + END_EXCEPTION + fail: + return (qpol_portcon_t*)qp; + }; + ~qpol_portcon_t() { + /* no op */ + return; + }; + uint16_t get_low_port(qpol_policy_t *p) { + uint16_t port = 0; + BEGIN_EXCEPTION + if(qpol_portcon_get_low_port(p, self, &port)) { + SWIG_exception(SWIG_RuntimeError, "Could not get low port for portcon statement"); + } + END_EXCEPTION + fail: + return port; + }; + uint16_t get_high_port(qpol_policy_t *p) { + uint16_t port = 0; + BEGIN_EXCEPTION + if(qpol_portcon_get_high_port(p, self, &port)) { + SWIG_exception(SWIG_RuntimeError, "Could not get high port for portcon statement"); + } + END_EXCEPTION + fail: + return port; + }; + uint8_t get_protocol(qpol_policy_t *p) { + uint8_t proto = 0; + BEGIN_EXCEPTION + if (qpol_portcon_get_protocol(p, self, &proto)) { + SWIG_exception(SWIG_RuntimeError, "Could not get protocol for portcon statement"); + } + END_EXCEPTION + fail: + return proto; + }; + const qpol_context_t *get_context(qpol_policy_t *p) { + const qpol_context_t *ctx; + BEGIN_EXCEPTION + if (qpol_portcon_get_context(p, self, &ctx)) { + SWIG_exception(SWIG_ValueError, "Could not get context for portcon statement"); + } + END_EXCEPTION + fail: + return ctx; + }; +} +%inline %{ + qpol_portcon_t *qpol_portcon_from_void(void *x) { + return (qpol_portcon_t*)x; + }; +%} + +/* qpol constraint */ +typedef struct qpol_constraint {} qpol_constraint_t; +%extend qpol_constraint_t { + qpol_constraint_t() { + BEGIN_EXCEPTION + SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_constraint_t objects"); + END_EXCEPTION + fail: + return NULL; + }; + ~qpol_constraint_t() { + free(self); + }; + const qpol_class_t *get_class(qpol_policy_t *p) { + const qpol_class_t *cls; + BEGIN_EXCEPTION + if (qpol_constraint_get_class(p, self, &cls)) { + SWIG_exception(SWIG_ValueError, "Could not get class for constraint"); + } + END_EXCEPTION + fail: + return cls; + }; + %newobject get_perm_iter(qpol_policy_t*); + qpol_iterator_t *get_perm_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_constraint_get_perm_iter(p, self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return iter; + }; + %newobject get_expr_iter(qpol_policy_t*); + qpol_iterator_t *get_expr_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_constraint_get_expr_iter(p, self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return iter; + }; +}; +%inline %{ + qpol_constraint_t *qpol_constraint_from_void(void *x) { + return (qpol_constraint_t*)x; + }; +%} + +/* qpol validatetrans */ +typedef struct qpol_validatetrans {} qpol_validatetrans_t; +%extend qpol_validatetrans_t { + qpol_validatetrans_t() { + BEGIN_EXCEPTION + SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_validatetrans_t objects"); + END_EXCEPTION + fail: + return NULL; + }; + ~qpol_validatetrans_t() { + free(self); + }; + const qpol_class_t *get_class(qpol_policy_t *p) { + const qpol_class_t *cls; + BEGIN_EXCEPTION + if (qpol_validatetrans_get_class(p, self, &cls)) { + SWIG_exception(SWIG_ValueError, "Could not get class for validatetrans"); + } + END_EXCEPTION + fail: + return cls; + }; + %newobject get_expr_iter(qpol_policy_t*); + qpol_iterator_t *get_expr_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_validatetrans_get_expr_iter(p, self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return iter; + }; +}; +%inline %{ + qpol_validatetrans_t *qpol_validatetrans_from_void(void *x) { + return (qpol_validatetrans_t*)x; + }; +%} + +/* qpol constraint expression node */ +/* expr_type values */ +#define QPOL_CEXPR_TYPE_NOT 1 +#define QPOL_CEXPR_TYPE_AND 2 +#define QPOL_CEXPR_TYPE_OR 3 +#define QPOL_CEXPR_TYPE_ATTR 4 +#define QPOL_CEXPR_TYPE_NAMES 5 +/* symbol type values */ +#define QPOL_CEXPR_SYM_USER 1 +#define QPOL_CEXPR_SYM_ROLE 2 +#define QPOL_CEXPR_SYM_TYPE 4 +#define QPOL_CEXPR_SYM_TARGET 8 +#define QPOL_CEXPR_SYM_XTARGET 16 +#define QPOL_CEXPR_SYM_L1L2 32 +#define QPOL_CEXPR_SYM_L1H2 64 +#define QPOL_CEXPR_SYM_H1L2 128 +#define QPOL_CEXPR_SYM_H1H2 256 +#define QPOL_CEXPR_SYM_L1H1 512 +#define QPOL_CEXPR_SYM_L2H2 1024 +/* op values */ +#define QPOL_CEXPR_OP_EQ 1 +#define QPOL_CEXPR_OP_NEQ 2 +#define QPOL_CEXPR_OP_DOM 3 +#define QPOL_CEXPR_OP_DOMBY 4 +#define QPOL_CEXPR_OP_INCOMP 5 +typedef struct qpol_constraint_expr_node {} qpol_constraint_expr_node_t; +%extend qpol_constraint_expr_node_t { + qpol_constraint_expr_node_t() { + BEGIN_EXCEPTION + SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_constraint_expr_node_t objects"); + END_EXCEPTION + fail: + return NULL; + }; + ~qpol_constraint_expr_node_t() { + /* no op */ + return; + }; + int get_expr_type(qpol_policy_t *p) { + uint32_t et; + BEGIN_EXCEPTION + if (qpol_constraint_expr_node_get_expr_type(p, self, &et)) { + SWIG_exception(SWIG_ValueError, "Could not get expression type for node"); + } + END_EXCEPTION + fail: + return (int) et; + }; + int get_sym_type(qpol_policy_t *p) { + uint32_t st; + BEGIN_EXCEPTION + if (qpol_constraint_expr_node_get_sym_type(p, self, &st)) { + SWIG_exception(SWIG_ValueError, "Could not get symbol type for node"); + } + END_EXCEPTION + fail: + return (int) st; + }; + int get_op(qpol_policy_t *p) { + uint32_t op; + BEGIN_EXCEPTION + if (qpol_constraint_expr_node_get_op(p, self, &op)) { + SWIG_exception(SWIG_ValueError, "Could not get operator for node"); + } + END_EXCEPTION + fail: + return (int) op; + }; + %newobject get_names_iter(qpol_policy_t*); + qpol_iterator_t *get_names_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_constraint_expr_node_get_names_iter(p, self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return iter; + }; +}; +%inline %{ + qpol_constraint_expr_node_t *qpol_constraint_expr_node_from_void(void *x) { + return (qpol_constraint_expr_node_t*)x; + }; +%} + +/* qpol role allow */ +typedef struct qpol_role_allow {} qpol_role_allow_t; +%extend qpol_role_allow_t { + qpol_role_allow_t() { + BEGIN_EXCEPTION + SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_role_allow_t objects"); + END_EXCEPTION + fail: + return NULL; + }; + ~qpol_role_allow_t() { + /* no op */ + return; + }; + const qpol_role_t *get_source_role(qpol_policy_t *p) { + const qpol_role_t *r; + BEGIN_EXCEPTION + if (qpol_role_allow_get_source_role(p, self, &r)) { + SWIG_exception(SWIG_ValueError, "Could not get source for role allow rule"); + } + END_EXCEPTION + fail: + return r; + }; + const qpol_role_t *get_target_role(qpol_policy_t *p) { + const qpol_role_t *r; + BEGIN_EXCEPTION + if (qpol_role_allow_get_target_role(p, self, &r)) { + SWIG_exception(SWIG_ValueError, "Could not get target for role allow rule"); + } + END_EXCEPTION + fail: + return r; + }; +}; +%inline %{ + qpol_role_allow_t *qpol_role_allow_from_void(void *x) { + return (qpol_role_allow_t*)x; + }; +%} + +/* qpol role trans */ +typedef struct qpol_role_trans {} qpol_role_trans_t; +%extend qpol_role_trans_t { + qpol_role_trans_t() { + BEGIN_EXCEPTION + SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_role_trans_t objects"); + END_EXCEPTION + fail: + return NULL; + }; + ~qpol_role_trans_t() { + /* no op */ + return; + }; + const qpol_role_t *get_source_role(qpol_policy_t *p) { + const qpol_role_t *r; + BEGIN_EXCEPTION + if (qpol_role_trans_get_source_role(p, self, &r)) { + SWIG_exception(SWIG_ValueError, "Could not get source for role_transition rule"); + } + END_EXCEPTION + fail: + return r; + }; + const qpol_type_t *get_target_type(qpol_policy_t *p) { + const qpol_type_t *t; + BEGIN_EXCEPTION + if (qpol_role_trans_get_target_type(p, self, &t)) { + SWIG_exception(SWIG_ValueError, "Could not get target for role_transition rule"); + } + END_EXCEPTION + fail: + return t; + }; + const qpol_role_t *get_default_role(qpol_policy_t *p) { + const qpol_role_t *r; + BEGIN_EXCEPTION + if (qpol_role_trans_get_default_role(p, self, &r)) { + SWIG_exception(SWIG_ValueError, "Could not get default for role_transition rule"); + } + END_EXCEPTION + fail: + return r; + }; +}; +%inline %{ + qpol_role_trans_t *qpol_role_trans_from_void(void *x) { + return (qpol_role_trans_t*)x; + }; +%} + +/* qpol range trans */ +typedef struct qpol_range_trans {} qpol_range_trans_t; +%extend qpol_range_trans_t { + qpol_range_trans_t() { + BEGIN_EXCEPTION + SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_range_trans_t objects"); + END_EXCEPTION + fail: + return NULL; + }; + ~qpol_range_trans_t() { + /* no op */ + return; + }; + const qpol_type_t *get_source_type (qpol_policy_t *p) { + const qpol_type_t *t; + BEGIN_EXCEPTION + if (qpol_range_trans_get_source_type(p, self, &t)) { + SWIG_exception(SWIG_ValueError, "Could not get source for range_transition rule"); + } + END_EXCEPTION + fail: + return t; + }; + const qpol_type_t *get_target_type (qpol_policy_t *p) { + const qpol_type_t *t; + BEGIN_EXCEPTION + if (qpol_range_trans_get_target_type(p, self, &t)) { + SWIG_exception(SWIG_ValueError, "Could not get target for range_transition rule"); } + END_EXCEPTION + fail: + return t; + }; + const qpol_class_t *get_target_class(qpol_policy_t *p) { + const qpol_class_t *cls; + BEGIN_EXCEPTION + if (qpol_range_trans_get_target_class(p, self, &cls)) { + SWIG_exception(SWIG_ValueError, "Could not get class for range_transition rule"); } + END_EXCEPTION + fail: + return cls; + }; + const qpol_mls_range_t *get_range(qpol_policy_t *p) { + const qpol_mls_range_t *r; + BEGIN_EXCEPTION + if (qpol_range_trans_get_range(p, self, &r)) { + SWIG_exception(SWIG_ValueError, "Could not get range for range_transition rule"); + } + END_EXCEPTION + fail: + return r; + }; +}; +%inline %{ + qpol_range_trans_t *qpol_range_trans_from_void(void *x) { + return (qpol_range_trans_t*)x; + }; +%} + +/* qpol av rule */ +#define QPOL_RULE_ALLOW 1 +#define QPOL_RULE_NEVERALLOW 128 +#define QPOL_RULE_AUDITALLOW 2 +#define QPOL_RULE_DONTAUDIT 4 +typedef struct qpol_avrule {} qpol_avrule_t; +%extend qpol_avrule_t { + qpol_avrule_t() { + BEGIN_EXCEPTION + SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_avrule_t objects"); + END_EXCEPTION + fail: + return NULL; + }; + ~qpol_avrule_t() { + /* no op */ + return; + }; + int get_rule_type(qpol_policy_t *p) { + uint32_t rt; + BEGIN_EXCEPTION + if (qpol_avrule_get_rule_type(p, self, &rt)) { + SWIG_exception(SWIG_ValueError, "Could not get rule type for av rule"); + } + END_EXCEPTION + fail: + return (int) rt; + }; + const qpol_type_t *get_source_type(qpol_policy_t *p) { + const qpol_type_t *t; + BEGIN_EXCEPTION + if (qpol_avrule_get_source_type(p, self, &t)) { + SWIG_exception(SWIG_ValueError, "Could not get source for av rule"); + } + END_EXCEPTION + fail: + return t; + }; + const qpol_type_t *get_target_type(qpol_policy_t *p) { + const qpol_type_t *t; + BEGIN_EXCEPTION + if (qpol_avrule_get_target_type(p, self, &t)) { + SWIG_exception(SWIG_ValueError, "Could not get target for av rule"); + } + END_EXCEPTION + fail: + return t; + }; + const qpol_class_t *get_object_class(qpol_policy_t *p) { + const qpol_class_t *cls; + BEGIN_EXCEPTION + if (qpol_avrule_get_object_class(p, self, &cls)) { + SWIG_exception(SWIG_ValueError, "Could not get class for av rule"); + } + END_EXCEPTION + fail: + return cls; + }; + %newobject get_perm_iter(qpol_policy_t *p); + qpol_iterator_t *get_perm_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_avrule_get_perm_iter(p, self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return iter; + }; + const qpol_cond_t *get_cond(qpol_policy_t *p) { + const qpol_cond_t *c; + BEGIN_EXCEPTION + if (qpol_avrule_get_cond(p, self, &c)) { + SWIG_exception(SWIG_ValueError, "Could not get conditional for av rule"); + } + END_EXCEPTION + fail: + return c; + }; + int get_is_enabled(qpol_policy_t *p) { + uint32_t e; + BEGIN_EXCEPTION + if (qpol_avrule_get_is_enabled(p, self, &e)) { + SWIG_exception(SWIG_ValueError, "Could not determine if av rule is enabled"); + } + END_EXCEPTION + fail: + return (int) e; + }; + int get_which_list(qpol_policy_t *p) { + const qpol_cond_t *c; + uint32_t which = 0; + BEGIN_EXCEPTION + qpol_avrule_get_cond(p, self, &c); + if (c == NULL) { + SWIG_exception(SWIG_TypeError, "Rule is not conditional"); + } else if (qpol_avrule_get_which_list(p, self, &which)) { + SWIG_exception(SWIG_ValueError, "Could not get conditional list for av rule"); + } + END_EXCEPTION + fail: + return (int) which; + }; + %newobject get_syn_avrule_iter(qpol_policy_t*); + qpol_iterator_t *get_syn_avrule_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_avrule_get_syn_avrule_iter(p, self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return iter; + }; +}; +%inline %{ + qpol_avrule_t *qpol_avrule_from_void(void *x) { + return (qpol_avrule_t*)x; + }; +%} + +/* qpol te rule */ +#define QPOL_RULE_TYPE_TRANS 16 +#define QPOL_RULE_TYPE_CHANGE 64 +#define QPOL_RULE_TYPE_MEMBER 32 +typedef struct qpol_terule {} qpol_terule_t; +%extend qpol_terule_t { + qpol_terule_t() { + BEGIN_EXCEPTION + SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_terule_t objects"); + END_EXCEPTION + fail: + return NULL; + }; + ~qpol_terule_t() { + /* no op */ + return; + }; + int get_rule_type(qpol_policy_t *p) { + uint32_t rt; + BEGIN_EXCEPTION + if (qpol_terule_get_rule_type(p, self, &rt)) { + SWIG_exception(SWIG_ValueError, "Could not get rule type for te rule"); + } + END_EXCEPTION + fail: + return (int) rt; + }; + const qpol_type_t *get_source_type(qpol_policy_t *p) { + const qpol_type_t *t; + BEGIN_EXCEPTION + if (qpol_terule_get_source_type(p, self, &t)) { + SWIG_exception(SWIG_ValueError, "Could not get source for te rule"); + } + END_EXCEPTION + fail: + return t; + }; + const qpol_type_t *get_target_type(qpol_policy_t *p) { + const qpol_type_t *t; + BEGIN_EXCEPTION + if (qpol_terule_get_target_type(p, self, &t)) { + SWIG_exception(SWIG_ValueError, "Could not get target for te rule"); + } + END_EXCEPTION + fail: + return t; + }; + const qpol_class_t *get_object_class(qpol_policy_t *p) { + const qpol_class_t *cls; + BEGIN_EXCEPTION + if (qpol_terule_get_object_class(p, self, &cls)) { + SWIG_exception(SWIG_ValueError, "Could not get class for te rule"); + } + END_EXCEPTION + fail: + return cls; + }; + const qpol_type_t *get_default_type(qpol_policy_t *p) { + const qpol_type_t *t; + BEGIN_EXCEPTION + if (qpol_terule_get_default_type(p, self, &t)) { + SWIG_exception(SWIG_ValueError, "Could not get default for te rule"); + } + END_EXCEPTION + fail: + return t; + }; + const qpol_cond_t *get_cond(qpol_policy_t *p) { + const qpol_cond_t *c; + BEGIN_EXCEPTION + if (qpol_terule_get_cond(p, self, &c)) { + SWIG_exception(SWIG_ValueError, "Could not get conditional for te rule"); + } + END_EXCEPTION + fail: + return c; + }; + int get_is_enabled(qpol_policy_t *p) { + uint32_t e; + BEGIN_EXCEPTION + if (qpol_terule_get_is_enabled(p, self, &e)) { + SWIG_exception(SWIG_ValueError, "Could not determine if te rule is enabled"); + } + END_EXCEPTION + fail: + return (int) e; + }; + int get_which_list(qpol_policy_t *p) { + const qpol_cond_t *c; + uint32_t which = 0; + BEGIN_EXCEPTION + qpol_terule_get_cond(p, self, &c); + if (c == NULL) { + SWIG_exception(SWIG_TypeError, "Rule is not conditional"); + } else if (qpol_terule_get_which_list(p, self, &which)) { + SWIG_exception(SWIG_ValueError, "Could not get conditional list for te rule"); + } + END_EXCEPTION + fail: + return (int) which; + }; + %newobject get_syn_terule_iter(qpol_policy_t*); + qpol_iterator_t *get_syn_terule_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_terule_get_syn_terule_iter(p, self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return iter; + }; +}; +%inline %{ + qpol_terule_t *qpol_terule_from_void(void *x) { + return (qpol_terule_t*)x; + }; +%} + +/* qpol conditional */ +typedef struct qpol_cond {} qpol_cond_t; +%extend qpol_cond_t { + qpol_cond_t() { + BEGIN_EXCEPTION + SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_cond_t objects"); + END_EXCEPTION + fail: + return NULL; + }; + ~qpol_cond_t() { + /* no op */ + return; + }; + %newobject get_expr_node_iter(qpol_policy_t*); + qpol_iterator_t *get_expr_node_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_cond_get_expr_node_iter(p, self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return iter; + }; + %newobject get_av_true_iter(qpol_policy_t*, int); + qpol_iterator_t *get_av_true_iter(qpol_policy_t *p, int rule_types) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_cond_get_av_true_iter(p, self, rule_types, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return iter; + }; + %newobject get_av_false_iter(qpol_policy_t*, int); + qpol_iterator_t *get_av_false_iter(qpol_policy_t *p, int rule_types) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_cond_get_av_false_iter(p, self, rule_types, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return iter; + }; + %newobject get_te_true_iter(qpol_policy_t*, int); + qpol_iterator_t *get_te_true_iter(qpol_policy_t *p, int rule_types) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_cond_get_te_true_iter(p, self, rule_types, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return iter; + }; + %newobject get_te_false_iter(qpol_policy_t*, int); + qpol_iterator_t *get_te_false_iter(qpol_policy_t *p, int rule_types) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_cond_get_te_false_iter(p, self, rule_types, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return iter; + }; + int eval(qpol_policy_t *p) { + uint32_t e; + BEGIN_EXCEPTION + if (qpol_cond_eval(p, self, &e)) { + SWIG_exception(SWIG_RuntimeError, "Could not evaluate conditional"); + } + END_EXCEPTION + fail: + return (int) e; + }; +}; +%inline %{ + qpol_cond_t *qpol_cond_from_void(void *x) { + return (qpol_cond_t*)x; + }; +%} + +/* qpol conditional expression node */ +#define QPOL_COND_EXPR_BOOL 1 /* plain bool */ +#define QPOL_COND_EXPR_NOT 2 /* !bool */ +#define QPOL_COND_EXPR_OR 3 /* bool || bool */ +#define QPOL_COND_EXPR_AND 4 /* bool && bool */ +#define QPOL_COND_EXPR_XOR 5 /* bool ^ bool */ +#define QPOL_COND_EXPR_EQ 6 /* bool == bool */ +#define QPOL_COND_EXPR_NEQ 7 /* bool != bool */ +typedef struct qpol_cond_expr_node {} qpol_cond_expr_node_t; +%extend qpol_cond_expr_node_t { + qpol_cond_expr_node_t() { + BEGIN_EXCEPTION + SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_cond_expr_node_t objects"); + END_EXCEPTION + fail: + return NULL; + }; + ~qpol_cond_expr_node_t() { + /* no op */ + return; + }; + int get_expr_type(qpol_policy_t *p) { + uint32_t et; + BEGIN_EXCEPTION + if (qpol_cond_expr_node_get_expr_type(p, self, &et)) { + SWIG_exception(SWIG_ValueError, "Could not get node expression type"); + } + END_EXCEPTION + fail: + return (int) et; + }; + qpol_bool_t *get_bool(qpol_policy_t *p) { + uint32_t et; + qpol_bool_t *b = NULL; + BEGIN_EXCEPTION + qpol_cond_expr_node_get_expr_type(p, self, &et); + if (et != QPOL_COND_EXPR_BOOL) { + SWIG_exception(SWIG_TypeError, "Node does not contain a boolean"); + } else if (qpol_cond_expr_node_get_bool(p, self, &b)) { + SWIG_exception(SWIG_ValueError, "Could not get boolean for node"); + } + END_EXCEPTION + fail: + return b; + }; +}; +%inline %{ + qpol_cond_expr_node_t *qpol_cond_expr_node_from_void(void *x) { + return (qpol_cond_expr_node_t*)x; + }; +%} + +/* qpol type set */ +typedef struct qpol_type_set {} qpol_type_set_t; +%extend qpol_type_set_t { + qpol_type_set_t() { + BEGIN_EXCEPTION + SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_type_set_t objects"); + END_EXCEPTION + fail: + return NULL; + }; + ~qpol_type_set_t() { + /* no op */ + return; + }; + %newobject get_included_types_iter(qpol_policy_t*); + qpol_iterator_t *get_included_types_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_type_set_get_included_types_iter(p, self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return iter; + }; + %newobject get_subtracted_types_iter(qpol_policy_t*); + qpol_iterator_t *get_subtracted_types_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_type_set_get_subtracted_types_iter(p, self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return iter; + }; + int get_is_star(qpol_policy_t *p) { + uint32_t s; + BEGIN_EXCEPTION + if (qpol_type_set_get_is_star(p, self, &s)) { + SWIG_exception(SWIG_ValueError, "Could not determine if type set contains star"); + } + END_EXCEPTION + fail: + return (int) s; + }; + int get_is_comp(qpol_policy_t *p) { + uint32_t c; + BEGIN_EXCEPTION + if (qpol_type_set_get_is_comp(p, self, &c)) { + SWIG_exception(SWIG_ValueError, "Could not determine if type set is complemented"); + } + END_EXCEPTION + fail: + return (int) c; + }; +}; +%inline %{ + qpol_type_set_t *qpol_type_set_from_void(void *x) { + return (qpol_type_set_t*)x; + }; +%} + +/* qpol syn av rule */ +typedef struct qpol_syn_avrule {} qpol_syn_avrule_t; +%extend qpol_syn_avrule_t { + qpol_syn_avrule_t() { + BEGIN_EXCEPTION + SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_syn_avrule_t objects"); + END_EXCEPTION + fail: + return NULL; + }; + ~qpol_syn_avrule_t() { + /* no op */ + return; + }; + int get_rule_type(qpol_policy_t *p) { + uint32_t rt; + BEGIN_EXCEPTION + if (qpol_syn_avrule_get_rule_type(p, self, &rt)) { + SWIG_exception(SWIG_ValueError, "Could not get rule type for syn av rule"); + } + END_EXCEPTION + fail: + return (int) rt; + }; + const qpol_type_set_t *get_source_type_set(qpol_policy_t *p) { + const qpol_type_set_t *ts; + BEGIN_EXCEPTION + if (qpol_syn_avrule_get_source_type_set(p, self, &ts)) { + SWIG_exception(SWIG_ValueError, "Could not get source type set for syn av rule"); + } + END_EXCEPTION + fail: + return ts; + }; + const qpol_type_set_t *get_target_type_set(qpol_policy_t *p) { + const qpol_type_set_t *ts; + BEGIN_EXCEPTION + if (qpol_syn_avrule_get_target_type_set(p, self, &ts)) { + SWIG_exception(SWIG_ValueError, "Could not get target type set for syn av rule"); + } + END_EXCEPTION + fail: + return ts; + }; + int get_is_target_self(qpol_policy_t *p) { + uint32_t i; + BEGIN_EXCEPTION + if (qpol_syn_avrule_get_is_target_self(p, self, &i)) { + SWIG_exception(SWIG_ValueError, "Could not determine if target is self for syn av rule"); + } + END_EXCEPTION + fail: + return (int) i; + }; + %newobject get_class_iter(qpol_policy_t*); + qpol_iterator_t *get_class_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_syn_avrule_get_class_iter(p, self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return iter; + }; + %newobject get_perm_iter(qpol_policy_t*); + qpol_iterator_t *get_perm_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_syn_avrule_get_perm_iter(p, self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return iter; + }; + long get_lineno(qpol_policy_t *p) { + unsigned long l; + BEGIN_EXCEPTION + if (qpol_syn_avrule_get_lineno(p, self, &l)) { + SWIG_exception(SWIG_ValueError, "Could not get line number for syn av rule"); + } + END_EXCEPTION + fail: + return (long)l; + }; + const qpol_cond_t *get_cond(qpol_policy_t *p) { + const qpol_cond_t *c; + BEGIN_EXCEPTION + if (qpol_syn_avrule_get_cond(p, self, &c)) { + SWIG_exception(SWIG_ValueError, "Could not get conditional for syn av rule"); + } + END_EXCEPTION + fail: + return c; + }; + int get_is_enabled(qpol_policy_t *p) { + uint32_t e; + BEGIN_EXCEPTION + if (qpol_syn_avrule_get_is_enabled(p, self, &e)) { + SWIG_exception(SWIG_ValueError, "Could not determine if syn av rule is enabled"); + } + END_EXCEPTION + fail: + return e; + }; +}; +%inline %{ + qpol_syn_avrule_t *qpol_syn_avrule_from_void(void *x) { + return (qpol_syn_avrule_t*)x; + }; +%} + +/* qpol syn te rule */ +typedef struct qpol_syn_terule {} qpol_syn_terule_t; +%extend qpol_syn_terule_t { + qpol_syn_terule_t() { + BEGIN_EXCEPTION + SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_syn_terule_t objects"); + END_EXCEPTION + fail: + return NULL; + }; + ~qpol_syn_terule_t() { + /* no op */ + return; + }; + int get_rule_type(qpol_policy_t *p) { + uint32_t rt; + BEGIN_EXCEPTION + if (qpol_syn_terule_get_rule_type(p, self, &rt)) { + SWIG_exception(SWIG_ValueError, "Could not get rule type for syn te rule"); + } + END_EXCEPTION + fail: + return rt; + }; + const qpol_type_set_t *get_source_type_set(qpol_policy_t *p) { + const qpol_type_set_t *ts; + BEGIN_EXCEPTION + if (qpol_syn_terule_get_source_type_set(p, self, &ts)) { + SWIG_exception(SWIG_ValueError, "Could not get source type set for syn te rule"); + } + END_EXCEPTION + fail: + return ts; + }; + const qpol_type_set_t *get_target_type_set(qpol_policy_t *p) { + const qpol_type_set_t *ts; + BEGIN_EXCEPTION + if (qpol_syn_terule_get_target_type_set(p, self, &ts)) { + SWIG_exception(SWIG_ValueError, "Could not get target type set for syn te rule"); + } + END_EXCEPTION + fail: + return ts; + }; + %newobject get_class_iter(qpol_policy_t*); + qpol_iterator_t *get_class_iter(qpol_policy_t *p) { + qpol_iterator_t *iter; + BEGIN_EXCEPTION + if (qpol_syn_terule_get_class_iter(p, self, &iter)) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return iter; + }; + const qpol_type_t *get_default_type(qpol_policy_t *p) { + const qpol_type_t *t; + BEGIN_EXCEPTION + if (qpol_syn_terule_get_default_type(p, self, &t)) { + SWIG_exception(SWIG_ValueError, "Could not get default type for syn te rule"); + } + END_EXCEPTION + fail: + return t; + }; + long get_lineno(qpol_policy_t *p) { + unsigned long l; + BEGIN_EXCEPTION + if (qpol_syn_terule_get_lineno(p, self, &l)) { + SWIG_exception(SWIG_ValueError, "Could not get line number for syn te rule"); + } + END_EXCEPTION + fail: + return (long)l; + }; + const qpol_cond_t *get_cond(qpol_policy_t *p) { + const qpol_cond_t *c; + BEGIN_EXCEPTION + if (qpol_syn_terule_get_cond(p, self, &c)) { + SWIG_exception(SWIG_ValueError, "Could not get conditional for syn te rule"); + } + END_EXCEPTION + fail: + return c; + }; + int get_is_enabled(qpol_policy_t *p) { + uint32_t e; + BEGIN_EXCEPTION + if (qpol_syn_terule_get_is_enabled(p, self, &e)) { + SWIG_exception(SWIG_ValueError, "Could not determine if syn te rule is enabled"); + } + END_EXCEPTION + fail: + return (int) e; + }; +}; +%inline %{ + qpol_syn_terule_t *qpol_syn_terule_from_void(void *x) { + return (qpol_syn_terule_t*)x; + }; +%} +// vim:ft=c noexpandtab |