diff options
Diffstat (limited to 'libseaudit/swig/seaudit.i')
| -rw-r--r-- | libseaudit/swig/seaudit.i | 1373 |
1 files changed, 1373 insertions, 0 deletions
diff --git a/libseaudit/swig/seaudit.i b/libseaudit/swig/seaudit.i new file mode 100644 index 0000000..8c96d89 --- /dev/null +++ b/libseaudit/swig/seaudit.i @@ -0,0 +1,1373 @@ +/** + * @file + * SWIG declarations for libseaudit. + * + * @author Jeremy A. Mowery jmowery@tresys.com + * @author Jason Tang jtang@tresys.com + * + * Copyright (C) 2006-2007 Tresys Technology, LLC + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +%module seaudit + +%{ +#include <seaudit/avc_message.h> +#include <seaudit/bool_message.h> +#include <seaudit/filter.h> +#include <seaudit/load_message.h> +#include <seaudit/log.h> +#include <seaudit/message.h> +#include <seaudit/model.h> +#include <seaudit/parse.h> +#include <seaudit/report.h> +#include <seaudit/sort.h> +#include <seaudit/util.h> +#include <time.h> + +/* Provide hooks so that language-specific modules can define the + * callback function, used by the handler in seaudit_log_create(). + */ +SWIGEXPORT seaudit_handle_fn_t seaudit_swig_message_callback = NULL; +SWIGEXPORT void * seaudit_swig_message_callback_arg = NULL; + +%} + +#ifdef SWIGJAVA +%javaconst(1); +/* get the java environment so we can throw exceptions */ +%{ + static JNIEnv *seaudit_global_jenv; + jint JNI_OnLoad(JavaVM *vm, void *reserved) { + (*vm)->AttachCurrentThread(vm, (void **)&seaudit_global_jenv, NULL); + return JNI_VERSION_1_2; + } +%} +#endif + +%include exception.i +%include stdint.i +%import apol.i + +%{ +#undef BEGIN_EXCEPTION +#undef END_EXCEPTION +%} + +#ifdef SWIGJAVA + +%exception { + seaudit_global_jenv = jenv; + $action +} + +%{ +#define BEGIN_EXCEPTION JNIEnv *local_jenv = seaudit_global_jenv; { +#define END_EXCEPTION } +%} + +/* handle size_t correctly in java as architecture independent */ +%typemap(jni) size_t "jlong" +%typemap(jtype) size_t "long" +%typemap(jstype) size_t "long" +%typemap("javaimports") SWIGTYPE, FILE* %{ +import com.tresys.setools.qpol.*; +import com.tresys.setools.apol.*; +%} +%typemap(javabody) SWIGTYPE %{ + private long swigCPtr; + protected boolean swigCMemOwn; + + public $javaclassname(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + public static long getCPtr($javaclassname obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +%} +/* the following handles the dependencies on qpol and apol */ +%pragma(java) jniclassimports=%{ +import com.tresys.setools.qpol.*; +import com.tresys.setools.apol.*; +%} +%pragma(java) jniclasscode=%{ + static { + try + { + libseaudit_get_version (); + } + catch (UnsatisfiedLinkError ule) + { + System.loadLibrary("jseaudit"); + } + } +%} +%pragma(java) moduleimports=%{ +import com.tresys.setools.qpol.*; +import com.tresys.setools.apol.*; +%} +#else +/* not in java so handle size_t as architecture dependent */ +#ifdef SWIGWORDSIZE64 +typedef uint64_t size_t; +#else +typedef uint32_t size_t; +#endif +%{ +#define BEGIN_EXCEPTION +#define END_EXCEPTION +%} +#endif + +#ifdef SWIGJAVA +/* if java, pass the new exception macro to C not just SWIG */ +#undef SWIG_exception +#define SWIG_exception(code, msg) {SWIG_JavaException(local_jenv, code, msg); goto fail;} +%inline %{ +#undef SWIG_exception +#define SWIG_exception(code, msg) {SWIG_JavaException(local_jenv, code, msg); goto fail;} +%} +#endif + +#ifdef SWIGTCL +/* implement a custom non thread-safe error handler */ +%{ +static char *message = NULL; +static void tcl_clear_error(void) +{ + free(message); + message = NULL; +} +static void tcl_throw_error(const char *s) +{ + free(message); + message = strdup(s); +} +static char *tcl_get_error(void) +{ + return message; +} +#undef SWIG_exception +#define SWIG_exception(code, msg) {tcl_throw_error(msg); goto fail;} +%} + +%wrapper %{ +/* Tcl module's initialization routine is expected to be named + * Seaudit_Init(), but the output file will be called libtseaudit.so instead + * of libseaudit.so. Therefore add an alias from Tseaudit_Init() to the + * real Seaudit_Init(). + */ +SWIGEXPORT int Tseaudit_Init(Tcl_Interp *interp) { + return SWIG_init(interp); +} +%} + +%exception { + char *err; + tcl_clear_error(); + $action + if ((err = tcl_get_error()) != NULL) { + Tcl_Obj *obj = Tcl_NewStringObj(message, -1); + Tcl_ResetResult(interp); + Tcl_SetObjResult(interp, obj); + goto fail; + } +} +#undef SWIG_exception +#define SWIG_exception(code, msg) {tcl_throw_error(msg); goto fail;} +#endif + +%inline %{ + typedef struct apol_string_vector apol_string_vector_t; +%} + + +#ifdef SWIGPYTHON +/* map python file to C FILE struct pointer */ +%typemap(in) FILE * { + if (!PyFile_Check($input)) { + PyErr_SetString(PyExc_TypeError, "Need a file!"); + return NULL; + } + $1 = PyFile_AsFile($input); +} +/* map string into C-style memory buffer */ +%typemap(in) (const char *buffer, const size_t bufsize) { + $1 = PyString_AsString($input); + $2 = (size_t) PyString_Size($input); +} +#endif +#ifdef SWIGJAVA +/* map string into C-style memory buffer */ +%typemap(in, noblock=1) (const char *buffer, const size_t bufsize) { + $1 = 0; + $2 = 0; + if ($input) { + $1 = ($1_ltype)JCALL2(GetStringUTFChars, jenv, $input, 0); + if (!$1) return $null; + $2 = strlen($1); + } +} +%typemap(freearg, noblock=1) (const char *buffer, const size_t bufsize) { + if ($1) JCALL2(ReleaseStringUTFChars, jenv, $input, $1); +} +#endif +#ifdef SWIGTCL +%typemap(in) FILE * { + ClientData c; + if (Tcl_GetOpenFile(interp, Tcl_GetString($input), 0, 1, &c) == TCL_ERROR) + SWIG_exception(SWIG_RuntimeError, Tcl_GetStringResult(interp)); + $1 = (FILE*)c; +} +#endif + +/* from <time.h> */ +%{ + typedef struct tm tm_t; +%} +typedef struct tm { + int tm_sec; /* seconds */ + int tm_min; /* minutes */ + int tm_hour; /* hours */ + int tm_mday; /* day of the month */ + int tm_mon; /* month */ + int tm_year; /* year */ + int tm_wday; /* day of the week */ + int tm_yday; /* day in the year */ + int tm_isdst; /* daylight saving time */ +} tm_t; +%extend tm_t { + tm_t() { + struct tm *t; + BEGIN_EXCEPTION + t = calloc(1, sizeof(struct tm)); + if (!t) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return t; + }; + ~tm_t() { + free(self); + } + /* use default accessor style for the rest */ +}; + +const char *libseaudit_get_version(void); + +/* seaudit log */ +typedef enum seaudit_log_type +{ + SEAUDIT_LOG_TYPE_INVALID = 0, + SEAUDIT_LOG_TYPE_SYSLOG, + SEAUDIT_LOG_TYPE_AUDITD +} seaudit_log_type_e; +typedef struct seaudit_log {} seaudit_log_t; +%extend seaudit_log_t { + seaudit_log_t() { + seaudit_log_t *slog; + BEGIN_EXCEPTION + slog = seaudit_log_create(seaudit_swig_message_callback, seaudit_swig_message_callback_arg); + if (!slog) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return slog; + }; + ~seaudit_log_t() { + seaudit_log_destroy(&self); + }; + void clear () { + seaudit_log_clear(self); + }; + %newobject get_users(); + apol_string_vector_t *get_users() { + apol_vector_t *v; + BEGIN_EXCEPTION + v = seaudit_log_get_users(self); + if (!v) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return (apol_string_vector_t*)v; + }; + %newobject get_roles(); + apol_string_vector_t *get_roles() { + apol_vector_t *v; + BEGIN_EXCEPTION + v = seaudit_log_get_roles(self); + if (!v) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return (apol_string_vector_t*)v; + }; + %newobject get_types(); + apol_string_vector_t *get_types() { + apol_vector_t *v; + BEGIN_EXCEPTION + v = seaudit_log_get_types(self); + if (!v) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return (apol_string_vector_t*)v; + }; + %newobject get_classes(); + apol_string_vector_t *get_classes() { + apol_vector_t *v; + BEGIN_EXCEPTION + v = seaudit_log_get_classes(self); + if (!v) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return (apol_string_vector_t*)v; + }; +}; + +/* seaudit message */ +typedef enum seaudit_message_type +{ + SEAUDIT_MESSAGE_TYPE_INVALID = 0, + SEAUDIT_MESSAGE_TYPE_BOOL, + SEAUDIT_MESSAGE_TYPE_AVC, + SEAUDIT_MESSAGE_TYPE_LOAD +} seaudit_message_type_e; +typedef struct seaudit_message {} seaudit_message_t; +%extend seaudit_message_t { + seaudit_message_t() { + BEGIN_EXCEPTION + SWIG_exception(SWIG_RuntimeError, "Canot directly create seaudit_message_t objects"); + END_EXCEPTION + fail: + return NULL; + }; + ~seaudit_message_t() { + /* no op */ + return; + }; + seaudit_message_type_e get_type() { + seaudit_message_type_e te; + (void)seaudit_message_get_data(self, &te); + return te; + }; + void *get_data() { + seaudit_message_type_e te; + return seaudit_message_get_data(self, &te); + }; + const char *get_host() { + return seaudit_message_get_host(self); + }; + const tm_t *get_time() { + return seaudit_message_get_time(self); + } + %newobject to_string(); + char *to_string() { + char *str; + BEGIN_EXCEPTION + str = seaudit_message_to_string(self); + if (!str) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return str; + }; + %newobject to_string_html(); + char *to_string_html() { + char *str; + BEGIN_EXCEPTION + str = seaudit_message_to_string_html(self); + if (!str) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return str; + }; + %newobject to_misc_string(); + char *to_misc_string() { + char *str; + BEGIN_EXCEPTION + str = seaudit_message_to_misc_string(self); + if (!str) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return str; + }; +}; +%inline %{ + seaudit_message_t *seaudit_message_from_void(void *x) { + return (seaudit_message_t*)x; + }; +%} + +/* seaudit load message */ +typedef struct seaudit_load_message {} seaudit_load_message_t; +%extend seaudit_load_message_t { + seaudit_load_message_t() { + BEGIN_EXCEPTION + SWIG_exception(SWIG_RuntimeError, "Cannot directly create seaudit_load_message_t objects"); + END_EXCEPTION + fail: + return NULL; + }; + ~seaudit_load_message_t() { + /* no op */ + return; + }; +}; +%inline %{ + seaudit_load_message_t *seaudit_load_message_from_void(void *msg) { + return (seaudit_load_message_t*)msg; + }; +%} + +/* seaudit bool message */ +typedef struct seaudit_bool_message {} seaudit_bool_message_t; +%extend seaudit_bool_message_t { + seaudit_bool_message_t(void *msg) { + BEGIN_EXCEPTION + SWIG_exception(SWIG_RuntimeError, "Cannot directly create seaudit_bool_message_t objects"); + END_EXCEPTION + fail: + return NULL; + }; + ~seaudit_bool_message_t() { + /* no op */ + return; + }; +}; +%inline %{ + seaudit_bool_message_t *seaudit_bool_message_from_void(void *msg) { + return (seaudit_bool_message_t*)msg; + }; +%} + +/* seaudit avc message */ +typedef enum seaudit_avc_message_type +{ + SEAUDIT_AVC_UNKNOWN = 0, + SEAUDIT_AVC_DENIED, + SEAUDIT_AVC_GRANTED +} seaudit_avc_message_type_e; +typedef struct seaudit_avc_message {} seaudit_avc_message_t; +%extend seaudit_avc_message_t { + seaudit_avc_message_t() { + BEGIN_EXCEPTION + SWIG_exception(SWIG_RuntimeError, "Cannot directly create seaudit_avc_message_t objects"); + END_EXCEPTION + fail: + return NULL; + }; + ~seaudit_avc_message_t() { + /* no op */ + return; + }; + seaudit_avc_message_type_e get_message_type() { + return seaudit_avc_message_get_message_type(self); + }; + long get_timestamp_nano() { + return seaudit_avc_message_get_timestamp_nano(self); + }; + const char *get_source_user() { + return seaudit_avc_message_get_source_user(self); + }; + const char *get_source_role() { + return seaudit_avc_message_get_source_role(self); + }; + const char *get_source_type() { + return seaudit_avc_message_get_source_type(self); + }; + const char *get_target_user() { + return seaudit_avc_message_get_target_user(self); + }; + const char *get_target_role() { + return seaudit_avc_message_get_target_role(self); + }; + const char *get_target_type() { + return seaudit_avc_message_get_target_type(self); + }; + const char *get_object_class() { + return seaudit_avc_message_get_object_class(self); + }; + const apol_string_vector_t *get_perm() { + return (apol_string_vector_t*)seaudit_avc_message_get_perm(self); + }; + const char *get_exe() { + return seaudit_avc_message_get_exe(self); + }; + const char *get_comm() { + return seaudit_avc_message_get_comm(self); + }; + const char *get_name() { + return seaudit_avc_message_get_name(self); + }; + int get_pid() { + return (int)seaudit_avc_message_get_pid(self); + }; + long get_inode() { + return (long)seaudit_avc_message_get_inode(self); + }; + const char *get_path() { + return seaudit_avc_message_get_path(self); + }; + const char *get_dev() { + return seaudit_avc_message_get_dev(self); + }; + const char *get_netif() { + return seaudit_avc_message_get_netif(self); + }; + int get_port() { + return seaudit_avc_message_get_port(self); + }; + const char *get_laddr() { + return seaudit_avc_message_get_laddr(self); + }; + int get_lport() { + return seaudit_avc_message_get_lport(self); + }; + const char *get_faddr() { + return seaudit_avc_message_get_faddr(self); + }; + int get_fport() { + return seaudit_avc_message_get_fport(self); + }; + const char *get_saddr() { + return seaudit_avc_message_get_saddr(self); + }; + int get_sport() { + return seaudit_avc_message_get_sport(self); + }; + const char *get_daddr() { + return seaudit_avc_message_get_daddr(self); + }; + int get_dport() { + return seaudit_avc_message_get_dport(self); + }; + int get_key() { + return seaudit_avc_message_get_key(self); + }; + int get_cap() { + return seaudit_avc_message_get_cap(self); + }; +}; +%inline %{ + seaudit_avc_message_t *seaudit_avc_message_from_void(void *msg) { + return (seaudit_avc_message_t*)msg; + }; +%} + +/* Java does not permit parsing directly from a file; parsing may only + be done through a memory buffer. */ +#ifndef SWIGJAVA +int seaudit_log_parse(seaudit_log_t * log, FILE * syslog); +#endif +int seaudit_log_parse_buffer(seaudit_log_t * log, const char *buffer, const size_t bufsize); + +/* seaudit filter */ +typedef enum seaudit_filter_match +{ + SEAUDIT_FILTER_MATCH_ALL = 0, + SEAUDIT_FILTER_MATCH_ANY +} seaudit_filter_match_e; +typedef enum seaudit_filter_visible +{ + SEAUDIT_FILTER_VISIBLE_SHOW = 0, + SEAUDIT_FILTER_VISIBLE_HIDE +} seaudit_filter_visible_e; +typedef enum seaudit_filter_date_match +{ + SEAUDIT_FILTER_DATE_MATCH_BEFORE = 0, + SEAUDIT_FILTER_DATE_MATCH_AFTER, + SEAUDIT_FILTER_DATE_MATCH_BETWEEN +} seaudit_filter_date_match_e; +typedef struct seaudit_filter {} seaudit_filter_t; +%extend seaudit_filter_t { + seaudit_filter_t(char *name = NULL) { + seaudit_filter_t *sf = NULL; + BEGIN_EXCEPTION + sf = seaudit_filter_create(name); + if (!sf) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return sf; + }; + seaudit_filter_t(seaudit_filter_t *in) { + seaudit_filter_t *sf = NULL; + BEGIN_EXCEPTION + sf = seaudit_filter_create_from_filter(in); + if (!sf) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return sf; + }; + ~seaudit_filter_t() { + seaudit_filter_destroy(&self); + }; + void save(char *path) { + BEGIN_EXCEPTION + if (seaudit_filter_save_to_file(self, path)) { + SWIG_exception(SWIG_RuntimeError, "Could not save filter"); + } + END_EXCEPTION + fail: + return; + }; + void set_match(seaudit_filter_match_e match) { + BEGIN_EXCEPTION + if (seaudit_filter_set_match(self, match)) { + SWIG_exception(SWIG_RuntimeError, "Could not set filter matching method"); + } + END_EXCEPTION + fail: + return; + } + seaudit_filter_match_e get_match() { + return seaudit_filter_get_match(self); + }; + void set_name(char *name) { + BEGIN_EXCEPTION + if (seaudit_filter_set_name(self, name)) { + SWIG_exception(SWIG_RuntimeError, "Could not set filter name"); + } + END_EXCEPTION + fail: + return; + }; + const char *get_name() { + return seaudit_filter_get_name(self); + }; + void set_description(char *description) { + BEGIN_EXCEPTION + if (seaudit_filter_set_description(self, description)) { + SWIG_exception(SWIG_RuntimeError, "Could not set filter description"); + } + END_EXCEPTION + fail: + return; + }; + const char *get_description() { + return seaudit_filter_get_description(self); + }; + void set_strict(bool is_strict) { + seaudit_filter_set_strict(self, is_strict); + }; + bool get_strict() { + return seaudit_filter_get_strict(self); + }; + void set_source_user(apol_string_vector_t *v) { + BEGIN_EXCEPTION + if (seaudit_filter_set_source_user(self, (apol_vector_t*)v)) { + SWIG_exception(SWIG_RuntimeError, "Could not set source user list for filter"); + } + END_EXCEPTION + fail: + return; + }; + const apol_string_vector_t *get_source_user() { + return (apol_string_vector_t*)seaudit_filter_get_source_user(self); + }; + void set_source_role(apol_string_vector_t *v) { + BEGIN_EXCEPTION + if (seaudit_filter_set_source_role(self, (apol_vector_t*)v)) { + SWIG_exception(SWIG_RuntimeError, "Could not set source role list for filter"); + } + END_EXCEPTION + fail: + return; + }; + const apol_string_vector_t *get_source_role() { + return (apol_string_vector_t*)seaudit_filter_get_source_role(self); + }; + void set_source_type(apol_string_vector_t *v) { + BEGIN_EXCEPTION + if (seaudit_filter_set_source_type(self, (apol_vector_t*)v)) { + SWIG_exception(SWIG_RuntimeError, "Could not set source type list for filter"); + } + END_EXCEPTION + fail: + return; + }; + const apol_string_vector_t *get_source_type() { + return (apol_string_vector_t*)seaudit_filter_get_source_type(self); + }; + void set_target_user(apol_string_vector_t *v) { + BEGIN_EXCEPTION + if (seaudit_filter_set_target_user(self, (apol_vector_t*)v)) { + SWIG_exception(SWIG_RuntimeError, "Could not set target user list for filter"); + } + END_EXCEPTION + fail: + return; + }; + const apol_string_vector_t *get_target_user() { + return (apol_string_vector_t*)seaudit_filter_get_target_user(self); + }; + void set_target_role(apol_string_vector_t *v) { + BEGIN_EXCEPTION + if (seaudit_filter_set_target_role(self, (apol_vector_t*)v)) { + SWIG_exception(SWIG_RuntimeError, "Could not set target role list for filter"); + } + END_EXCEPTION + fail: + return; + }; + const apol_string_vector_t *get_target_role() { + return (apol_string_vector_t*)seaudit_filter_get_target_role(self); + }; + void set_target_type(apol_string_vector_t *v) { + BEGIN_EXCEPTION + if (seaudit_filter_set_target_type(self, (apol_vector_t*)v)) { + SWIG_exception(SWIG_RuntimeError, "Could not set target type list for filter"); + } + END_EXCEPTION + fail: + return; + }; + const apol_string_vector_t *get_target_type() { + return (apol_string_vector_t*)seaudit_filter_get_target_type(self); + }; + void set_target_class(apol_string_vector_t *v) { + BEGIN_EXCEPTION + if (seaudit_filter_set_target_class(self, (apol_vector_t*)v)) { + SWIG_exception(SWIG_RuntimeError, "Could not set target class list for filter"); + } + END_EXCEPTION + fail: + return; + }; + const apol_string_vector_t *get_target_class() { + return (apol_string_vector_t*)seaudit_filter_get_target_class(self); + }; + void set_permission(char *name) { + BEGIN_EXCEPTION + if (seaudit_filter_set_permission(self, name)) { + SWIG_exception(SWIG_RuntimeError, "Could not set permission for filter"); + } + END_EXCEPTION + fail: + return; + }; + const char *get_permission() { + return seaudit_filter_get_permission(self); + }; + void set_executable(char *name) { + BEGIN_EXCEPTION + if (seaudit_filter_set_executable(self, name)) { + SWIG_exception(SWIG_RuntimeError, "Could not set executable for filter"); + } + END_EXCEPTION + fail: + return; + }; + const char *get_executable() { + return seaudit_filter_get_executable(self); + }; + void set_host(char *name) { + BEGIN_EXCEPTION + if (seaudit_filter_set_host(self, name)) { + SWIG_exception(SWIG_RuntimeError, "Could not set host for filter"); + } + END_EXCEPTION + fail: + return; + }; + const char *get_host() { + return seaudit_filter_get_host(self); + }; + void set_path(char *path) { + BEGIN_EXCEPTION + if (seaudit_filter_set_path(self, path)) { + SWIG_exception(SWIG_RuntimeError, "Could not set path for filter"); + } + END_EXCEPTION + fail: + return; + }; + const char *get_path() { + return seaudit_filter_get_path(self); + }; + void set_command(char *name) { + BEGIN_EXCEPTION + if (seaudit_filter_set_command(self, name)) { + SWIG_exception(SWIG_RuntimeError, "Could not set command for filter"); + } + END_EXCEPTION + fail: + return; + }; + void set_inode(long inode) { + seaudit_filter_set_inode(self, (long) inode); + }; + long get_inode() { + return (long) seaudit_filter_get_inode(self); + }; + void set_pid(long pid) { + seaudit_filter_set_pid(self, (unsigned int) pid); + }; + long get_pid() { + return (long) seaudit_filter_get_pid(self); + }; + const char *get_command() { + return seaudit_filter_get_command(self); + }; + void set_anyaddr(char *name) { + BEGIN_EXCEPTION + if (seaudit_filter_set_anyaddr(self, name)) { + SWIG_exception(SWIG_RuntimeError, "Could not set ip address for filter"); + } + END_EXCEPTION + fail: + return; + }; + const char *get_anyaddr() { + return seaudit_filter_get_anyaddr(self); + }; + void set_anyport(int port) { + seaudit_filter_set_anyport(self, port); + }; + int get_anyport() { + return seaudit_filter_get_anyport(self); + }; + void set_laddr(char *name) { + BEGIN_EXCEPTION + if (seaudit_filter_set_laddr(self, name)) { + SWIG_exception(SWIG_RuntimeError, "Could not set local address for filter"); + } + END_EXCEPTION + fail: + return; + }; + const char *get_laddr() { + return seaudit_filter_get_laddr(self); + }; + void set_lport(int port) { + seaudit_filter_set_lport(self, port); + }; + int get_lport() { + return seaudit_filter_get_lport(self); + }; + void set_faddr(char *name) { + BEGIN_EXCEPTION + if (seaudit_filter_set_faddr(self, name)) { + SWIG_exception(SWIG_RuntimeError, "Could not set foreign address for filter"); + } + END_EXCEPTION + fail: + return; + }; + const char *get_faddr() { + return seaudit_filter_get_faddr(self); + }; + void set_fport(int port) { + seaudit_filter_set_fport(self, port); + }; + int get_fport() { + return seaudit_filter_get_fport(self); + }; + void set_saddr(char *name) { + BEGIN_EXCEPTION + if (seaudit_filter_set_saddr(self, name)) { + SWIG_exception(SWIG_RuntimeError, "Could not set source address for filter"); + } + END_EXCEPTION + fail: + return; + }; + const char *get_saddr() { + return seaudit_filter_get_saddr(self); + }; + void set_sport(int port) { + seaudit_filter_set_sport(self, port); + }; + int get_sport() { + return seaudit_filter_get_sport(self); + }; + void set_daddr(char *name) { + BEGIN_EXCEPTION + if (seaudit_filter_set_daddr(self, name)) { + SWIG_exception(SWIG_RuntimeError, "Could not set destination address for filter"); + } + END_EXCEPTION + fail: + return; + }; + const char *get_daddr() { + return seaudit_filter_get_daddr(self); + }; + void set_dport(int port) { + seaudit_filter_set_dport(self, port); + }; + int get_dport() { + return seaudit_filter_get_dport(self); + }; + void set_port(int port) { + seaudit_filter_set_port(self, port); + }; + int get_port() { + return seaudit_filter_get_port(self); + }; + void set_netif(char *name) { + BEGIN_EXCEPTION + if (seaudit_filter_set_netif(self, name)) { + SWIG_exception(SWIG_RuntimeError, "Could not set network interface for filter"); + } + END_EXCEPTION + fail: + return; + }; + const char *get_netif() { + return seaudit_filter_get_netif(self); + }; + void set_key(int key) { + seaudit_filter_set_key(self, key); + }; + int get_key() { + return seaudit_filter_get_key(self); + }; + void set_cap(int cap) { + seaudit_filter_set_cap(self, cap); + }; + int get_cap() { + return seaudit_filter_get_cap(self); + }; + void set_message_type(seaudit_avc_message_type_e mtype) { + BEGIN_EXCEPTION + if (seaudit_filter_set_message_type(self, mtype)) { + SWIG_exception(SWIG_RuntimeError, "Could not set message type for filter"); + } + END_EXCEPTION + fail: + return; + }; + seaudit_message_type_e get_message_type() { + return seaudit_filter_get_message_type(self); + }; + void set_date(struct tm *start, struct tm *end, seaudit_filter_date_match_e match) { + BEGIN_EXCEPTION + if (seaudit_filter_set_date(self, start, end, match)) { + SWIG_exception(SWIG_RuntimeError, "Could not set date for filter"); + } + END_EXCEPTION + fail: + return; + }; + const struct tm *get_start_date() { + const struct tm *s; + const struct tm *e; + seaudit_filter_date_match_e m; + seaudit_filter_get_date(self, &s, &e, &m); + return s; + }; + const struct tm *get_end_date() { + const struct tm *s; + const struct tm *e; + seaudit_filter_date_match_e m; + seaudit_filter_get_date(self, &s, &e, &m); + return e; + }; + seaudit_filter_date_match_e get_date_match() { + const struct tm *s; + const struct tm *e; + seaudit_filter_date_match_e m; + seaudit_filter_get_date(self, &s, &e, &m); + return m; + }; +}; +%newobject seaudit_filter_create_from_file(const char*); +apol_vector_t *seaudit_filter_create_from_file(const char *filename); +%inline %{ + seaudit_filter_t *seaudit_filter_from_void(void *x) { + return (seaudit_filter_t*)x; + }; +%} + +/* seaudit sort */ +typedef struct seaudit_sort {} seaudit_sort_t; +%extend seaudit_sort_t { + seaudit_sort_t() { + BEGIN_EXCEPTION + SWIG_exception(SWIG_RuntimeError, "Cannot directly create seaudit_sort_t objects"); + END_EXCEPTION + fail: + return NULL; + }; + seaudit_sort_t(seaudit_sort_t *in) { + seaudit_sort_t *ss = NULL; + BEGIN_EXCEPTION + ss = seaudit_sort_create_from_sort(in); + if (!ss) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return ss; + }; + ~seaudit_sort_t() { + seaudit_sort_destroy(&self); + }; +}; +%newobject seaudit_sort_by_message_type(const int); +seaudit_sort_t *seaudit_sort_by_message_type(const int direction); +%newobject seaudit_sort_by_date(const int); +seaudit_sort_t *seaudit_sort_by_date(const int direction); +%newobject seaudit_sort_by_host(const int); +seaudit_sort_t *seaudit_sort_by_host(const int direction); +%newobject seaudit_sort_by_permission(const int); +seaudit_sort_t *seaudit_sort_by_permission(const int direction); +%newobject seaudit_sort_by_source_user(const int); +seaudit_sort_t *seaudit_sort_by_source_user(const int direction); +%newobject seaudit_sort_by_source_role(const int); +seaudit_sort_t *seaudit_sort_by_source_role(const int direction); +%newobject seaudit_sort_by_source_type(const int); +seaudit_sort_t *seaudit_sort_by_source_type(const int direction); +%newobject seaudit_sort_by_target_user(const int); +seaudit_sort_t *seaudit_sort_by_target_user(const int direction); +%newobject seaudit_sort_by_target_role(const int); +seaudit_sort_t *seaudit_sort_by_target_role(const int direction); +%newobject seaudit_sort_by_target_type(const int); +seaudit_sort_t *seaudit_sort_by_target_type(const int direction); +%newobject seaudit_sort_by_object_class(const int); +seaudit_sort_t *seaudit_sort_by_object_class(const int direction); +%newobject seaudit_sort_by_executable(const int); +seaudit_sort_t *seaudit_sort_by_executable(const int direction); +%newobject seaudit_sort_by_command(const int); +seaudit_sort_t *seaudit_sort_by_command(const int direction); +%newobject seaudit_sort_by_name(const int); +seaudit_sort_t *seaudit_sort_by_name(const int direction); +%newobject seaudit_sort_by_path(const int); +seaudit_sort_t *seaudit_sort_by_path(const int direction); +%newobject seaudit_sort_by_device(const int); +seaudit_sort_t *seaudit_sort_by_device(const int direction); +%newobject seaudit_sort_by_inode(const int); +seaudit_sort_t *seaudit_sort_by_inode(const int direction); +%newobject seaudit_sort_by_pid(const int); +seaudit_sort_t *seaudit_sort_by_pid(const int direction); +%newobject seaudit_sort_by_port(const int); +extern seaudit_sort_t *seaudit_sort_by_port(const int direction); +%newobject seaudit_sort_by_laddr(const int); +extern seaudit_sort_t *seaudit_sort_by_laddr(const int direction); +%newobject seaudit_sort_by_lport(const int); +extern seaudit_sort_t *seaudit_sort_by_lport(const int direction); +%newobject seaudit_sort_by_faddr(const int); +extern seaudit_sort_t *seaudit_sort_by_faddr(const int direction); +%newobject seaudit_sort_by_fport(const int); +extern seaudit_sort_t *seaudit_sort_by_fport(const int direction); +%newobject seaudit_sort_by_saddr(const int); +extern seaudit_sort_t *seaudit_sort_by_saddr(const int direction); +%newobject seaudit_sort_by_sport(const int); +extern seaudit_sort_t *seaudit_sort_by_sport(const int direction); +%newobject seaudit_sort_by_daddr(const int); +extern seaudit_sort_t *seaudit_sort_by_daddr(const int direction); +%newobject seaudit_sort_by_dport(const int); +extern seaudit_sort_t *seaudit_sort_by_dport(const int direction); +%newobject seaudit_sort_by_key(const int); +extern seaudit_sort_t *seaudit_sort_by_key(const int direction); +%newobject seaudit_sort_by_cap(const int); +extern seaudit_sort_t *seaudit_sort_by_cap(const int direction); + +/* seaudit model */ +#ifdef SWIGPYTHON +/* handle ownership of filters and sorts passed to the model */ +%typemap(in) seaudit_filter_t *filter { + void *x = NULL; + Py_IncRef($input); + SWIG_ConvertPtr($input, &x,SWIGTYPE_p_seaudit_filter, 0 | 0 ); + $1 = (seaudit_filter_t*)x; +} +%typemap(in) seaudit_sort_t *ssort { + void *x = NULL; + Py_IncRef($input); + SWIG_ConvertPtr($input, &x,SWIGTYPE_p_seaudit_sort, 0 | 0 ); + $1 = (seaudit_sort_t*)x; +} +#endif +typedef struct seaudit_model {} seaudit_model_t; +%extend seaudit_model_t { + seaudit_model_t(char *name = NULL, seaudit_log_t *slog = NULL) { + seaudit_model_t *smod; + BEGIN_EXCEPTION + smod = seaudit_model_create(name, slog); + if (!smod) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return smod; + }; + seaudit_model_t(seaudit_model_t *in) { + seaudit_model_t *smod; + BEGIN_EXCEPTION + smod = seaudit_model_create_from_model(in); + if (!smod) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return smod; + }; + seaudit_model_t(char *path) { + seaudit_model_t *smod; + BEGIN_EXCEPTION + smod = seaudit_model_create_from_file(path); + if (!smod) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return smod; + } + ~seaudit_model_t() { + seaudit_model_destroy(&self); + }; + void save(char *path) { + BEGIN_EXCEPTION + if (seaudit_model_save_to_file(self, path)) { + SWIG_exception(SWIG_RuntimeError, "Could not save seaudit model"); + } + END_EXCEPTION + fail: + return; + } + const char *get_name() { + return seaudit_model_get_name(self); + }; + void set_name(char *name) { + BEGIN_EXCEPTION + if (seaudit_model_set_name(self, name)) { + SWIG_exception(SWIG_RuntimeError, "Could not set model name"); + } + END_EXCEPTION + fail: + return; + }; + void append_log(seaudit_log_t *slog) { + BEGIN_EXCEPTION + if (seaudit_model_append_log(self, slog)) { + SWIG_exception(SWIG_RuntimeError, "Could not append log to model"); + } + END_EXCEPTION + fail: + return; + }; + void append_filter(seaudit_filter_t *filter) { + BEGIN_EXCEPTION +#ifdef SWIGJAVA /* duplicate so the garbage collector does not double free */ + seaudit_filter_t *tmp = seaudit_filter_create_from_filter(filter); + if (seaudit_model_append_filter(self, tmp)) { + seaudit_filter_destroy(&tmp); + SWIG_exception(SWIG_RuntimeError, "Could not append filter to model"); + } +#else + if (seaudit_model_append_filter(self, filter)) { + SWIG_exception(SWIG_RuntimeError, "Could not append filter to model"); + } +#endif + END_EXCEPTION + fail: + return; + }; + const apol_vector_t *get_filters() { + return seaudit_model_get_filters(self); + }; + %delobject remove_filter(); + void remove_filter(seaudit_filter_t *filter) { + BEGIN_EXCEPTION + if (seaudit_model_remove_filter(self, filter)) { + SWIG_exception(SWIG_ValueError, "Could not remove filter"); + } + END_EXCEPTION + fail: + return; + }; + void set_filter_match(seaudit_filter_match_e match) { + BEGIN_EXCEPTION + if (seaudit_model_set_filter_match(self, match)) { + SWIG_exception(SWIG_RuntimeError, "Could not set filter matching method for model"); + } + END_EXCEPTION + fail: + return; + }; + seaudit_filter_match_e get_filter_match() { + return seaudit_model_get_filter_match(self); + }; + void set_filter_visible(seaudit_filter_visible_e vis) { + BEGIN_EXCEPTION + if (seaudit_model_set_filter_visible(self, vis)) { + SWIG_exception(SWIG_RuntimeError, "Could not set filter visibility for model"); + } + END_EXCEPTION + fail: + return; + }; + seaudit_filter_visible_e get_filter_visible() { + return seaudit_model_get_filter_visible(self); + }; + void append_sort(seaudit_sort_t *ssort) { + BEGIN_EXCEPTION +#ifdef SWIGJAVA + seaudit_sort_t *tmp = seaudit_sort_create_from_sort(ssort); + if (seaudit_model_append_sort(self, tmp)) { + seaudit_sort_destroy(&tmp); + SWIG_exception(SWIG_RuntimeError, "Could not append sort to model"); + } +#else + if (seaudit_model_append_sort(self, ssort)) { + SWIG_exception(SWIG_RuntimeError, "Could not append sort to model"); + } +#endif + END_EXCEPTION + fail: + return; + }; + void clear_sorts() { + BEGIN_EXCEPTION + if (seaudit_model_clear_sorts(self)) { + SWIG_exception(SWIG_RuntimeError, "Could not clear model sorting criteria"); + } + END_EXCEPTION + fail: + return; + }; + int is_changed() { + return seaudit_model_is_changed(self); + }; + %newobject get_messages(seaudit_log_t*); + apol_vector_t *get_messages(seaudit_log_t *slog) { + apol_vector_t *v = NULL; + BEGIN_EXCEPTION + v = seaudit_model_get_messages(slog, self); + if (!v) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return v; + }; + %newobject get_malformed_messages(seaudit_log_t*); + apol_vector_t *get_malformed_messages(seaudit_log_t *slog) { + apol_vector_t *v = NULL; + BEGIN_EXCEPTION + v = seaudit_model_get_malformed_messages(slog, self); + if (!v) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return v; + }; + void hide_message(seaudit_message_t *message) { + seaudit_model_hide_message(self, message); + }; + size_t get_num_allows(seaudit_log_t *slog) { + return seaudit_model_get_num_allows(slog, self); + }; + size_t get_num_denies(seaudit_log_t *slog) { + return seaudit_model_get_num_denies(slog, self); + }; + size_t get_num_bools(seaudit_log_t *slog) { + return seaudit_model_get_num_bools(slog, self); + }; + size_t get_num_loads(seaudit_log_t *slog) { + return seaudit_model_get_num_loads(slog, self); + }; +}; + +/* seaudit report */ +typedef enum seaudit_report_format +{ + SEAUDIT_REPORT_FORMAT_TEXT, + SEAUDIT_REPORT_FORMAT_HTML +} seaudit_report_format_e; +typedef struct seaudit_report {} seaudit_report_t; +%extend seaudit_report_t { + seaudit_report_t(seaudit_model_t *m) { + seaudit_report_t *sr; + BEGIN_EXCEPTION + sr = seaudit_report_create(m); + if (!sr) { + SWIG_exception(SWIG_MemoryError, "Out of memory"); + } + END_EXCEPTION + fail: + return sr; + }; + ~seaudit_report_t() { + seaudit_report_destroy(&self); + }; + void write(seaudit_log_t *slog, char *path) { + BEGIN_EXCEPTION + if (seaudit_report_write(slog, self, path)) { + SWIG_exception(SWIG_RuntimeError, "Could not write report to file"); + } + END_EXCEPTION + fail: + return; + }; + void set_format(seaudit_log_t *slog, seaudit_report_format_e format) { + BEGIN_EXCEPTION + if (seaudit_report_set_format(slog, self, format)) { + SWIG_exception(SWIG_RuntimeError, "Could not set report format"); + } + END_EXCEPTION + fail: + return; + }; + void set_configuration(seaudit_log_t *slog, char *path) { + BEGIN_EXCEPTION + if (seaudit_report_set_configuration(slog, self, path)) { + SWIG_exception(SWIG_RuntimeError, "Could not set report configuration file"); + } + END_EXCEPTION + fail: + return; + }; + void set_stylesheet(seaudit_log_t *slog, char *path, int use_stylesheet) { + BEGIN_EXCEPTION + if (seaudit_report_set_stylesheet(slog, self, path, use_stylesheet)) { + SWIG_exception(SWIG_RuntimeError, "Could not set report stylesheet"); + } + END_EXCEPTION + fail: + return; + }; + void set_malformed(seaudit_log_t *slog, int do_malformed) { + BEGIN_EXCEPTION + if (seaudit_report_set_malformed(slog, self, do_malformed)) { + SWIG_exception(SWIG_RuntimeError, "Could not set report malformed flag"); + } + END_EXCEPTION + fail: + return; + }; +}; |