| /** |
| * 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 <sys/stat.h> |
| #include <arpa/inet.h> |
| #include <sepol/policydb.h> |
| #include <sepol/policydb/policydb.h> |
| #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" |
| #include "include/qpol/xen_query.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; |
| |
| %} |
| |
| %include exception.i |
| %include stdint.i |
| |
| /* handle size_t as architecture dependent */ |
| #ifdef SWIGWORDSIZE64 |
| typedef uint64_t size_t; |
| #else |
| typedef uint32_t size_t; |
| #endif |
| |
| %inline %{ |
| /* cast void * to char * as it can't have a constructor */ |
| const char * to_str(void *x) { |
| return (const char *)x; |
| } |
| |
| /* cast a void * to int, while freeing the pointer */ |
| int to_int_with_free(void *x) { |
| int i = *(int *)x; |
| free(x); |
| return i; |
| } |
| %} |
| %{ |
| /* C Bridge to Python logging callback */ |
| __attribute__ ((format(printf, 4, 0))) |
| static void qpol_log_callback(void *varg, |
| const qpol_policy_t * p __attribute__ ((unused)), |
| int level, |
| const char *fmt, |
| va_list va_args) |
| { |
| /* Expand to a full string to avoid any C format string |
| * or variable args handling when passing to Python |
| */ |
| |
| PyObject *py_callback, *rc; |
| char *str = NULL; |
| |
| if(vasprintf(&str, fmt, va_args) < 0) |
| return; |
| |
| py_callback = (PyObject *) varg; |
| |
| /* this char* casting doesn't make sense, but this runs afoul of -Werror |
| * otherwise as the Python library doesn't do const char* */ |
| rc = PyObject_CallFunction(py_callback, (char*)"(is)", level, str); |
| Py_XDECREF(rc); |
| free(str); |
| } |
| %} |
| |
| %pythoncode %{ |
| import logging |
| from functools import wraps |
| |
| def QpolGenerator(cast): |
| """ |
| A decorator which converts qpol iterators into Python generators. |
| |
| Qpol iterators use void* to be generic about their contents. |
| The purpose of the _from_void functions below is to wrap |
| the pointer casting, hence the "cast" variable name here. |
| |
| Decorator parameter: |
| cast A wrapper function which casts the qpol iterator return pointer |
| to the proper C data type pointer. The Python function |
| reference to the C Python extension is used, for example: |
| |
| @QpolGenerator(_qpol.qpol_type_from_void) |
| """ |
| |
| def decorate(func): |
| @wraps(func) |
| def wrapper(*args, **kwargs): |
| qpol_iter = func(*args) |
| while not qpol_iter.isend(): |
| yield cast(qpol_iter.item()) |
| qpol_iter.next_() |
| |
| return wrapper |
| return decorate |
| |
| def qpol_logger(level, msg): |
| """Log qpol messages via Python logging.""" |
| logging.getLogger(__name__).debug(msg) |
| |
| def qpol_policy_factory(path): |
| """Factory function for qpol policy objects.""" |
| # The main purpose here is to hook in the |
| # above logger callback. |
| return qpol_policy_t(path, 0, qpol_logger) |
| %} |
| |
| /* qpol_policy */ |
| #define QPOL_POLICY_OPTION_NO_NEVERALLOWS 0x00000001 |
| #define QPOL_POLICY_OPTION_NO_RULES 0x00000002 |
| #define QPOL_POLICY_OPTION_MATCH_SYSTEM 0x00000004 |
| /* add maximum and minimum policy versions supported by the statically linked libsepol */ |
| %constant int QPOL_POLICY_MAX_VERSION = POLICYDB_VERSION_MAX; |
| %constant int QPOL_POLICY_MIN_VERSION = POLICYDB_VERSION_MIN; |
| 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); |
| |
| 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_CAP_POLCAPS, |
| QPOL_CAP_BOUNDS, |
| QPOL_CAP_DEFAULT_OBJECTS, |
| QPOL_CAP_DEFAULT_TYPE, |
| QPOL_CAP_PERMISSIVE, |
| QPOL_CAP_FILENAME_TRANS, |
| QPOL_CAP_ROLETRANS, |
| QPOL_CAP_XPERM_IOCTL |
| } qpol_capability_e; |
| %exception qpol_policy { |
| $action |
| if (!result) { |
| if (errno == EINVAL) { |
| PyErr_SetString(PyExc_SyntaxError, "Invalid policy."); |
| } else { |
| PyErr_SetFromErrnoWithFilename(PyExc_OSError, arg1); |
| } |
| return NULL; |
| } |
| } |
| %extend qpol_policy { |
| qpol_policy(const char *path, const int options, PyObject *py_callback) { |
| qpol_policy_t *p; |
| |
| if (!PyCallable_Check(py_callback)) { |
| PyErr_SetString(PyExc_TypeError, "Callback parameter must be callable"); |
| return NULL; |
| } |
| |
| qpol_policy_open_from_file(path, &p, qpol_log_callback, (void*)py_callback, options); |
| return p; |
| } |
| ~qpol_policy() { |
| qpol_policy_destroy(&self); |
| }; |
| |
| int 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; |
| }; |
| |
| const char *handle_unknown () { |
| unsigned int h; |
| qpol_policy_get_policy_handle_unknown(self, &h); |
| |
| switch (h) { |
| case SEPOL_DENY_UNKNOWN: return "deny"; |
| case SEPOL_REJECT_UNKNOWN: return "reject"; |
| case SEPOL_ALLOW_UNKNOWN: return "allow"; |
| default: return "unknown"; |
| } |
| }; |
| |
| /* This is whether SELinux or XEN policy */ |
| const char *target_platform () { |
| int t; |
| (void)qpol_policy_get_target_platform(self, &t); |
| switch (t) { |
| case SEPOL_TARGET_SELINUX: return "selinux"; |
| case SEPOL_TARGET_XEN: return "xen"; |
| default: return "unknown"; |
| } |
| }; |
| |
| int capability (qpol_capability_e cap) { |
| return qpol_policy_has_capability(self, cap); |
| }; |
| |
| %newobject type_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_type_from_void) %} |
| qpol_iterator_t *type_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_type_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t type_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_type_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject role_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_role_from_void) %} |
| qpol_iterator_t *role_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_role_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t role_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_role_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject level_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_level_from_void) %} |
| qpol_iterator_t *level_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_level_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t level_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_level_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject cat_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_cat_from_void) %} |
| qpol_iterator_t *cat_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_cat_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t cat_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_cat_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject user_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_user_from_void) %} |
| qpol_iterator_t *user_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_user_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t user_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_user_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| |
| %newobject bool_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_bool_from_void) %} |
| qpol_iterator_t *bool_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_bool_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t bool_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_bool_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject class_iter(char*); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_class_from_void) %} |
| qpol_iterator_t *class_iter(char *perm=NULL) { |
| 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; |
| fail: |
| return NULL; |
| }; |
| |
| size_t class_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_class_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject common_iter(char*); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_common_from_void) %} |
| qpol_iterator_t *common_iter(char *perm=NULL) { |
| 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; |
| fail: |
| return NULL; |
| }; |
| |
| size_t common_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_common_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject fs_use_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_fs_use_from_void) %} |
| qpol_iterator_t *fs_use_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_fs_use_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t fs_use_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_fs_use_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject genfscon_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_genfscon_from_void) %} |
| qpol_iterator_t *genfscon_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_genfscon_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t genfscon_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_genfscon_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject isid_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_isid_from_void) %} |
| qpol_iterator_t *isid_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_isid_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t isid_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_isid_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject netifcon_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_netifcon_from_void) %} |
| qpol_iterator_t *netifcon_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_netifcon_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t netifcon_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_netifcon_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject nodecon_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_nodecon_from_void) %} |
| qpol_iterator_t *nodecon_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_nodecon_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t nodecon_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_nodecon_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject portcon_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_portcon_from_void) %} |
| qpol_iterator_t *portcon_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_portcon_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t portcon_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_portcon_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject constraint_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_constraint_from_void) %} |
| qpol_iterator_t *constraint_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_constraint_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t constraint_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_constraint_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject validatetrans_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_validatetrans_from_void) %} |
| qpol_iterator_t *validatetrans_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_validatetrans_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t validatetrans_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_validatetrans_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject role_allow_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_role_allow_from_void) %} |
| qpol_iterator_t *role_allow_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_role_allow_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t role_allow_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_role_allow_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject role_trans_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_role_trans_from_void) %} |
| qpol_iterator_t *role_trans_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_role_trans_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t role_trans_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_role_trans_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject range_trans_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_range_trans_from_void) %} |
| qpol_iterator_t *range_trans_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_range_trans_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t range_trans_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_range_trans_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject avrule_iter(int); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_avrule_from_void) %} |
| qpol_iterator_t *avrule_iter() { |
| qpol_iterator_t *iter; |
| uint32_t rule_types = QPOL_RULE_ALLOW | QPOL_RULE_AUDITALLOW | QPOL_RULE_DONTAUDIT; |
| |
| if (qpol_policy_has_capability(self, QPOL_CAP_NEVERALLOW)) |
| rule_types |= QPOL_RULE_NEVERALLOW; |
| |
| if (qpol_policy_get_avrule_iter(self, rule_types, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t avrule_allow_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_avrule_iter(self, QPOL_RULE_ALLOW, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| size_t avrule_auditallow_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_avrule_iter(self, QPOL_RULE_AUDITALLOW, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| size_t avrule_neverallow_count() { |
| if (qpol_policy_has_capability(self, QPOL_CAP_NEVERALLOW)) { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_avrule_iter(self, QPOL_RULE_NEVERALLOW, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| } else { |
| return 0; |
| } |
| fail: |
| return 0; |
| }; |
| |
| size_t avrule_dontaudit_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_avrule_iter(self, QPOL_RULE_DONTAUDIT, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject avulex_iter(int); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_avrule_from_void) %} |
| qpol_iterator_t *avrulex_iter() { |
| qpol_iterator_t *iter; |
| uint32_t rule_types = QPOL_RULE_XPERMS_ALLOW | QPOL_RULE_XPERMS_AUDITALLOW | QPOL_RULE_XPERMS_DONTAUDIT; |
| |
| if (qpol_policy_has_capability(self, QPOL_CAP_NEVERALLOW)) |
| rule_types |= QPOL_RULE_XPERMS_NEVERALLOW; |
| |
| if (qpol_policy_get_avrule_iter(self, rule_types, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t avrule_allowx_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_avrule_iter(self, QPOL_RULE_XPERMS_ALLOW, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| size_t avrule_auditallowx_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_avrule_iter(self, QPOL_RULE_XPERMS_AUDITALLOW, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| size_t avrule_neverallowx_count() { |
| if (qpol_policy_has_capability(self, QPOL_CAP_NEVERALLOW)) { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_avrule_iter(self, QPOL_RULE_XPERMS_NEVERALLOW, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| } else { |
| return 0; |
| } |
| fail: |
| return 0; |
| }; |
| |
| size_t avrule_dontauditx_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_avrule_iter(self, QPOL_RULE_XPERMS_DONTAUDIT, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject terule_iter(int); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_terule_from_void) %} |
| qpol_iterator_t *terule_iter() { |
| qpol_iterator_t *iter; |
| uint32_t rule_types = QPOL_RULE_TYPE_TRANS | QPOL_RULE_TYPE_CHANGE | QPOL_RULE_TYPE_MEMBER; |
| |
| if (qpol_policy_get_terule_iter(self, rule_types, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t terule_trans_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_terule_iter(self, QPOL_RULE_TYPE_TRANS, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| size_t terule_change_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_terule_iter(self, QPOL_RULE_TYPE_CHANGE, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| size_t terule_member_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_terule_iter(self, QPOL_RULE_TYPE_MEMBER, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject cond_iter(); |
| qpol_iterator_t *cond_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_cond_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t cond_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_cond_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject filename_trans_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_filename_trans_from_void) %} |
| qpol_iterator_t *filename_trans_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_filename_trans_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t filename_trans_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_filename_trans_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject permissive_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_type_from_void) %} |
| qpol_iterator_t *permissive_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_permissive_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t permissive_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_permissive_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject typebounds_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_typebounds_from_void) %} |
| qpol_iterator_t *typebounds_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_typebounds_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| %newobject polcap_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_polcap_from_void) %} |
| qpol_iterator_t *polcap_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_polcap_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t polcap_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_polcap_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject default_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_default_object_from_void) %} |
| qpol_iterator_t *default_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_default_object_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| %newobject iomemcon_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_iomemcon_from_void) %} |
| qpol_iterator_t *iomemcon_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_iomemcon_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| size_t iomemcon_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_iomemcon_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject ioportcon_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_ioportcon_from_void) %} |
| qpol_iterator_t *ioportcon_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_ioportcon_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| |
| size_t ioportcon_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_ioportcon_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject pcidevicecon_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_pcidevicecon_from_void) %} |
| qpol_iterator_t *pcidevicecon_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_pcidevicecon_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| size_t pcidevicecon_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_pcidevicecon_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject pirqcon_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_pirqcon_from_void) %} |
| qpol_iterator_t *pirqcon_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_pirqcon_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| size_t pirqcon_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_pirqcon_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| |
| %newobject devicetreecon_iter(); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_devicetreecon_from_void) %} |
| qpol_iterator_t *devicetreecon_iter() { |
| qpol_iterator_t *iter; |
| if (qpol_policy_get_devicetreecon_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| return iter; |
| fail: |
| return NULL; |
| }; |
| size_t devicetreecon_count() { |
| qpol_iterator_t *iter; |
| size_t count = 0; |
| if (qpol_policy_get_devicetreecon_iter(self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| qpol_iterator_get_size(iter, &count); |
| return count; |
| fail: |
| return 0; |
| }; |
| }; |
| |
| /* qpol iterator */ |
| typedef struct qpol_iterator {} qpol_iterator_t; |
| %extend qpol_iterator { |
| /* user never directly creates, but SWIG expects a constructor */ |
| qpol_iterator() { |
| SWIG_exception(SWIG_TypeError, "User may not create iterators difectly"); |
| fail: |
| return NULL; |
| }; |
| ~qpol_iterator() { |
| qpol_iterator_destroy(&self); |
| }; |
| void *item() { |
| void *i; |
| if (qpol_iterator_get_item(self, &i)) { |
| SWIG_exception(SWIG_RuntimeError, "Could not get item"); |
| } |
| return i; |
| fail: |
| return NULL; |
| }; |
| void next_() { |
| if (qpol_iterator_next(self)) { |
| SWIG_exception(SWIG_RuntimeError, "Error advancing iterator"); |
| } |
| fail: |
| return; |
| }; |
| int isend() { |
| return qpol_iterator_end(self); |
| }; |
| size_t size() { |
| size_t s; |
| if (qpol_iterator_get_size(self, &s)) { |
| SWIG_exception(SWIG_ValueError, "Could not get iterator size"); |
| } |
| return s; |
| fail: |
| return 0; |
| }; |
| }; |
| |
| /* qpol type */ |
| typedef struct qpol_type {} qpol_type_t; |
| %extend qpol_type { |
| %exception qpol_type { |
| $action |
| if (!result) { |
| PyErr_SetString(PyExc_ValueError, "Invalid type or attribute."); |
| return NULL; |
| } |
| } |
| qpol_type(qpol_policy_t *p, const char *name) { |
| const qpol_type_t *t; |
| qpol_policy_get_type_by_name(p, name, &t); |
| return (qpol_type_t*)t; |
| }; |
| ~qpol_type() { |
| /* no op */ |
| return; |
| }; |
| const char *name(qpol_policy_t *p) { |
| const char *name; |
| if (qpol_type_get_name(p, self, &name)) { |
| SWIG_exception(SWIG_ValueError, "Could not get type name"); |
| } |
| return name; |
| fail: |
| return NULL; |
| }; |
| int value(qpol_policy_t *p) { |
| uint32_t v; |
| if (qpol_type_get_value(p, self, &v)) { |
| SWIG_exception(SWIG_ValueError, "Could not get type value"); |
| } |
| fail: |
| return (int) v; |
| }; |
| int isalias(qpol_policy_t *p) { |
| unsigned char i; |
| if (qpol_type_get_isalias(p, self, &i)) { |
| SWIG_exception(SWIG_ValueError, "Could not determine whether type is an alias"); |
| } |
| fail: |
| return (int)i; |
| }; |
| int isattr(qpol_policy_t *p) { |
| unsigned char i; |
| if (qpol_type_get_isattr(p, self, &i)) { |
| SWIG_exception(SWIG_ValueError, "Could not determine whether type is an attribute"); |
| } |
| fail: |
| return (int)i; |
| }; |
| int ispermissive(qpol_policy_t *p) { |
| unsigned char i; |
| if (qpol_type_get_ispermissive(p, self, &i)) { |
| SWIG_exception(SWIG_ValueError, "Could not determine whether type is permissive"); |
| } |
| fail: |
| return (int)i; |
| }; |
| |
| %newobject type_iter(qpol_policy_t*); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_type_from_void) %} |
| qpol_iterator_t *type_iter(qpol_policy_t *p) { |
| qpol_iterator_t *iter; |
| 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"); |
| } |
| fail: |
| return iter; |
| }; |
| |
| %newobject attr_iter(qpol_policy_t*); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_type_from_void) %} |
| qpol_iterator_t *attr_iter(qpol_policy_t *p) { |
| qpol_iterator_t *iter; |
| 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"); |
| } |
| fail: |
| return iter; |
| }; |
| |
| %newobject alias_iter(qpol_policy_t*); |
| %pythoncode %{ @QpolGenerator(_qpol.to_str) %} |
| qpol_iterator_t *alias_iter(qpol_policy_t *p) { |
| qpol_iterator_t *iter; |
| if (qpol_type_get_alias_iter(p, self, &iter)) { |
| SWIG_exception(SWIG_RuntimeError, "Could not get type aliases"); |
| } |
| fail: |
| return iter; |
| }; |
| |
| const char *name(qpol_policy_t *p) { |
| const char *name; |
| if (qpol_permissive_get_name(p, self, &name)) { |
| SWIG_exception(SWIG_ValueError, "Could not get permissive type name"); |
| } |
| return name; |
| fail: |
| return NULL; |
| }; |
| }; |
| %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 { |
| %exception qpol_role { |
| $action |
| if (!result) { |
| PyErr_SetString(PyExc_ValueError, "Invalid type or attribute."); |
| return NULL; |
| } |
| } |
| qpol_role(qpol_policy_t *p, const char *name) { |
| const qpol_role_t *r; |
| qpol_policy_get_role_by_name(p, name, &r); |
| return (qpol_role_t*)r; |
| }; |
| ~qpol_role() { |
| /* no op */ |
| return; |
| }; |
| int value (qpol_policy_t *p) { |
| uint32_t v; |
| if (qpol_role_get_value(p, self, &v)) { |
| SWIG_exception(SWIG_ValueError, "Could not get role value"); |
| } |
| fail: |
| return (int) v; |
| }; |
| const char *name(qpol_policy_t *p) { |
| const char *name; |
| if (qpol_role_get_name(p, self, &name)) { |
| SWIG_exception(SWIG_ValueError, "Could not get role name"); |
| } |
| return name; |
| fail: |
| return NULL; |
| }; |
| |
| %newobject type_iter(qpol_policy_t*); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_type_from_void) %} |
| qpol_iterator_t *type_iter(qpol_policy_t *p) { |
| qpol_iterator_t *iter; |
| if (qpol_role_get_type_iter(p, self, &iter)) { |
| SWIG_exception(SWIG_RuntimeError, "Could not get role types"); |
| } |
| fail: |
| return iter; |
| }; |
| |
| %newobject dominate_iter(qpol_policy_t*); |
| qpol_iterator_t *dominate_iter(qpol_policy_t *p) { |
| qpol_iterator_t *iter; |
| if (qpol_role_get_dominate_iter(p, self, &iter)) { |
| SWIG_exception(SWIG_RuntimeError, "Could not get dominated roles"); |
| } |
| 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 { |
| %exception qpol_level { |
| $action |
| if (!result) { |
| if (errno == EINVAL) { |
| PyErr_SetString(PyExc_ValueError, "Invalid level."); |
| } else { |
| PyErr_SetFromErrno(PyExc_OSError); |
| } |
| |
| return NULL; |
| } |
| } |
| qpol_level(qpol_policy_t *p, const char *name) { |
| const qpol_level_t *l; |
| qpol_policy_get_level_by_name(p, name, &l); |
| return (qpol_level_t*)l; |
| }; |
| |
| ~qpol_level() { |
| /* no op */ |
| return; |
| }; |
| int isalias(qpol_policy_t *p) { |
| unsigned char i; |
| if (qpol_level_get_isalias(p, self, &i)) { |
| SWIG_exception(SWIG_ValueError, "Could not determine whether level is an alias"); |
| } |
| fail: |
| return (int)i; |
| }; |
| int value(qpol_policy_t *p) { |
| uint32_t v; |
| if (qpol_level_get_value(p, self, &v)) { |
| SWIG_exception(SWIG_ValueError, "Could not get level sensitivity value"); |
| } |
| fail: |
| return (int) v; |
| }; |
| const char *name(qpol_policy_t *p) { |
| const char *name; |
| if (qpol_level_get_name(p, self, &name)) { |
| SWIG_exception(SWIG_ValueError, "Could not get level sensitivity name"); |
| } |
| return name; |
| fail: |
| return NULL; |
| }; |
| |
| %newobject cat_iter(qpol_policy_t*); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_cat_from_void) %} |
| qpol_iterator_t *cat_iter(qpol_policy_t *p) { |
| qpol_iterator_t *iter; |
| if (qpol_level_get_cat_iter(p, self, &iter)) { |
| SWIG_exception(SWIG_RuntimeError, "Could not get level categories"); |
| } |
| fail: |
| return iter; |
| }; |
| |
| %newobject alias_iter(qpol_policy_t*); |
| %pythoncode %{ @QpolGenerator(_qpol.to_str) %} |
| qpol_iterator_t *alias_iter(qpol_policy_t *p) { |
| qpol_iterator_t *iter; |
| if (qpol_level_get_alias_iter(p, self, &iter)) { |
| SWIG_exception(SWIG_RuntimeError, "Could not get level aliases"); |
| } |
| 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 { |
| %exception qpol_cat { |
| $action |
| if (!result) { |
| if (errno == EINVAL) { |
| PyErr_SetString(PyExc_ValueError, "Invalid category."); |
| } else { |
| PyErr_SetFromErrno(PyExc_OSError); |
| } |
| |
| return NULL; |
| } |
| } |
| qpol_cat(qpol_policy_t *p, const char *name) { |
| const qpol_cat_t *c; |
| qpol_policy_get_cat_by_name(p, name, &c); |
| return (qpol_cat_t*)c; |
| }; |
| |
| ~qpol_cat() { |
| /* no op */ |
| return; |
| }; |
| int isalias(qpol_policy_t *p) { |
| unsigned char i; |
| if (qpol_cat_get_isalias(p, self, &i)) { |
| SWIG_exception(SWIG_ValueError, "Could not determine whether category is an alias"); |
| } |
| fail: |
| return (int)i; |
| }; |
| int value(qpol_policy_t *p) { |
| uint32_t v; |
| if (qpol_cat_get_value(p, self, &v)) { |
| SWIG_exception(SWIG_ValueError, "Could not get category value"); |
| } |
| fail: |
| return (int) v; |
| }; |
| const char *name(qpol_policy_t *p) { |
| const char *name; |
| if (qpol_cat_get_name(p, self, &name)) { |
| SWIG_exception(SWIG_ValueError, "Could not get category name"); |
| } |
| return name; |
| fail: |
| return NULL; |
| }; |
| %newobject alias_iter(qpol_policy_t*); |
| %pythoncode %{ @QpolGenerator(_qpol.to_str) %} |
| qpol_iterator_t *alias_iter(qpol_policy_t *p) { |
| qpol_iterator_t *iter; |
| if (qpol_cat_get_alias_iter(p, self, &iter)) { |
| SWIG_exception(SWIG_RuntimeError, "Could not get category aliases"); |
| } |
| 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 { |
| /* |
| * TODO: determine how to conditionally destroy this range. |
| * It should only be destroyed if it was looked up (user-entered) |
| * Otherwise qpol will destroy the others when the policy closes. |
| */ |
| %exception qpol_mls_range { |
| $action |
| if (!result) { |
| if (errno == EINVAL) { |
| PyErr_SetString(PyExc_ValueError, "Invalid range."); |
| } else { |
| PyErr_SetFromErrno(PyExc_OSError); |
| } |
| |
| return NULL; |
| } |
| } |
| |
| qpol_mls_range(qpol_policy_t *p, qpol_mls_level_t *l, qpol_mls_level_t *h) { |
| qpol_mls_range_t *range; |
| qpol_policy_get_mls_range_from_mls_levels(p, l, h, &range); |
| return range; |
| } |
| |
| ~qpol_mls_range() { |
| /* no op */ |
| return; |
| }; |
| const qpol_mls_level_t *high_level(qpol_policy_t *p) { |
| const qpol_mls_level_t *l; |
| if (qpol_mls_range_get_high_level(p, self, &l)) { |
| SWIG_exception(SWIG_ValueError, "Could not get range high levl"); |
| } |
| fail: |
| return l; |
| }; |
| const qpol_mls_level_t *low_level(qpol_policy_t *p) { |
| const qpol_mls_level_t *l; |
| if (qpol_mls_range_get_low_level(p, self, &l)) { |
| SWIG_exception(SWIG_ValueError, "Could not get range low levl"); |
| } |
| fail: |
| return l; |
| }; |
| }; |
| %inline %{ |
| qpol_mls_range_t *qpol_mls_range_from_void(void *x) { |
| return (qpol_mls_range_t*)x; |
| }; |
| %} |
| |
| /* qpol semantic mls level */ |
| typedef struct qpol_semantic_level {} qpol_semantic_level_t; |
| %extend qpol_semantic_level { |
| %exception qpol_semantic_level { |
| $action |
| if (!result) { |
| PyErr_SetString(PyExc_ValueError, "Invalid sensitivity name."); |
| return NULL; |
| } |
| } |
| |
| qpol_semantic_level(qpol_policy_t *p, const char *name) { |
| const qpol_semantic_level_t *l; |
| qpol_policy_get_semantic_level_by_name(p, name, &l); |
| return (qpol_semantic_level_t*)l; |
| }; |
| |
| ~qpol_semantic_level() { |
| qpol_semantic_level_destroy(self); |
| return; |
| }; |
| |
| %exception add_cats { |
| $action |
| if (result) { |
| PyErr_SetString(PyExc_ValueError, "Invalid category name or category range."); |
| return NULL; |
| } |
| } |
| int add_cats(qpol_policy_t *p, const char *low, const char *high) { |
| return qpol_semantic_level_add_cats_by_name(p, self, low, high); |
| } |
| }; |
| |
| /* qpol mls level */ |
| typedef struct qpol_mls_level {} qpol_mls_level_t; |
| %extend qpol_mls_level { |
| %exception qpol_mls_level { |
| $action |
| if (!result) { |
| PyErr_SetString(PyExc_ValueError, "Invalid level."); |
| return NULL; |
| } |
| } |
| |
| qpol_mls_level(qpol_policy_t *p, qpol_semantic_level_t *l) { |
| qpol_mls_level_t *level; |
| qpol_mls_level_from_semantic_level(p, l, &level); |
| return level; |
| } |
| |
| ~qpol_mls_level() { |
| /* no op */ |
| return; |
| }; |
| const char *sens_name(qpol_policy_t *p) { |
| const char *name; |
| if (qpol_mls_level_get_sens_name(p, self, &name)) { |
| SWIG_exception(SWIG_ValueError, "Could not get level sensitivity name"); |
| } |
| fail: |
| return name; |
| }; |
| |
| %newobject cat_iter(qpol_policy_t*); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_cat_from_void) %} |
| qpol_iterator_t *cat_iter(qpol_policy_t *p) { |
| qpol_iterator_t *iter; |
| if (qpol_mls_level_get_cat_iter(p, self, &iter)) { |
| SWIG_exception(SWIG_RuntimeError, "Could not get level categories"); |
| } |
| 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 { |
| %exception qpol_user { |
| $action |
| if (!result) { |
| PyErr_SetString(PyExc_ValueError, "Invalid user."); |
| return NULL; |
| } |
| } |
| qpol_user(qpol_policy_t *p, const char *name) { |
| const qpol_user_t *u; |
| qpol_policy_get_user_by_name(p, name, &u); |
| return (qpol_user_t*)u; |
| }; |
| ~qpol_user() { |
| /* no op */ |
| return; |
| }; |
| int value(qpol_policy_t *p) { |
| uint32_t v; |
| if (qpol_user_get_value(p, self, &v)) { |
| SWIG_exception(SWIG_ValueError, "Could not get user value"); |
| } |
| fail: |
| return (int) v; |
| }; |
| |
| %newobject role_iter(qpol_policy_t*); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_role_from_void) %} |
| qpol_iterator_t *role_iter(qpol_policy_t *p) { |
| qpol_iterator_t *iter; |
| if (qpol_user_get_role_iter(p, self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of Memory"); |
| } |
| fail: |
| return iter; |
| }; |
| |
| const qpol_mls_range_t *range(qpol_policy_t *p) { |
| const qpol_mls_range_t *r; |
| if (qpol_user_get_range(p, self, &r)) { |
| SWIG_exception(SWIG_ValueError, "Could not get user range"); |
| } |
| fail: |
| return r; |
| }; |
| const char *name(qpol_policy_t *p) { |
| const char *name; |
| if (qpol_user_get_name(p, self, &name)) { |
| SWIG_exception(SWIG_ValueError, "Could not get user name"); |
| } |
| fail: |
| return name; |
| }; |
| const qpol_mls_level_t *dfltlevel(qpol_policy_t *p) { |
| const qpol_mls_level_t *l; |
| if (qpol_user_get_dfltlevel(p, self, &l)) { |
| SWIG_exception(SWIG_ValueError, "Could not get user default level"); |
| } |
| 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 { |
| qpol_bool(qpol_policy_t *p, const char *name) { |
| qpol_bool_t *b; |
| if (qpol_policy_get_bool_by_name(p, name, &b)) { |
| SWIG_exception(SWIG_RuntimeError, "Boolean does not exist"); |
| } |
| fail: |
| return b; |
| }; |
| ~qpol_bool() { |
| /* no op */ |
| return; |
| }; |
| int value(qpol_policy_t *p) { |
| uint32_t v; |
| if (qpol_bool_get_value(p, self, &v)) { |
| SWIG_exception(SWIG_ValueError, "Could not get boolean value"); |
| } |
| fail: |
| return (int) v; |
| }; |
| int state(qpol_policy_t *p) { |
| int s; |
| if (qpol_bool_get_state(p, self, &s)) { |
| SWIG_exception(SWIG_ValueError, "Could not get boolean state"); |
| } |
| fail: |
| return s; |
| }; |
| |
| const char *name(qpol_policy_t *p) { |
| const char *name; |
| if (qpol_bool_get_name(p, self, &name)) { |
| SWIG_exception(SWIG_ValueError, "Could not get boolean name"); |
| } |
| 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 { |
| qpol_context() { |
| SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_context_t objects"); |
| fail: |
| return NULL; |
| }; |
| ~qpol_context() { |
| /* no op */ |
| return; |
| }; |
| const qpol_user_t *user(qpol_policy_t *p) { |
| const qpol_user_t *u; |
| if (qpol_context_get_user(p, self, &u)) { |
| SWIG_exception(SWIG_ValueError, "Could not get user from context"); |
| } |
| fail: |
| return u; |
| }; |
| const qpol_role_t *role(qpol_policy_t *p) { |
| const qpol_role_t *r; |
| if (qpol_context_get_role(p, self, &r)) { |
| SWIG_exception(SWIG_ValueError, "Could not get role from context"); |
| } |
| fail: |
| return r; |
| }; |
| const qpol_type_t *type_(qpol_policy_t *p) { |
| const qpol_type_t *t; |
| if (qpol_context_get_type(p, self, &t)) { |
| SWIG_exception(SWIG_ValueError, "Could not get type from context"); |
| } |
| fail: |
| return t; |
| }; |
| const qpol_mls_range_t *range(qpol_policy_t *p) { |
| const qpol_mls_range_t *r; |
| if (qpol_context_get_range(p, self, &r)) { |
| SWIG_exception(SWIG_ValueError, "Could not get range from context"); |
| } |
| 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 { |
| %exception qpol_class { |
| $action |
| if (!result) { |
| if (errno == EINVAL) { |
| PyErr_SetString(PyExc_ValueError, "Invalid class."); |
| } else { |
| PyErr_SetFromErrno(PyExc_OSError); |
| } |
| |
| return NULL; |
| } |
| } |
| qpol_class(qpol_policy_t *p, const char *name) { |
| const qpol_class_t *c; |
| qpol_policy_get_class_by_name(p, name, &c); |
| return (qpol_class_t*)c; |
| }; |
| |
| ~qpol_class() { |
| /* no op */ |
| return; |
| }; |
| int value(qpol_policy_t *p) { |
| uint32_t v; |
| if (qpol_class_get_value(p, self, &v)) { |
| SWIG_exception(SWIG_ValueError, "Could not get value for class"); |
| } |
| fail: |
| return (int) v; |
| }; |
| |
| %exception common { |
| $action |
| if (!result) { |
| PyErr_SetString(PyExc_ValueError, "Class does not inherit a common."); |
| return NULL; |
| } |
| } |
| const qpol_common_t *common(qpol_policy_t *p) { |
| const qpol_common_t *c; |
| if(qpol_class_get_common(p, self, &c)) { |
| SWIG_exception(SWIG_ValueError, "Could not get common for class"); |
| } |
| fail: |
| return c; |
| }; |
| %newobject perm_iter(qpol_policy_t*); |
| %pythoncode %{ @QpolGenerator(_qpol.to_str) %} |
| qpol_iterator_t *perm_iter(qpol_policy_t *p) { |
| qpol_iterator_t *iter; |
| if(qpol_class_get_perm_iter(p, self, &iter)) { |
| SWIG_exception(SWIG_RuntimeError, "Could not get class permissions"); |
| } |
| fail: |
| return iter; |
| }; |
| |
| %newobject constraint_iter(qpol_policy_t*); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_constraint_from_void) %} |
| qpol_iterator_t *constraint_iter(qpol_policy_t *p) { |
| qpol_iterator_t *iter; |
| if(qpol_class_get_constraint_iter(p, self, &iter)) { |
| SWIG_exception(SWIG_RuntimeError, "Could not get class constraints"); |
| } |
| fail: |
| return iter; |
| }; |
| |
| %newobject validatetrans_iter(qpol_policy_t*); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_validatetrans_from_void) %} |
| qpol_iterator_t *validatetrans_iter(qpol_policy_t *p) { |
| qpol_iterator_t *iter; |
| if(qpol_class_get_validatetrans_iter(p, self, &iter)) { |
| SWIG_exception(SWIG_RuntimeError, "Could not get class validatetrans statements"); |
| } |
| fail: |
| return iter; |
| }; |
| |
| const char *name(qpol_policy_t *p) { |
| const char *name; |
| if (qpol_class_get_name(p, self, &name)) { |
| SWIG_exception(SWIG_ValueError, "Could not get class name"); |
| } |
| 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 { |
| %exception qpol_common { |
| $action |
| if (!result) { |
| if (errno == EINVAL) { |
| PyErr_SetString(PyExc_ValueError, "Invalid common."); |
| } else { |
| PyErr_SetFromErrno(PyExc_OSError); |
| } |
| |
| return NULL; |
| } |
| } |
| qpol_common(qpol_policy_t *p, const char *name) { |
| const qpol_common_t *c; |
| qpol_policy_get_common_by_name(p, name, &c); |
| return (qpol_common_t*)c; |
| }; |
| |
| ~qpol_common() { |
| /* no op */ |
| return; |
| }; |
| int value(qpol_policy_t *p) { |
| uint32_t v; |
| if (qpol_common_get_value(p, self, &v)) { |
| SWIG_exception(SWIG_ValueError, "Could not get value for common"); |
| } |
| fail: |
| return (int) v; |
| }; |
| |
| %newobject perm_iter(qpol_policy_t*); |
| %pythoncode %{ @QpolGenerator(_qpol.to_str) %} |
| qpol_iterator_t *perm_iter(qpol_policy_t *p) { |
| qpol_iterator_t *iter; |
| if(qpol_common_get_perm_iter(p, self, &iter)) { |
| SWIG_exception(SWIG_RuntimeError, "Could not get common permissions"); |
| } |
| fail: |
| return iter; |
| }; |
| |
| const char *name(qpol_policy_t *p) { |
| const char *name; |
| if (qpol_common_get_name(p, self, &name)) { |
| SWIG_exception(SWIG_ValueError, "Could not get common name"); |
| } |
| 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. */ |
| #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 |
| typedef struct qpol_fs_use {} qpol_fs_use_t; |
| %extend qpol_fs_use { |
| qpol_fs_use(qpol_policy_t *p, const char *name) { |
| const qpol_fs_use_t *f; |
| if (qpol_policy_get_fs_use_by_name(p, name, &f)) { |
| SWIG_exception(SWIG_RuntimeError, "FS Use Statement does not exist"); |
| } |
| fail: |
| return (qpol_fs_use_t*)f; |
| }; |
| ~qpol_fs_use() { |
| /* no op */ |
| return; |
| }; |
| const char *name(qpol_policy_t *p) { |
| const char *name; |
| if (qpol_fs_use_get_name(p, self, &name)) { |
| SWIG_exception(SWIG_ValueError, "Could not get file system name"); |
| } |
| fail: |
| return name; |
| }; |
| int behavior(qpol_policy_t *p) { |
| uint32_t behav; |
| if (qpol_fs_use_get_behavior(p, self, &behav)) { |
| SWIG_exception(SWIG_ValueError, "Could not get file system labeling behavior"); |
| } |
| fail: |
| return (int) behav; |
| }; |
| const qpol_context_t *context(qpol_policy_t *p) { |
| uint32_t behav; |
| const qpol_context_t *ctx = NULL; |
| 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"); |
| } |
| 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 */ |
| #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 |
| typedef struct qpol_genfscon {} qpol_genfscon_t; |
| %extend qpol_genfscon { |
| qpol_genfscon(qpol_policy_t *p, const char *name, const char *path) { |
| qpol_genfscon_t *g; |
| if (qpol_policy_get_genfscon_by_name(p, name, path, &g)) { |
| SWIG_exception(SWIG_RuntimeError, "Genfscon statement does not exist"); |
| } |
| fail: |
| return g; |
| }; |
| ~qpol_genfscon() { |
| free(self); |
| }; |
| const char *name(qpol_policy_t *p) { |
| const char *name; |
| if (qpol_genfscon_get_name(p, self, &name)) { |
| SWIG_exception(SWIG_ValueError, "Could not get file system name"); |
| } |
| fail: |
| return name; |
| }; |
| const char *path(qpol_policy_t *p) { |
| const char *path; |
| if (qpol_genfscon_get_path(p, self, &path)) { |
| SWIG_exception(SWIG_ValueError, "Could not get file system path"); |
| } |
| fail: |
| return path; |
| }; |
| unsigned int object_class(qpol_policy_t *p) { |
| uint32_t cls; |
| if (qpol_genfscon_get_class(p, self, &cls)) { |
| SWIG_exception(SWIG_ValueError, "Could not get genfscon statement class"); |
| } |
| switch (cls) { |
| case QPOL_CLASS_BLK_FILE: return S_IFBLK; |
| case QPOL_CLASS_CHR_FILE: return S_IFCHR; |
| case QPOL_CLASS_DIR: return S_IFDIR; |
| case QPOL_CLASS_FIFO_FILE: return S_IFIFO; |
| case QPOL_CLASS_FILE: return S_IFREG; |
| case QPOL_CLASS_LNK_FILE: return S_IFLNK; |
| case QPOL_CLASS_SOCK_FILE: return S_IFSOCK; |
| default: return 0; /* all file types */ |
| } |
| fail: |
| return 0; |
| }; |
| const qpol_context_t *context(qpol_policy_t *p) { |
| const qpol_context_t *ctx; |
| if (qpol_genfscon_get_context(p, self, &ctx)) { |
| SWIG_exception(SWIG_ValueError, "Could not get context for genfscon statement"); |
| } |
| 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 { |
| %exception qpol_isid { |
| $action |
| if (!result) { |
| if (errno == EINVAL) { |
| PyErr_SetString(PyExc_ValueError, "Invalid initial sid name."); |
| } else { |
| PyErr_SetFromErrno(PyExc_OSError); |
| } |
| |
| return NULL; |
| } |
| } |
| qpol_isid(qpol_policy_t *p, const char *name) { |
| const qpol_isid_t *i; |
| qpol_policy_get_isid_by_name(p, name, &i); |
| return (qpol_isid_t*)i; |
| }; |
| |
| ~qpol_isid() { |
| /* no op */ |
| return; |
| }; |
| const char *name(qpol_policy_t *p) { |
| const char *name; |
| if (qpol_isid_get_name(p, self, &name)) { |
| SWIG_exception(SWIG_ValueError, "Could not get name for initial sid"); |
| } |
| fail: |
| return name; |
| }; |
| const qpol_context_t *context(qpol_policy_t *p) { |
| const qpol_context_t *ctx; |
| if (qpol_isid_get_context(p, self, &ctx)) { |
| SWIG_exception(SWIG_ValueError, "Could not get context for initial sid"); |
| } |
| 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 { |
| qpol_netifcon(qpol_policy_t *p, const char *name) { |
| const qpol_netifcon_t *n; |
| if (qpol_policy_get_netifcon_by_name(p, name, &n)) { |
| SWIG_exception(SWIG_RuntimeError, "Netifcon statement does not exist"); |
| } |
| fail: |
| return (qpol_netifcon_t*)n; |
| }; |
| ~qpol_netifcon() { |
| /* no op */ |
| return; |
| }; |
| const char *name(qpol_policy_t *p) { |
| const char *name; |
| if (qpol_netifcon_get_name(p, self, &name)) { |
| SWIG_exception(SWIG_ValueError, "Could not get name for netifcon statement"); |
| } |
| fail: |
| return name; |
| }; |
| const qpol_context_t *msg_con(qpol_policy_t *p) { |
| const qpol_context_t *ctx; |
| if (qpol_netifcon_get_msg_con(p, self, &ctx)) { |
| SWIG_exception(SWIG_ValueError, "Could not get message context for netifcon statement"); |
| } |
| fail: |
| return ctx; |
| }; |
| const qpol_context_t *if_con(qpol_policy_t *p) { |
| const qpol_context_t *ctx; |
| if (qpol_netifcon_get_if_con(p, self, &ctx)) { |
| SWIG_exception(SWIG_ValueError, "Could not get interface context for netifcon statement"); |
| } |
| 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 { |
| qpol_nodecon(qpol_policy_t *p, int addr[4], int mask[4], int protocol) { |
| uint32_t a[4], m[4]; |
| qpol_nodecon_t *n; |
| 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"); |
| } |
| fail: |
| return n; |
| } |
| ~qpol_nodecon() { |
| free(self); |
| }; |
| char *addr(qpol_policy_t *p) { |
| uint32_t *a; |
| unsigned char proto; |
| char *addr = NULL; |
| |
| addr = malloc(INET6_ADDRSTRLEN * sizeof(char)); |
| if(!addr) |
| SWIG_exception(SWIG_MemoryError, "Out of memory"); |
| |
| if (qpol_nodecon_get_addr(p, self, &a, &proto)) { |
| SWIG_exception(SWIG_ValueError, "Could not get address of nodecon statement"); |
| } |
| |
| if(proto == QPOL_IPV4) { |
| inet_ntop(AF_INET, a, addr, INET6_ADDRSTRLEN); |
| } else { |
| inet_ntop(AF_INET6, a, addr, INET6_ADDRSTRLEN); |
| } |
| |
| fail: |
| return addr; |
| }; |
| char *mask(qpol_policy_t *p) { |
| uint32_t *m; |
| unsigned char proto; |
| char *mask; |
| mask = malloc(INET6_ADDRSTRLEN * sizeof(char)); |
| if (!mask) |
| SWIG_exception(SWIG_MemoryError, "Out of memory"); |
| |
| if (qpol_nodecon_get_mask(p, self, &m, &proto)) { |
| SWIG_exception(SWIG_ValueError, "Could not get mask of nodecon statement"); |
| } |
| |
| if(proto == QPOL_IPV4) { |
| inet_ntop(AF_INET, m, mask, INET6_ADDRSTRLEN); |
| } else { |
| inet_ntop(AF_INET6, m, mask, INET6_ADDRSTRLEN); |
| } |
| fail: |
| return mask; |
| }; |
| int protocol(qpol_policy_t *p) { |
| unsigned char proto; |
| if (qpol_nodecon_get_protocol(p, self, &proto)) { |
| SWIG_exception(SWIG_ValueError, "Could not get protocol for nodecon statement"); |
| } |
| fail: |
| if(proto == QPOL_IPV4) { |
| return AF_INET; |
| } else { |
| return AF_INET6; |
| } |
| }; |
| const qpol_context_t *context(qpol_policy_t *p) { |
| const qpol_context_t *ctx; |
| if (qpol_nodecon_get_context(p, self, &ctx)) { |
| SWIG_exception(SWIG_ValueError, "Could not get context for nodecon statement"); |
| } |
| 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 { |
| qpol_portcon(qpol_policy_t *p, uint16_t low, uint16_t high, uint8_t protocol) { |
| const qpol_portcon_t *qp; |
| if (qpol_policy_get_portcon_by_port(p, low, high, protocol, &qp)) { |
| SWIG_exception(SWIG_RuntimeError, "Portcon statement does not exist"); |
| } |
| fail: |
| return (qpol_portcon_t*)qp; |
| }; |
| ~qpol_portcon() { |
| /* no op */ |
| return; |
| }; |
| uint16_t low_port(qpol_policy_t *p) { |
| uint16_t port = 0; |
| if(qpol_portcon_get_low_port(p, self, &port)) { |
| SWIG_exception(SWIG_RuntimeError, "Could not get low port for portcon statement"); |
| } |
| fail: |
| return port; |
| }; |
| uint16_t high_port(qpol_policy_t *p) { |
| uint16_t port = 0; |
| if(qpol_portcon_get_high_port(p, self, &port)) { |
| SWIG_exception(SWIG_RuntimeError, "Could not get high port for portcon statement"); |
| } |
| fail: |
| return port; |
| }; |
| uint8_t protocol(qpol_policy_t *p) { |
| uint8_t proto = 0; |
| if (qpol_portcon_get_protocol(p, self, &proto)) { |
| SWIG_exception(SWIG_RuntimeError, "Could not get protocol for portcon statement"); |
| } |
| fail: |
| return proto; |
| }; |
| const qpol_context_t *context(qpol_policy_t *p) { |
| const qpol_context_t *ctx; |
| if (qpol_portcon_get_context(p, self, &ctx)) { |
| SWIG_exception(SWIG_ValueError, "Could not get context for portcon statement"); |
| } |
| 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 { |
| qpol_constraint() { |
| SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_constraint_t objects"); |
| fail: |
| return NULL; |
| }; |
| ~qpol_constraint() { |
| free(self); |
| }; |
| const qpol_class_t *object_class(qpol_policy_t *p) { |
| const qpol_class_t *cls; |
| if (qpol_constraint_get_class(p, self, &cls)) { |
| SWIG_exception(SWIG_ValueError, "Could not get class for constraint"); |
| } |
| fail: |
| return cls; |
| }; |
| |
| %newobject perm_iter(qpol_policy_t*); |
| %pythoncode %{ @QpolGenerator(_qpol.to_str) %} |
| qpol_iterator_t *perm_iter(qpol_policy_t *p) { |
| qpol_iterator_t *iter; |
| if (qpol_constraint_get_perm_iter(p, self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of memory"); |
| } |
| fail: |
| return iter; |
| }; |
| |
| %newobject expr_iter(qpol_policy_t*); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_constraint_expr_node_from_void) %} |
| qpol_iterator_t *expr_iter(qpol_policy_t *p) { |
| qpol_iterator_t *iter; |
| if (qpol_constraint_get_expr_iter(p, self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of memory"); |
| } |
| 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 { |
| qpol_validatetrans() { |
| SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_validatetrans_t objects"); |
| fail: |
| return NULL; |
| }; |
| ~qpol_validatetrans() { |
| free(self); |
| }; |
| const qpol_class_t *object_class(qpol_policy_t *p) { |
| const qpol_class_t *cls; |
| if (qpol_validatetrans_get_class(p, self, &cls)) { |
| SWIG_exception(SWIG_ValueError, "Could not get class for validatetrans"); |
| } |
| fail: |
| return cls; |
| }; |
| %newobject expr_iter(qpol_policy_t*); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_constraint_expr_node_from_void) %} |
| qpol_iterator_t *expr_iter(qpol_policy_t *p) { |
| qpol_iterator_t *iter; |
| if (qpol_validatetrans_get_expr_iter(p, self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of memory"); |
| } |
| 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 { |
| qpol_constraint_expr_node() { |
| SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_constraint_expr_node_t objects"); |
| fail: |
| return NULL; |
| }; |
| ~qpol_constraint_expr_node() { |
| /* no op */ |
| return; |
| }; |
| int expr_type(qpol_policy_t *p) { |
| uint32_t et; |
| if (qpol_constraint_expr_node_get_expr_type(p, self, &et)) { |
| SWIG_exception(SWIG_ValueError, "Could not get expression type for node"); |
| } |
| fail: |
| return (int) et; |
| }; |
| int sym_type(qpol_policy_t *p) { |
| uint32_t st; |
| if (qpol_constraint_expr_node_get_sym_type(p, self, &st)) { |
| SWIG_exception(SWIG_ValueError, "Could not get symbol type for node"); |
| } |
| fail: |
| return (int) st; |
| }; |
| int op(qpol_policy_t *p) { |
| uint32_t op; |
| if (qpol_constraint_expr_node_get_op(p, self, &op)) { |
| SWIG_exception(SWIG_ValueError, "Could not get operator for node"); |
| } |
| fail: |
| return (int) op; |
| }; |
| %newobject names_iter(qpol_policy_t*); |
| %pythoncode %{ @QpolGenerator(_qpol.to_str) %} |
| qpol_iterator_t *names_iter(qpol_policy_t *p) { |
| qpol_iterator_t *iter; |
| if (qpol_constraint_expr_node_get_names_iter(p, self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of memory"); |
| } |
| 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 { |
| qpol_role_allow() { |
| SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_role_allow_t objects"); |
| fail: |
| return NULL; |
| }; |
| ~qpol_role_allow() { |
| /* no op */ |
| return; |
| }; |
| %pythoncode %{ |
| def rule_type(self,policy): |
| return "allow" |
| %} |
| const qpol_role_t *source_role(qpol_policy_t *p) { |
| const qpol_role_t *r; |
| if (qpol_role_allow_get_source_role(p, self, &r)) { |
| SWIG_exception(SWIG_ValueError, "Could not get source for role allow rule"); |
| } |
| fail: |
| return r; |
| }; |
| const qpol_role_t *target_role(qpol_policy_t *p) { |
| const qpol_role_t *r; |
| if (qpol_role_allow_get_target_role(p, self, &r)) { |
| SWIG_exception(SWIG_ValueError, "Could not get target for role allow rule"); |
| } |
| 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 { |
| qpol_role_trans() { |
| SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_role_trans_t objects"); |
| fail: |
| return NULL; |
| }; |
| ~qpol_role_trans() { |
| /* no op */ |
| return; |
| }; |
| %pythoncode %{ |
| def rule_type(self,policy): |
| return "role_transition" |
| %} |
| const qpol_role_t *source_role(qpol_policy_t *p) { |
| const qpol_role_t *r; |
| if (qpol_role_trans_get_source_role(p, self, &r)) { |
| SWIG_exception(SWIG_ValueError, "Could not get source for role_transition rule"); |
| } |
| fail: |
| return r; |
| }; |
| const qpol_type_t *target_type(qpol_policy_t *p) { |
| const qpol_type_t *t; |
| if (qpol_role_trans_get_target_type(p, self, &t)) { |
| SWIG_exception(SWIG_ValueError, "Could not get target for role_transition rule"); |
| } |
| fail: |
| return t; |
| }; |
| const qpol_class_t *object_class(qpol_policy_t *p) { |
| const qpol_class_t *c; |
| if (qpol_role_trans_get_object_class(p, self, &c)) { |
| SWIG_exception(SWIG_ValueError, "Could not get class for role_transition rule"); |
| } |
| fail: |
| return c; |
| }; |
| const qpol_role_t *default_role(qpol_policy_t *p) { |
| const qpol_role_t *r; |
| if (qpol_role_trans_get_default_role(p, self, &r)) { |
| SWIG_exception(SWIG_ValueError, "Could not get default for role_transition rule"); |
| } |
| 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 { |
| qpol_range_trans() { |
| SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_range_trans_t objects"); |
| fail: |
| return NULL; |
| }; |
| ~qpol_range_trans() { |
| /* no op */ |
| return; |
| }; |
| %pythoncode %{ |
| def rule_type(self,policy): |
| return "range_transition" |
| %} |
| |
| const qpol_type_t *source_type (qpol_policy_t *p) { |
| const qpol_type_t *t; |
| if (qpol_range_trans_get_source_type(p, self, &t)) { |
| SWIG_exception(SWIG_ValueError, "Could not get source for range_transition rule"); |
| } |
| fail: |
| return t; |
| }; |
| const qpol_type_t *target_type (qpol_policy_t *p) { |
| const qpol_type_t *t; |
| if (qpol_range_trans_get_target_type(p, self, &t)) { |
| SWIG_exception(SWIG_ValueError, "Could not get target for range_transition rule"); } |
| fail: |
| return t; |
| }; |
| const qpol_class_t *object_class(qpol_policy_t *p) { |
| const qpol_class_t *cls; |
| if (qpol_range_trans_get_target_class(p, self, &cls)) { |
| SWIG_exception(SWIG_ValueError, "Could not get class for range_transition rule"); } |
| fail: |
| return cls; |
| }; |
| const qpol_mls_range_t *range(qpol_policy_t *p) { |
| const qpol_mls_range_t *r; |
| if (qpol_range_trans_get_range(p, self, &r)) { |
| SWIG_exception(SWIG_ValueError, "Could not get range for range_transition rule"); |
| } |
| 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 0x0001 |
| #define QPOL_RULE_NEVERALLOW 0x0080 |
| #define QPOL_RULE_AUDITALLOW 0x0002 |
| #define QPOL_RULE_DONTAUDIT 0x0004 |
| #define QPOL_RULE_XPERMS_ALLOW 0x0100 |
| #define QPOL_RULE_XPERMS_AUDITALLOW 0x0200 |
| #define QPOL_RULE_XPERMS_DONTAUDIT 0x0400 |
| #define QPOL_RULE_XPERMS_NEVERALLOW 0x0800 |
| typedef struct qpol_avrule {} qpol_avrule_t; |
| %extend qpol_avrule { |
| qpol_avrule() { |
| SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_avrule_t objects"); |
| fail: |
| return NULL; |
| }; |
| ~qpol_avrule() { |
| /* no op */ |
| return; |
| }; |
| const char * rule_type(qpol_policy_t *p) { |
| uint32_t rt; |
| if (qpol_avrule_get_rule_type(p, self, &rt)) { |
| SWIG_exception(SWIG_ValueError, "Could not get rule type for av rule"); |
| } |
| switch (rt) { |
| case QPOL_RULE_ALLOW: return "allow"; break; |
| case QPOL_RULE_NEVERALLOW: return "neverallow"; break; |
| case QPOL_RULE_AUDITALLOW: return "auditallow"; break; |
| case QPOL_RULE_DONTAUDIT: return "dontaudit"; break; |
| case QPOL_RULE_XPERMS_ALLOW: return "allowxperm"; break; |
| case QPOL_RULE_XPERMS_NEVERALLOW: return "neverallowxperm"; break; |
| case QPOL_RULE_XPERMS_AUDITALLOW: return "auditallowxperm"; break; |
| case QPOL_RULE_XPERMS_DONTAUDIT: return "dontauditxperm"; break; |
| } |
| fail: |
| return NULL; |
| }; |
| const qpol_type_t *source_type(qpol_policy_t *p) { |
| const qpol_type_t *t; |
| if (qpol_avrule_get_source_type(p, self, &t)) { |
| SWIG_exception(SWIG_ValueError, "Could not get source for av rule"); |
| } |
| fail: |
| return t; |
| }; |
| const qpol_type_t *target_type(qpol_policy_t *p) { |
| const qpol_type_t *t; |
| if (qpol_avrule_get_target_type(p, self, &t)) { |
| SWIG_exception(SWIG_ValueError, "Could not get target for av rule"); |
| } |
| fail: |
| return t; |
| }; |
| const qpol_class_t *object_class(qpol_policy_t *p) { |
| const qpol_class_t *cls; |
| if (qpol_avrule_get_object_class(p, self, &cls)) { |
| SWIG_exception(SWIG_ValueError, "Could not get class for av rule"); |
| } |
| fail: |
| return cls; |
| }; |
| |
| %newobject perm_iter(qpol_policy_t *p); |
| %pythoncode %{ @QpolGenerator(_qpol.to_str) %} |
| qpol_iterator_t *perm_iter(qpol_policy_t *p) { |
| qpol_iterator_t *iter; |
| if (qpol_avrule_get_perm_iter(p, self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of memory"); |
| } |
| fail: |
| return iter; |
| }; |
| |
| /* TODO, do I need an exception (similar to cond) that is thrown if you ask this on a non extended avrule? Likewise for asking for prems an an extended rule */ |
| %newobject xperm_iter(qpol_policy_t *p); |
| %pythoncode %{ @QpolGenerator(_qpol.to_int_with_free) %} |
| qpol_iterator_t *xperm_iter(qpol_policy_t *p) { |
| qpol_iterator_t *iter; |
| if (qpol_avrule_get_xperm_iter(p, self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of memory"); |
| } |
| fail: |
| return iter; |
| }; |
| int is_extended(qpol_policy_t *p) { |
| uint32_t e; |
| if (qpol_avrule_get_is_extended(p, self, &e)) { |
| SWIG_exception(SWIG_ValueError, "Could not determine if av rule is extended"); |
| } |
| fail: |
| return (int) e; |
| }; |
| const char * xperm_type(qpol_policy_t *p) { |
| char *xt; |
| if (qpol_avrule_get_xperm_type(p, self, &xt)) { |
| SWIG_exception(SWIG_ValueError, "Could not get xperm type for av rule"); |
| } |
| fail: |
| return xt; |
| }; |
| |
| %exception cond { |
| $action |
| if (!result) { |
| PyErr_SetString(PyExc_AttributeError, "Rule is not conditional."); |
| return NULL; |
| } |
| } |
| const qpol_cond_t *cond(qpol_policy_t *p) { |
| const qpol_cond_t *c; |
| qpol_avrule_get_cond(p, self, &c); |
| return c; |
| }; |
| int is_enabled(qpol_policy_t *p) { |
| uint32_t e; |
| if (qpol_avrule_get_is_enabled(p, self, &e)) { |
| SWIG_exception(SWIG_ValueError, "Could not determine if av rule is enabled"); |
| } |
| fail: |
| return (int) e; |
| }; |
| |
| %exception which_list { |
| $action |
| if (result < 0) { |
| PyErr_SetString(PyExc_AttributeError, "Rule is not conditional."); |
| return NULL; |
| } |
| } |
| int which_list(qpol_policy_t *p) { |
| const qpol_cond_t *c; |
| uint32_t which = 0; |
| qpol_avrule_get_cond(p, self, &c); |
| if (c == NULL) { |
| return -1; |
| } else if (qpol_avrule_get_which_list(p, self, &which)) { |
| return -1; |
| } |
| return (int) which; |
| }; |
| %newobject syn_avrule_iter(qpol_policy_t*); |
| qpol_iterator_t *syn_avrule_iter(qpol_policy_t *p) { |
| qpol_iterator_t *iter; |
| if (qpol_avrule_get_syn_avrule_iter(p, self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of memory"); |
| } |
| 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 { |
| qpol_terule() { |
| SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_terule_t objects"); |
| fail: |
| return NULL; |
| }; |
| ~qpol_terule() { |
| /* no op */ |
| return; |
| }; |
| const char * rule_type(qpol_policy_t *p) { |
| uint32_t rt; |
| if (qpol_terule_get_rule_type(p, self, &rt)) { |
| SWIG_exception(SWIG_ValueError, "Could not get rule type for te rule"); |
| } |
| switch (rt) { |
| case QPOL_RULE_TYPE_TRANS: return "type_transition"; break; |
| case QPOL_RULE_TYPE_CHANGE: return "type_change"; break; |
| case QPOL_RULE_TYPE_MEMBER: return "type_member"; break; |
| } |
| fail: |
| return NULL; |
| }; |
| const qpol_type_t *source_type(qpol_policy_t *p) { |
| const qpol_type_t *t; |
| if (qpol_terule_get_source_type(p, self, &t)) { |
| SWIG_exception(SWIG_ValueError, "Could not get source for te rule"); |
| } |
| fail: |
| return t; |
| }; |
| const qpol_type_t *target_type(qpol_policy_t *p) { |
| const qpol_type_t *t; |
| if (qpol_terule_get_target_type(p, self, &t)) { |
| SWIG_exception(SWIG_ValueError, "Could not get target for te rule"); |
| } |
| fail: |
| return t; |
| }; |
| const qpol_class_t *object_class(qpol_policy_t *p) { |
| const qpol_class_t *cls; |
| if (qpol_terule_get_object_class(p, self, &cls)) { |
| SWIG_exception(SWIG_ValueError, "Could not get class for te rule"); |
| } |
| fail: |
| return cls; |
| }; |
| const qpol_type_t *default_type(qpol_policy_t *p) { |
| const qpol_type_t *t; |
| if (qpol_terule_get_default_type(p, self, &t)) { |
| SWIG_exception(SWIG_ValueError, "Could not get default for te rule"); |
| } |
| fail: |
| return t; |
| }; |
| |
| %exception cond { |
| $action |
| if (!result) { |
| PyErr_SetString(PyExc_AttributeError, "Rule is not conditional."); |
| return NULL; |
| } |
| } |
| const qpol_cond_t *cond(qpol_policy_t *p) { |
| const qpol_cond_t *c; |
| qpol_terule_get_cond(p, self, &c); |
| return c; |
| }; |
| int is_enabled(qpol_policy_t *p) { |
| uint32_t e; |
| if (qpol_terule_get_is_enabled(p, self, &e)) { |
| SWIG_exception(SWIG_ValueError, "Could not determine if te rule is enabled"); |
| } |
| fail: |
| return (int) e; |
| }; |
| |
| %exception which_list { |
| $action |
| if (result < 0) { |
| PyErr_SetString(PyExc_AttributeError, "Rule is not conditional."); |
| return NULL; |
| } |
| } |
| int which_list(qpol_policy_t *p) { |
| const qpol_cond_t *c; |
| uint32_t which = 0; |
| qpol_terule_get_cond(p, self, &c); |
| if (c == NULL) { |
| return -1; |
| } else if (qpol_terule_get_which_list(p, self, &which)) { |
| return -1; |
| } |
| return (int) which; |
| }; |
| |
| %newobject syn_terule_iter(qpol_policy_t*); |
| qpol_iterator_t *syn_terule_iter(qpol_policy_t *p) { |
| qpol_iterator_t *iter; |
| if (qpol_terule_get_syn_terule_iter(p, self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of memory"); |
| } |
| 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 { |
| qpol_cond() { |
| SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_cond_t objects"); |
| fail: |
| return NULL; |
| }; |
| ~qpol_cond() { |
| /* no op */ |
| return; |
| }; |
| |
| %newobject expr_node_iter(qpol_policy_t*); |
| %pythoncode %{ @QpolGenerator(_qpol.qpol_cond_expr_node_from_void) %} |
| qpol_iterator_t *expr_node_iter(qpol_policy_t *p) { |
| qpol_iterator_t *iter; |
| if (qpol_cond_get_expr_node_iter(p, self, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of memory"); |
| } |
| fail: |
| return iter; |
| }; |
| |
| %newobject av_true_iter(qpol_policy_t*, int); |
| qpol_iterator_t *av_true_iter(qpol_policy_t *p, int rule_types) { |
| qpol_iterator_t *iter; |
| if (qpol_cond_get_av_true_iter(p, self, rule_types, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of memory"); |
| } |
| fail: |
| return iter; |
| }; |
| %newobject av_false_iter(qpol_policy_t*, int); |
| qpol_iterator_t *av_false_iter(qpol_policy_t *p, int rule_types) { |
| qpol_iterator_t *iter; |
| if (qpol_cond_get_av_false_iter(p, self, rule_types, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of memory"); |
| } |
| fail: |
| return iter; |
| }; |
| %newobject te_true_iter(qpol_policy_t*, int); |
| qpol_iterator_t *te_true_iter(qpol_policy_t *p, int rule_types) { |
| qpol_iterator_t *iter; |
| if (qpol_cond_get_te_true_iter(p, self, rule_types, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of memory"); |
| } |
| fail: |
| return iter; |
| }; |
| %newobject te_false_iter(qpol_policy_t*, int); |
| qpol_iterator_t *te_false_iter(qpol_policy_t *p, int rule_types) { |
| qpol_iterator_t *iter; |
| if (qpol_cond_get_te_false_iter(p, self, rule_types, &iter)) { |
| SWIG_exception(SWIG_MemoryError, "Out of memory"); |
| } |
| fail: |
| return iter; |
| }; |
| int evaluate(qpol_policy_t *p) { |
| uint32_t e; |
| if (qpol_cond_eval(p, self, &e)) { |
| SWIG_exception(SWIG_RuntimeError, "Could not evaluate conditional"); |
| } |
| 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 { |
| qpol_cond_expr_node() { |
| SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_cond_expr_node_t objects"); |
| fail: |
| return NULL; |
| }; |
| ~qpol_cond_expr_node() { |
| /* no op */ |
| return; |
| }; |
| int expr_type(qpol_policy_t *p) { |
| uint32_t et; |
| if (qpol_cond_expr_node_get_expr_type(p, self, &et)) { |
| SWIG_exception(SWIG_ValueError, "Could not get node expression type"); |
| } |
| fail: |
| return (int) et; |
| }; |
| qpol_bool_t *get_boolean(qpol_policy_t *p) { |
| uint32_t et; |
| qpol_bool_t *b = NULL; |
| 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"); |
| } |
| 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 filename trans */ |
| typedef struct qpol_filename_trans {} qpol_filename_trans_t; |
| %extend qpol_filename_trans { |
| qpol_filename_trans() { |
| SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_filename_trans_t objects"); |
| fail: |
| return NULL; |
| }; |
| ~qpol_filename_trans() { |
| /* no op */ |
| return; |
| }; |
| %pythoncode %{ |
| def rule_type(self,policy): |
| return "type_transition" |
| %} |
| |
| const qpol_type_t *source_type (qpol_policy_t *p) { |
| const qpol_type_t *t; |
| if (qpol_filename_trans_get_source_type(p, self, &t)) { |
| SWIG_exception(SWIG_ValueError, "Could not get source for filename transition rule"); |
| } |
| fail: |
| return t; |
| }; |
| const qpol_type_t *target_type (qpol_policy_t *p) { |
| const qpol_type_t *t; |
| if (qpol_filename_trans_get_target_type(p, self, &t)) { |
| SWIG_exception(SWIG_ValueError, "Could not get target for filename transition rule"); } |
| fail: |
| return t; |
| }; |
| const qpol_class_t *object_class(qpol_policy_t *p) { |
| const qpol_class_t *cls; |
| if (qpol_filename_trans_get_object_class(p, self, &cls)) { |
| SWIG_exception(SWIG_ValueError, "Could not get class for filename transition rule"); } |
| fail: |
| return cls; |
| }; |
| const qpol_type_t *default_type(qpol_policy_t *p) { |
| const qpol_type_t *t; |
| if (qpol_filename_trans_get_default_type(p, self, &t)) { |
| SWIG_exception(SWIG_ValueError, "Could not get default for filename transition rule"); |
| } |
| fail: |
| return t; |
| }; |
| const char *filename(qpol_policy_t *p) { |
| const char *name; |
| if (qpol_filename_trans_get_filename(p, self, &name)) { |
| SWIG_exception(SWIG_ValueError, "Could not get file for filename transition rule"); |
| } |
| fail: |
| return name; |
| }; |
| |
| }; |
| %inline %{ |
| qpol_filename_trans_t *qpol_filename_trans_from_void(void *x) { |
| return (qpol_filename_trans_t*)x; |
| }; |
| %} |
| |
| /* qpol polcap */ |
| typedef struct qpol_polcap {} qpol_polcap_t; |
| %extend qpol_polcap { |
| qpol_polcap() { |
| SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_polcap_t objects"); |
| fail: |
| return NULL; |
| }; |
| ~qpol_polcap() { |
| /* no op */ |
| return; |
| }; |
| const char *name(qpol_policy_t *p) { |
| const char *name; |
| if (qpol_polcap_get_name(p, self, &name)) { |
| SWIG_exception(SWIG_ValueError, "Could not get polcap name rule"); |
| } |
| fail: |
| return name; |
| }; |
| |
| }; |
| %inline %{ |
| qpol_polcap_t *qpol_polcap_from_void(void *x) { |
| return (qpol_polcap_t*)x; |
| }; |
| %} |
| |
| /* qpol typebounds */ |
| typedef struct qpol_typebounds {} qpol_typebounds_t; |
| %extend qpol_typebounds { |
| qpol_typebounds() { |
| SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_typebounds_t objects"); |
| fail: |
| return NULL; |
| }; |
| ~qpol_typebounds() { |
| /* no op */ |
| return; |
| }; |
| const char *parent_name(qpol_policy_t *p) { |
| const char *name; |
| if (qpol_typebounds_get_parent_name(p, self, &name)) { |
| SWIG_exception(SWIG_ValueError, "Could not get parent name"); |
| } |
| fail: |
| return name; |
| }; |
| const char *child_name(qpol_policy_t *p) { |
| const char *name; |
| if (qpol_typebounds_get_child_name(p, self, &name)) { |
| SWIG_exception(SWIG_ValueError, "Could not get child name"); |
| } |
| fail: |
| return name; |
| }; |
| }; |
| %inline %{ |
| qpol_typebounds_t *qpol_typebounds_from_void(void *x) { |
| return (qpol_typebounds_t*)x; |
| }; |
| %} |
| |
| /* qpol rolebounds */ |
| typedef struct qpol_rolebounds {} qpol_rolebounds_t; |
| %extend qpol_rolebounds { |
| qpol_rolebounds() { |
| SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_rolebounds_t objects"); |
| fail: |
| return NULL; |
| }; |
| ~qpol_rolebounds() { |
| /* no op */ |
| return; |
| }; |
| const char *parent_name(qpol_policy_t *p) { |
| const char *name; |
| if (qpol_rolebounds_get_parent_name(p, self, &name)) { |
| SWIG_exception(SWIG_ValueError, "Could not get parent name"); |
| } |
| fail: |
| return name; |
| }; |
| const char *child_name(qpol_policy_t *p) { |
| const char *name; |
| if (qpol_rolebounds_get_child_name(p, self, &name)) { |
| SWIG_exception(SWIG_ValueError, "Could not get child name"); |
| } |
| fail: |
| return name; |
| }; |
| }; |
| %inline %{ |
| qpol_rolebounds_t *qpol_rolebounds_from_void(void *x) { |
| return (qpol_rolebounds_t*)x; |
| }; |
| %} |
| |
| /* qpol userbounds */ |
| typedef struct qpol_userbounds {} qpol_userbounds_t; |
| %extend qpol_userbounds { |
| qpol_userbounds() { |
| SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_userbounds_t objects"); |
| fail: |
| return NULL; |
| }; |
| ~qpol_userbounds() { |
| /* no op */ |
| return; |
| }; |
| const char *parent_name(qpol_policy_t *p) { |
| const char *name; |
| if (qpol_userbounds_get_parent_name(p, self, &name)) { |
| SWIG_exception(SWIG_ValueError, "Could not get parent name"); |
| } |
| fail: |
| return name; |
| }; |
| const char *child_name(qpol_policy_t *p) { |
| const char *name; |
| if (qpol_userbounds_get_child_name(p, self, &name)) { |
| SWIG_exception(SWIG_ValueError, "Could not get child name"); |
| } |
| fail: |
| return name; |
| }; |
| }; |
| %inline %{ |
| qpol_userbounds_t *qpol_userbounds_from_void(void *x) { |
| return (qpol_userbounds_t*)x; |
| }; |
| %} |
| |
| /* qpol default_object */ |
| typedef struct qpol_default_object {} qpol_default_object_t; |
| %extend qpol_default_object { |
| qpol_default_object() { |
| SWIG_exception(SWIG_RuntimeError, "Cannot directly create qpol_default_object_t objects"); |
| fail: |
| return NULL; |
| }; |
| ~qpol_default_object() { |
| /* no op */ |
| return; |
| }; |
| |
| %newobject object_class(); |
| const qpol_class_t *object_class(qpol_policy_t *p) { |
| const qpol_class_t *cls; |
| if (qpol_default_object_get_class(p, self, &cls)) { |
| SWIG_exception(SWIG_ValueError, "Could not get class"); |
| } |
| fail: |
| return cls; |
| }; |
| |
| const char *user_default(qpol_policy_t *p) { |
| const char *value; |
| if (qpol_default_object_get_user_default(p, self, &value)) { |
| SWIG_exception(SWIG_ValueError, "Could not get user default"); |
| } |
| fail: |
| return value; |
| }; |
| const char *role_default(qpol_policy_t *p) { |
| const char *value; |
| if (qpol_default_object_get_role_default(p, self, &value)) { |
| SWIG_exception(SWIG_ValueError, "Could not get role default"); |
| } |
| fail: |
| return value; |
| }; |
| const char *type_default(qpol_policy_t *p) { |
| const char *value; |
| if (qpol_default_object_get_type_default(p, self, &value)) { |
| SWIG_exception(SWIG_ValueError, "Could not get type default"); |
| } |
| fail: |
| return value; |
| }; |
| const char *range_default(qpol_policy_t *p) { |
| const char *value; |
| if (qpol_default_object_get_range_default(p, self, &value)) { |
| SWIG_exception(SWIG_ValueError, "Could not get range defaults"); |
| } |
| fail: |
| return value; |
| }; |
| }; |
| %inline %{ |
| qpol_default_object_t *qpol_default_object_from_void(void *x) { |
| return (qpol_default_object_t*)x; |
| }; |
| %} |
| |
| /* qpol iomemcon */ |
| typedef struct qpol_iomemcon {} qpol_iomemcon_t; |
| %extend qpol_iomemcon { |
| qpol_iomemcon(qpol_policy_t *p, uint64_t low, uint64_t high) { |
| const qpol_iomemcon_t *qp; |
| if (qpol_policy_get_iomemcon_by_addr(p, low, high, &qp)) { |
| SWIG_exception(SWIG_RuntimeError, "iomemcon statement does not exist"); |
| } |
| fail: |
| return (qpol_iomemcon_t*)qp; |
| }; |
| ~qpol_iomemcon() { |
| /* no op */ |
| return; |
| }; |
| uint64_t low_addr(qpol_policy_t *p) { |
| uint64_t addr = 0; |
| if(qpol_iomemcon_get_low_addr(p, self, &addr)) { |
| SWIG_exception(SWIG_RuntimeError, "Could not get low addr for iomemcon statement"); |
| } |
| fail: |
| return addr; |
| }; |
| uint64_t high_addr(qpol_policy_t *p) { |
| uint64_t addr = 0; |
| if(qpol_iomemcon_get_high_addr(p, self, &addr)) { |
| SWIG_exception(SWIG_RuntimeError, "Could not get high addr for iomemcon statement"); |
| } |
| fail: |
| return addr; |
| }; |
| const qpol_context_t *context(qpol_policy_t *p) { |
| const qpol_context_t *ctx; |
| if (qpol_iomemcon_get_context(p, self, &ctx)) { |
| SWIG_exception(SWIG_ValueError, "Could not get context for iomemcon statement"); |
| } |
| fail: |
| return ctx; |
| }; |
| } |
| %inline %{ |
| qpol_iomemcon_t *qpol_iomemcon_from_void(void *x) { |
| return (qpol_iomemcon_t*)x; |
| }; |
| %} |
| |
| /* qpol ioportcon */ |
| typedef struct qpol_ioportcon {} qpol_ioportcon_t; |
| %extend qpol_ioportcon { |
| qpol_ioportcon(qpol_policy_t *p, uint32_t low, uint32_t high) { |
| const qpol_ioportcon_t *qp; |
| if (qpol_policy_get_ioportcon_by_port(p, low, high, &qp)) { |
| SWIG_exception(SWIG_RuntimeError, "ioportcon statement does not exist"); |
| } |
| fail: |
| return (qpol_ioportcon_t*)qp; |
| }; |
| ~qpol_ioportcon() { |
| /* no op */ |
| return; |
| }; |
| uint32_t low_port(qpol_policy_t *p) { |
| uint32_t port = 0; |
| if(qpol_ioportcon_get_low_port(p, self, &port)) { |
| SWIG_exception(SWIG_RuntimeError, "Could not get low port for ioportcon statement"); |
| } |
| fail: |
| return port; |
| }; |
| uint32_t high_port(qpol_policy_t *p) { |
| uint32_t port = 0; |
| if(qpol_ioportcon_get_high_port(p, self, &port)) { |
| SWIG_exception(SWIG_RuntimeError, "Could not get high port for ioportcon statement"); |
| } |
| fail: |
| return port; |
| }; |
| const qpol_context_t *context(qpol_policy_t *p) { |
| const qpol_context_t *ctx; |
| if (qpol_ioportcon_get_context(p, self, &ctx)) { |
| SWIG_exception(SWIG_ValueError, "Could not get context for ioportcon statement"); |
| } |
| fail: |
| return ctx; |
| }; |
| } |
| %inline %{ |
| qpol_ioportcon_t *qpol_ioportcon_from_void(void *x) { |
| return (qpol_ioportcon_t*)x; |
| }; |
| %} |
| |
| /* qpol pcidevicecon */ |
| typedef struct qpol_pcidevicecon {} qpol_pcidevicecon_t; |
| %extend qpol_pcidevicecon { |
| qpol_pcidevicecon() { |
| SWIG_exception(SWIG_RuntimeError, "pcidevicecon statement does not exist"); |
| fail: |
| return NULL; |
| }; |
| ~qpol_pcidevicecon() { |
| return; |
| }; |
| uint32_t device(qpol_policy_t *p) { |
| uint32_t device = 0; |
| if(qpol_pcidevicecon_get_device(p, self, &device)) { |
| SWIG_exception(SWIG_RuntimeError, "Could not get device for pcidevicecon statement"); |
| } |
| fail: |
| return device; |
| }; |
| const qpol_context_t *context(qpol_policy_t *p) { |
| const qpol_context_t *ctx; |
| if (qpol_pcidevicecon_get_context(p, self, &ctx)) { |
| SWIG_exception(SWIG_ValueError, "Could not get context for pcidevicecon statement"); |
| } |
| fail: |
| return ctx; |
| }; |
| } |
| %inline %{ |
| qpol_pcidevicecon_t *qpol_pcidevicecon_from_void(void *x) { |
| return (qpol_pcidevicecon_t*)x; |
| }; |
| %} |
| |
| /* qpol pirqcon */ |
| typedef struct qpol_pirqcon {} qpol_pirqcon_t; |
| %extend qpol_pirqcon { |
| qpol_pirqcon() { |
| SWIG_exception(SWIG_RuntimeError, "pirqcon statement does not exist"); |
| fail: |
| return NULL; |
| }; |
| ~qpol_pirqcon() { |
| return; |
| }; |
| uint32_t irq(qpol_policy_t *p) { |
| uint16_t irq = 0; |
| if(qpol_pirqcon_get_irq(p, self, &irq)) { |
| SWIG_exception(SWIG_RuntimeError, "Could not get irq for pirqcon statement"); |
| } |
| fail: |
| return irq; |
| }; |
| const qpol_context_t *context(qpol_policy_t *p) { |
| const qpol_context_t *ctx; |
| if (qpol_pirqcon_get_context(p, self, &ctx)) { |
| SWIG_exception(SWIG_ValueError, "Could not get context for pirqcon statement"); |
| } |
| fail: |
| return ctx; |
| }; |
| } |
| %inline %{ |
| qpol_pirqcon_t *qpol_pirqcon_from_void(void *x) { |
| return (qpol_pirqcon_t*)x; |
| }; |
| %} |
| |
| /* qpol devicetreecon */ |
| typedef struct qpol_devicetreecon {} qpol_devicetreecon_t; |
| %extend qpol_devicetreecon { |
| qpol_devicetreecon() { |
| |
| SWIG_exception(SWIG_RuntimeError, "devicetreecon statement does not exist"); |
| |
| fail: |
| return NULL; |
| }; |
| char *path(qpol_policy_t *p) { |
| char *path = NULL; |
| if(qpol_devicetreecon_get_path(p, self, &path)) { |
| SWIG_exception(SWIG_RuntimeError, "Could not get path for devicetreecon statement"); |
| } |
| fail: |
| return path; |
| }; |
| const qpol_context_t *context(qpol_policy_t *p) { |
| const qpol_context_t *ctx; |
| if (qpol_devicetreecon_get_context(p, self, &ctx)) { |
| SWIG_exception(SWIG_ValueError, "Could not get context for devicetreecon statement"); |
| } |
| fail: |
| return ctx; |
| }; |
| } |
| %inline %{ |
| qpol_devicetreecon_t *qpol_devicetreecon_from_void(void *x) { |
| return (qpol_devicetreecon_t*)x; |
| }; |
| %} |
| |