dazuko_xp.h File Reference

#include "dazukoio_xp.h"

Go to the source code of this file.

Data Structures
struct	event_properties
struct	file_properties
struct	dazuko_file_listnode
struct	dazuko_file_struct
Defines
#define	VERSION   "2.0.5"
#define	SET_ACCESS_MASK   0
#define	ADD_INCLUDE_PATH   1
#define	ADD_EXCLUDE_PATH   2
#define	REGISTER   3
#define	REMOVE_ALL_PATHS   4
#define	UNREGISTER   5
#define	GET_AN_ACCESS   6
#define	RETURN_AN_ACCESS   7
#define	DAZUKO_FREE   0
#define	DAZUKO_READY   1
#define	DAZUKO_WAITING   2
#define	DAZUKO_WORKING   3
#define	DAZUKO_DONE   4
#define	DAZUKO_BROKEN   5
#define	DAZUKO_NONE   0
#define	DAZUKO_REGULAR   1
#define	DAZUKO_DIRECTORY   2
#define	DAZUKO_LINK   3
#define	DPRINT(fmt)
Functions
int	xp_init_mutex (struct xp_mutex *mutex)
int	xp_down (struct xp_mutex *mutex)
int	xp_up (struct xp_mutex *mutex)
int	xp_destroy_mutex (struct xp_mutex *mutex)
int	xp_init_rwlock (struct xp_rwlock *rwlock)
int	xp_write_lock (struct xp_rwlock *rwlock)
int	xp_write_unlock (struct xp_rwlock *rwlock)
int	xp_read_lock (struct xp_rwlock *rlock)
int	xp_read_unlock (struct xp_rwlock *rlock)
int	xp_destroy_rwlock (struct xp_rwlock *rwlock)
int	xp_init_queue (struct xp_queue *queue)
int	xp_wait_until_condition (struct xp_queue *queue, int(*cfunction)(void *), void *cparam, int allow_interrupt)
int	xp_notify (struct xp_queue *queue)
int	xp_destroy_queue (struct xp_queue *queue)
void *	xp_malloc (size_t size)
int	xp_free (void *ptr)
int	xp_copyin (const void *user_src, void *kernel_dest, size_t size)
int	xp_copyout (const void *kernel_src, void *user_dest, size_t size)
int	xp_verify_user_writable (const void *user_ptr, size_t size)
int	xp_verify_user_readable (const void *user_ptr, size_t size)
int	xp_is_absolute_path (const char *path)
int	xp_atomic_set (struct xp_atomic *atomic, int value)
int	xp_atomic_inc (struct xp_atomic *atomic)
int	xp_atomic_dec (struct xp_atomic *atomic)
int	xp_atomic_read (struct xp_atomic *atomic)
int	xp_copy_file (struct xp_file *dest, struct xp_file *src)
int	xp_compare_file (struct xp_file *file1, struct xp_file *file2)
int	xp_sys_hook (void)
int	xp_sys_unhook (void)
int	xp_fill_file_struct (struct dazuko_file_struct *dfs)
int	xp_id_compare (struct xp_daemon_id *id1, struct xp_daemon_id *id2)
int	xp_id_free (struct xp_daemon_id *id)
xp_daemon_id *	xp_id_copy (struct xp_daemon_id *id)
int	xp_print (const char *fmt,...)
int	dazuko_vsnprintf (char *str, size_t size, const char *format, va_list ap)
int	dazuko_snprintf (char *str, size_t size, const char *format,...)
int	dazuko_is_our_daemon (struct xp_daemon_id *xp_id)
int	dazuko_get_value (const char *key, const char *string, char **value)
int	dazuko_unregister_daemon (struct xp_daemon_id *xp_id)
int	dazuko_handle_user_request (struct dazuko_request *user_request, struct xp_daemon_id *xp_id)
int	dazuko_handle_user_request_compat12 (void *ptr, int cmd, struct xp_daemon_id *xp_id)
int	dazuko_get_filename_length (char *filename)
void	dazuko_bzero (void *p, int len)
int	dazuko_sys_check (unsigned long event, int daemon_is_allowed, struct xp_daemon_id *xp_id)
int	dazuko_sys_pre (unsigned long event, struct dazuko_file_struct *kfs, struct xp_file *file, struct event_properties *event_p)
int	dazuko_sys_post (unsigned long event, struct dazuko_file_struct *kfs, struct xp_file *file, struct event_properties *event_p)
int	dazuko_init (void)
int	dazuko_exit (void)

---

Define Documentation

#define ADD_EXCLUDE_PATH   2

Definition at line 45 of file dazuko_xp.h.

#define ADD_INCLUDE_PATH   1

Definition at line 44 of file dazuko_xp.h.

#define DAZUKO_BROKEN   5

Definition at line 58 of file dazuko_xp.h.

#define DAZUKO_DIRECTORY   2

Definition at line 63 of file dazuko_xp.h.

#define DAZUKO_DONE   4

Definition at line 57 of file dazuko_xp.h.

#define DAZUKO_FREE   0

Definition at line 53 of file dazuko_xp.h.

#define DAZUKO_LINK   3

Definition at line 64 of file dazuko_xp.h.

#define DAZUKO_NONE   0

Definition at line 61 of file dazuko_xp.h.

#define DAZUKO_READY   1

Definition at line 54 of file dazuko_xp.h.

#define DAZUKO_REGULAR   1

Definition at line 62 of file dazuko_xp.h.

#define DAZUKO_WAITING   2

Definition at line 55 of file dazuko_xp.h.

#define DAZUKO_WORKING   3

Definition at line 56 of file dazuko_xp.h.

#define DPRINT (  fmt   )

Definition at line 202 of file dazuko_xp.h.

#define GET_AN_ACCESS   6

Definition at line 49 of file dazuko_xp.h.

#define REGISTER   3

Definition at line 46 of file dazuko_xp.h.

#define REMOVE_ALL_PATHS   4

Definition at line 47 of file dazuko_xp.h.

#define RETURN_AN_ACCESS   7

Definition at line 50 of file dazuko_xp.h.

#define SET_ACCESS_MASK   0

Definition at line 43 of file dazuko_xp.h.

#define UNREGISTER   5

Definition at line 48 of file dazuko_xp.h.

#define VERSION   "2.0.5"

Definition at line 38 of file dazuko_xp.h. Referenced by dazuko_exit(), and dazuko_init().

---

Function Documentation

void dazuko_bzero (  void *  p, int  len )  [inline]

Definition at line 306 of file dazuko_core.c. { /* "zero out" len bytes starting with p */ char *ptr = (char *)p; while (len--) *ptr++ = 0; }

int dazuko_exit (  void   )  [inline]

Definition at line 3458 of file dazuko_core.c. References call_xp_atomic_read(), call_xp_destroy_mutex(), call_xp_destroy_queue(), call_xp_destroy_rwlock(), call_xp_free(), call_xp_print, call_xp_sys_unhook, dazuko_remove_all_hash(), dazuko_remove_all_paths(), dazuko_remove_all_trusted(), slot_list_container::mutex, NULL, NUM_SLOTS, slot_list::reg_name, slot_list_container::slot_list, VERSION, and VERSION_STRING. { int error; int i; int j; i = call_xp_atomic_read(&active); if (i != 0) { call_xp_print("dazuko: warning: trying to remove Dazuko with %d process%s still registered\n", i, i==1 ? "" : "es"); return -1; } error = call_xp_sys_unhook(); if (error == 0) { call_xp_destroy_mutex(&mutex_unique_count); call_xp_destroy_mutex(&mutex_amc); for (i=0 ; i<NUM_SLOT_LISTS ; i++) { if (slot_lists[i].slot_list != NULL) { dazuko_remove_all_paths(slot_lists[i].slot_list); if (call_xp_atomic_read(&(slot_lists[i].slot_list->use_count)) != 0) call_xp_print("dazuko: slot_list count was not 0 (possible bug)\n"); for (j=0 ; j<NUM_SLOTS ; j++) { call_xp_destroy_mutex(&(slot_lists[i].slot_list->slots[j].mutex)); call_xp_destroy_queue(&(slot_lists[i].slot_list->slots[j].wait_daemon_waiting_until_this_slot_not_READY)); call_xp_destroy_queue(&(slot_lists[i].slot_list->slots[j].wait_kernel_waiting_until_this_slot_not_WAITING_and_not_WORKING)); call_xp_destroy_queue(&(slot_lists[i].slot_list->slots[j].wait_daemon_waiting_until_this_slot_not_DONE)); } call_xp_destroy_rwlock(&(slot_lists[i].slot_list->lock_lists)); #ifdef TRUSTED_APPLICATION_SUPPORT dazuko_remove_all_trusted(slot_lists[i].slot_list); call_xp_destroy_rwlock(&(slot_lists[i].slot_list->lock_trusted_list)); #endif call_xp_destroy_queue(&(slot_lists[i].slot_list->wait_kernel_waiting_for_any_READY_slot_or_zero_use_count)); if (slot_lists[i].slot_list->reg_name != NULL) call_xp_free(slot_lists[i].slot_list->reg_name); slot_lists[i].slot_list->reg_name = NULL; call_xp_free(slot_lists[i].slot_list); slot_lists[i].slot_list = NULL; } call_xp_destroy_mutex(&(slot_lists[i].mutex)); } call_xp_print("dazuko: unloaded, version=%s\n", VERSION_STRING); } return error; }

int dazuko_get_filename_length (  char *  filename  )  [inline]

Definition at line 2499 of file dazuko_xp.c. { int len; for (len=0 ; filename[len] ; len++); return len; }

int dazuko_get_value (  const char *  key, const char *  string, char **  value )

Definition at line 1310 of file dazuko_core.c. References call_xp_malloc(), dazuko_strlen(), dazuko_strstr(), and NULL. { const char *p1; const char *p2; int size; if (value == NULL) return -1; *value = NULL; if (key == NULL || string == NULL) return -1; p1 = dazuko_strstr(string, key); if (p1 == NULL) return -1; p1 += dazuko_strlen(key); for (p2=p1 ; *p2 && *p2!='\n' ; p2++) continue; size = (p2 - p1) + 1; *value = call_xp_malloc(size); if (*value == NULL) return -1; memcpy(*value, p1, size - 1); (*value)[size - 1] = 0; return 0; }

int dazuko_handle_user_request (  struct dazuko_request *  user_request, struct xp_daemon_id *  xp_id )

Definition at line 1653 of file dazuko_xp.c. References dazuko_request::buffer, dazuko_request::buffer_size, call_xp_copyin(), call_xp_copyout(), call_xp_free(), call_xp_malloc(), dazuko_handle_request(), NULL, dazuko_request::reply_buffer, dazuko_request::reply_buffer_size, dazuko_request::reply_buffer_size_used, dazuko_request::type, XP_ERROR_FAULT, and XP_ERROR_PERMISSION. { int error = 0; struct dazuko_request *request; struct dazuko_request *temp_request; if (user_request == NULL || xp_id == NULL) return XP_ERROR_FAULT; /* allocate kernel request */ request = (struct dazuko_request *)call_xp_malloc(sizeof(struct dazuko_request)); if (request == NULL) return XP_ERROR_FAULT; /* use out0 now */ /* allocate temp kernel request */ temp_request = (struct dazuko_request *)call_xp_malloc(sizeof(struct dazuko_request)); if (temp_request == NULL) { error = XP_ERROR_FAULT; goto dazuko_handle_user_request_out0; } /* use out1 now */ /* copy in the request */ if (call_xp_copyin(user_request, temp_request, sizeof(struct dazuko_request)) != 0) { error = XP_ERROR_FAULT; goto dazuko_handle_user_request_out1; } memcpy(request->type, temp_request->type, sizeof(char[2])); request->buffer_size = temp_request->buffer_size; /* sanity check */ if (request->buffer_size < 0 || request->buffer_size > 8192) { error = XP_ERROR_FAULT; goto dazuko_handle_user_request_out1; } request->reply_buffer_size = temp_request->reply_buffer_size; /* sanity check */ if (request->reply_buffer_size < 0 || request->reply_buffer_size > 8192) { error = XP_ERROR_PERMISSION; goto dazuko_handle_user_request_out1; } /* allocate buffer */ request->buffer = (char *)call_xp_malloc(request->buffer_size + 1); if (request->buffer == NULL) { error = XP_ERROR_FAULT; goto dazuko_handle_user_request_out1; } /* use out2 now */ if (request->reply_buffer_size > 0) { /* allocate reply buffer */ request->reply_buffer = (char *)call_xp_malloc(request->reply_buffer_size + 1); if (request->reply_buffer == NULL) { error = XP_ERROR_FAULT; goto dazuko_handle_user_request_out2; } /* use out3 now */ request->reply_buffer_size_used = 0; } /* copy the buffer from userspace to kernelspace */ if (call_xp_copyin(temp_request->buffer, request->buffer, request->buffer_size) != 0) { error = XP_ERROR_FAULT; goto dazuko_handle_user_request_out3; } request->buffer[request->buffer_size] = 0; error = dazuko_handle_request(request, xp_id); if (error == 0 && request->reply_buffer_size > 0) { request->reply_buffer[request->reply_buffer_size] = 0; temp_request->reply_buffer_size_used = request->reply_buffer_size_used; if (call_xp_copyout(temp_request, user_request, sizeof(struct dazuko_request)) != 0) { error = XP_ERROR_FAULT; goto dazuko_handle_user_request_out3; } if (request->reply_buffer_size_used > 0) { if (call_xp_copyout(request->reply_buffer, temp_request->reply_buffer, request->reply_buffer_size_used) != 0) { error = XP_ERROR_FAULT; goto dazuko_handle_user_request_out3; } } } dazuko_handle_user_request_out3: if (request->reply_buffer_size > 0) call_xp_free(request->reply_buffer); dazuko_handle_user_request_out2: call_xp_free(request->buffer); dazuko_handle_user_request_out1: call_xp_free(temp_request); dazuko_handle_user_request_out0: call_xp_free(request); return error; }

int dazuko_handle_user_request_compat12 (  void *  ptr, int  cmd, struct xp_daemon_id *  xp_id )

Definition at line 1776 of file dazuko_xp.c. References call_xp_copyin(), call_xp_copyout(), call_xp_free(), call_xp_id_copy(), call_xp_id_free(), call_xp_malloc(), call_xp_print, call_xp_up(), call_xp_verify_user_readable(), call_xp_verify_user_writable(), DAZUKO_FILENAME_MAX_LENGTH_COMPAT12, dazuko_get_an_access(), dazuko_register_daemon(), dazuko_return_access(), dazuko_set_option(), dazuko_state_error(), DAZUKO_WORKING, access_compat12::deny, slot::event, access_compat12::event, slot::event_p, access_compat12::filename, slot::filename, slot::filenamelength, event_properties::flags, IOCTL_GET_AN_ACCESS, IOCTL_RETURN_ACCESS, IOCTL_SET_OPTION, event_properties::mode, slot::mutex, NULL, access_compat12::o_flags, access_compat12::o_mode, event_properties::pid, access_compat12::pid, REGISTER, event_properties::uid, access_compat12::uid, daemon_id::unique, XP_ERROR_FAULT, XP_ERROR_INTERRUPT, XP_ERROR_INVALID, and daemon_id::xp_id. Referenced by linux_dazuko_device_ioctl(). { struct access_compat12 *user_request12; struct access_compat12 *temp_request12; int error = 0; struct slot *s; char *k_param; struct daemon_id did; int temp_length; int temp_int; if (ptr == NULL || xp_id == NULL) return XP_ERROR_FAULT; did.xp_id = call_xp_id_copy(xp_id); did.unique = -1; switch (cmd) { case IOCTL_GET_AN_ACCESS: /* The daemon is requesting a filename of a file * to scan. This code will wait until a filename * is available, or until we should be killed. * (killing is done if any errors occur as well * as when the user kills us) */ user_request12 = (struct access_compat12 *)ptr; error = call_xp_verify_user_writable(user_request12, sizeof(struct access_compat12)); if (error) { error = XP_ERROR_FAULT; break; } /* DOWN? */ s = dazuko_get_an_access(&did); if (s == NULL) { error = XP_ERROR_INTERRUPT; break; } /* DOWN */ /* Slot IS in WORKING state. Copy all the * necessary information to userspace structure. */ if (s->filenamelength >= DAZUKO_FILENAME_MAX_LENGTH_COMPAT12) { /* filename length overflow :( */ s->filename[DAZUKO_FILENAME_MAX_LENGTH_COMPAT12 - 1] = 0; temp_length = DAZUKO_FILENAME_MAX_LENGTH_COMPAT12; } else { temp_length = s->filenamelength + 1; } temp_request12 = (struct access_compat12 *)call_xp_malloc(sizeof(struct access_compat12)); if (temp_request12 == NULL) { error = XP_ERROR_FAULT; } else if (call_xp_copyin(user_request12, temp_request12, sizeof(struct access_compat12)) != 0) { error = XP_ERROR_FAULT; } if (error == 0) { temp_request12->event = s->event; temp_request12->o_flags = s->event_p.flags; temp_request12->o_mode = s->event_p.mode; temp_request12->uid = s->event_p.uid; temp_request12->pid = s->event_p.pid; memcpy(temp_request12->filename, s->filename, temp_length); if (call_xp_copyout(temp_request12, user_request12, sizeof(struct access_compat12)) != 0) { error = XP_ERROR_FAULT; } } call_xp_up(&(s->mutex)); /* UP */ if (error) { dazuko_state_error(s, DAZUKO_WORKING); } if (temp_request12 != NULL) { call_xp_free(temp_request12); } break; case IOCTL_RETURN_ACCESS: /* The daemon has finished scanning a file * and has the response to give. The daemon's * slot should be in the WORKING state. */ user_request12 = (struct access_compat12 *)ptr; error = call_xp_verify_user_readable(user_request12, sizeof(struct access_compat12)); if (error) { error = XP_ERROR_FAULT; break; } temp_request12 = (struct access_compat12 *)call_xp_malloc(sizeof(struct access_compat12)); if (temp_request12 == NULL) { error = XP_ERROR_FAULT; break; } if (call_xp_copyin(user_request12, temp_request12, sizeof(struct access_compat12)) != 0) { error = XP_ERROR_FAULT; } temp_int = temp_request12->deny; call_xp_free(temp_request12); error = dazuko_return_access(&did, temp_int, NULL); break; case IOCTL_SET_OPTION: /* The daemon wants to set a configuration * option in the kernel. */ error = call_xp_verify_user_readable(ptr, 2*sizeof(int)); if (error) { error = XP_ERROR_FAULT; break; } /* copy option type from userspace */ if (call_xp_copyin(ptr, &temp_int, sizeof(int)) != 0) { error = XP_ERROR_FAULT; break; } ptr = ((char *)ptr + sizeof(int)); /* copy path length from userspace */ if (call_xp_copyin(ptr, &temp_length, sizeof(int)) != 0) { error = XP_ERROR_FAULT; break; } /* sanity check */ if (temp_length < 0 || temp_length > 4096) { error = XP_ERROR_INVALID; break; } ptr = ((char *)ptr + sizeof(int)); error = call_xp_verify_user_readable(ptr, temp_length); if (error) { error = XP_ERROR_FAULT; break; } k_param = (char *)call_xp_malloc(temp_length + 1); if (k_param == NULL) { error = XP_ERROR_FAULT; break; } /* We must copy the param from userspace to kernelspace. */ if (call_xp_copyin(ptr, k_param, temp_length) != 0) { call_xp_free(k_param); error = XP_ERROR_FAULT; break; } k_param[temp_length] = 0; if (temp_int == REGISTER) error = dazuko_register_daemon(&did, k_param, temp_length, 1); else error = dazuko_set_option(&did, temp_int, k_param, temp_length); call_xp_free(k_param); break; default: call_xp_print("dazuko: daemon requested unknown device_ioctl %d (possible bug)\n", cmd); break; } call_xp_id_free(did.xp_id); return error; }

int dazuko_init (  void   )  [inline]

Definition at line 3432 of file dazuko_core.c. References access_mask_cache, AMC_UNSET, call_xp_atomic_set(), call_xp_init_mutex(), call_xp_init_queue(), call_xp_init_rwlock(), call_xp_print, call_xp_sys_hook, dazuko_bzero(), VERSION, and VERSION_STRING. { int i; int error; call_xp_init_mutex(&mutex_unique_count); call_xp_init_mutex(&mutex_amc); dazuko_bzero(&slot_lists, sizeof(slot_lists)); memset(&access_mask_cache, AMC_UNSET, sizeof(access_mask_cache)); for (i=0 ; i<NUM_SLOT_LISTS ; i++) call_xp_init_mutex(&(slot_lists[i].mutex)); call_xp_atomic_set(&active, 0); call_xp_atomic_set(&groupcount, 0); error = call_xp_sys_hook(); if (error == 0) call_xp_print("dazuko: loaded, version=%s\n", VERSION_STRING); return error; }

int dazuko_is_our_daemon (  struct xp_daemon_id *  xp_id  )  [inline]

Definition at line 2218 of file dazuko_xp.c. References call_xp_id_copy(), call_xp_id_free(), dazuko_find_slot(), NULL, daemon_id::unique, and daemon_id::xp_id. { /* Check if the current process is one * of the daemons. */ struct daemon_id did; int ret; did.xp_id = call_xp_id_copy(xp_id); did.unique = -1; ret = (dazuko_find_slot(&did, 1, NULL) != NULL); call_xp_id_free(did.xp_id); return ret; }

int dazuko_snprintf (  char *  str, size_t  size, const char *  format,   ... )

Definition at line 294 of file dazuko_core.c. References dazuko_vsnprintf(). { va_list ap; int ret; va_start(ap, format); ret = dazuko_vsnprintf(str, size, format, ap); va_end(ap); return ret; }

int dazuko_sys_check (  unsigned long  event, int  daemon_is_allowed, struct xp_daemon_id *  xp_id )  [inline]

Definition at line 2563 of file dazuko_xp.c. References access_mask, call_xp_atomic_read(), dazuko_is_our_daemon(), DAZUKO_ON_CLOSE, DAZUKO_ON_OPEN, SCAN_ON_CLOSE, SCAN_ON_CLOSE_MODIFIED, and SCAN_ON_OPEN. Referenced by rsbac_adf_request_daz(), and rsbac_adf_set_attr_daz(). { /* is this event in our mask? */ switch (event) { case DAZUKO_ON_OPEN: /* this is a special case because the on_close information needs * to be saved during the on_open event */ if ((SCAN_ON_OPEN || SCAN_ON_CLOSE || SCAN_ON_CLOSE_MODIFIED) == 0) return -1; break; case DAZUKO_ON_CLOSE: /* will need to scan if ON_CLOSE_MODIFIED is in the mask too */ if ((SCAN_ON_CLOSE || SCAN_ON_CLOSE_MODIFIED) == 0) return -1; break; default: if ((access_mask & event) == 0) return -1; break; } /* do we have any daemons? */ if (call_xp_atomic_read(&active) <= 0) return -1; /* should daemons be allowed this event without a scan? */ if (daemon_is_allowed) { if (dazuko_is_our_daemon(xp_id)) { /* this is one of our daemons, so we will report as * as if this event was not in the mask */ return -1; } } return 0; }

int dazuko_sys_post (  unsigned long  event, struct dazuko_file_struct *  kfs, struct xp_file *  file, struct event_properties *  event_p )  [inline]

Definition at line 2727 of file dazuko_xp.c. References call_xp_atomic_read(), call_xp_free(), dazuko_add_hash(), dazuko_get_hash(), dazuko_mark_hash_dirty(), DAZUKO_ON_CLOSE, DAZUKO_ON_CLOSE_MODIFIED, DAZUKO_ON_OPEN, dazuko_run_daemon(), dazuko_should_scan(), hash::dirty, hash::name, hash::namelen, NULL, SCAN_ON_CLOSE, SCAN_ON_CLOSE_MODIFIED, and SCAN_ON_OPEN. Referenced by rsbac_adf_set_attr_daz(). { struct hash *h = NULL; switch (event) { case DAZUKO_ON_OPEN: /* kfs,file required */ /* if the file was opened and we are interested * in scanning on close, add this file to our struct hash list */ if ((call_xp_atomic_read(&active) > 0) && file != NULL && kfs != NULL) { if (SCAN_ON_OPEN || SCAN_ON_CLOSE || SCAN_ON_CLOSE_MODIFIED) { /* make sure we should scan this file */ if (dazuko_should_scan(kfs)) { /* hash is added if we were given an xp_file */ if (file != NULL) dazuko_add_hash(file, kfs->filename, kfs->filename_length); /* this is a fallback in case we didn't process the event in "sys_pre" */ dazuko_run_daemon(event, kfs->filename, kfs->filename_length, event_p, &(kfs->file_p)); } } } break; case DAZUKO_ON_CLOSE: /* file,o_flags,o_mode,pid,uid required */ if (file != NULL) { /* find hash entry and remove it from list */ h = dazuko_get_hash(file); /* if we found the file in our list and the file was * successfully closed, we need to scan it */ if (h != NULL) { /* determine if we are scanning on close or close_modified */ /* note that close_modified has priority over just close */ if (SCAN_ON_CLOSE_MODIFIED && h->dirty) dazuko_run_daemon(DAZUKO_ON_CLOSE_MODIFIED, h->name, h->namelen, event_p, NULL); else if (SCAN_ON_CLOSE) dazuko_run_daemon(DAZUKO_ON_CLOSE, h->name, h->namelen, event_p, NULL); /* clean up the struct hash structure */ call_xp_free(h); } } else { if (SCAN_ON_CLOSE) { if (dazuko_should_scan(kfs)) { dazuko_run_daemon(DAZUKO_ON_CLOSE, kfs->filename, kfs->filename_length, event_p, &(kfs->file_p)); } } } break; case DAZUKO_ON_CLOSE_MODIFIED: /* file required */ if (file != NULL) { /* if we actually wrote something and we found the * file in our list, set it as dirty */ /* Swade 4/24/02: Move to end of clean list */ dazuko_mark_hash_dirty(file); } break; default: break; } return 0; }

int dazuko_sys_pre (  unsigned long  event, struct dazuko_file_struct *  kfs, struct xp_file *  file, struct event_properties *  event_p )  [inline]

Definition at line 2608 of file dazuko_xp.c. References call_xp_compare_file(), call_xp_malloc(), call_xp_print, call_xp_read_lock(), call_xp_read_unlock(), DAZUKO_ON_CLOSE, DAZUKO_ON_CLOSE_MODIFIED, DAZUKO_ON_OPEN, dazuko_run_daemon(), dazuko_should_scan(), dazuko_file_struct::extra_data, hash::file, dazuko_file_struct::filename, dazuko_file_struct::filename_length, hash::name, hash::namelen, hash::next, NULL, SCAN_ON_OPEN, dazuko_file_struct::should_scan, XP_ERROR_INTERRUPT, and XP_ERROR_PERMISSION. Referenced by rsbac_adf_request_daz(). { /* return codes: * >0 -> access should be blocked * <0 -> access should be blocked (because user interrupted) * 0 -> access is allowed * -2 -> unscanned access should not be taken care of */ int error = 0; struct hash *h = NULL; switch (event) { case DAZUKO_ON_OPEN: /* special case, because this pre may be called * in order to record ON_CLOSE events (in post) */ if (!SCAN_ON_OPEN) return 2; break; case DAZUKO_ON_CLOSE: /* handled in post */ return 2; case DAZUKO_ON_CLOSE_MODIFIED: /* (this is really sys_write) always permitted */ return 2; default: break; } if (kfs == NULL) { /* kfs is required */ call_xp_print("dazuko: kfs=NULL (possible bug)\n"); return XP_ERROR_PERMISSION; } if (file != NULL) { /* we search for the file descriptor first */ /* LOCK */ call_xp_read_lock(&lock_hash); for (h=hash ; h ; h=h->next) { if (call_xp_compare_file(&(h->file), file) == 0) { /* we found the file descriptor */ kfs->filename = (char*)call_xp_malloc(h->namelen + 1); if (kfs->filename != NULL) { memcpy(kfs->filename, h->name, h->namelen); kfs->filename[h->namelen] = 0; kfs->filename_length = h->namelen; kfs->should_scan = 1; } else { /* error allocating, so we get out */ h = NULL; } break; } } call_xp_read_unlock(&lock_hash); /* UNLOCK */ if (h == NULL && kfs->extra_data == NULL) { /* we don't know this file descriptor * and we cannot fallback on name lookups */ /* we should not scan this file */ kfs->should_scan = 2; return 0; } } /* make sure we should scan this file */ if (dazuko_should_scan(kfs)) error = dazuko_run_daemon(event, kfs->filename, kfs->filename_length, event_p, &(kfs->file_p)); else return 2; if (error > 0) { /* access will be blocked */ /* dazuko_sys_post should NOT be called! */ return XP_ERROR_PERMISSION; } else if (error < 0) { /* user interrupted */ /* dazuko_sys_post should NOT be called! */ return XP_ERROR_INTERRUPT; } /* access allowed */ return 0; }

int dazuko_unregister_daemon (  struct xp_daemon_id *  xp_id  )

Definition at line 834 of file dazuko_core.c. References _dazuko_unregister_daemon(), call_xp_id_copy(), call_xp_id_free(), NULL, daemon_id::unique, and daemon_id::xp_id. { struct daemon_id did; int ret; if (xp_id == NULL) return 0; did.unique = -1; did.xp_id = call_xp_id_copy(xp_id); ret = _dazuko_unregister_daemon(&did); call_xp_id_free(did.xp_id); return ret; }

int dazuko_vsnprintf (  char *  str, size_t  size, const char *  format, va_list  ap )

Definition at line 176 of file dazuko_core.c. References DAZUKO_VSNPRINTF_PRINTSTRING, and NULL. { char *target; const char *end; int overflow = 0; char number_buffer[32]; /* 32 should be enough to hold any number, right? */ const char *s; if (str == NULL || size < 1 || format == NULL) return -1; target = str; end = (target + size) - 1; #define DAZUKO_VSNPRINTF_PRINTSTRING \ for ( ; *s ; s++) \ { \ if (target == end) \ { \ overflow = 1; \ goto dazuko_vsnprintf_out; \ } \ *target = *s; \ target++; \ } for ( ; *format ; format++) { if (target == end) { overflow = 1; goto dazuko_vsnprintf_out; } if (*format == '%') { format++; switch (*format) { case 's': /* %s */ s = va_arg(ap, char *); if (s == NULL) s = "(null)"; DAZUKO_VSNPRINTF_PRINTSTRING break; case 'd': /* %d */ sprintf(number_buffer, "%d", va_arg(ap, int)); s = number_buffer; DAZUKO_VSNPRINTF_PRINTSTRING break; case 'p': /* %p */ sprintf(number_buffer, "%p", va_arg(ap, void *)); s = number_buffer; DAZUKO_VSNPRINTF_PRINTSTRING break; case 'c': /* %c */ *target = va_arg(ap, int); target++; break; case 'l': /* %lu */ format++; if (*format != 'u') { /* print error message */ goto dazuko_vsnprintf_out; } sprintf(number_buffer, "%lu", va_arg(ap, unsigned long)); s = number_buffer; DAZUKO_VSNPRINTF_PRINTSTRING break; case '0': /* %02x */ format++; if (*format != '2') { /* print error message */ goto dazuko_vsnprintf_out; } format++; if (*format != 'x') { /* print error message */ goto dazuko_vsnprintf_out; } sprintf(number_buffer, "%02x", va_arg(ap, int)); s = number_buffer; DAZUKO_VSNPRINTF_PRINTSTRING break; default: /* print error message */ goto dazuko_vsnprintf_out; } } else { *target = *format; target++; } } dazuko_vsnprintf_out: *target = 0; /* We are returning what we've written. If there was an * overflow, the returned value will match "size" rather * than being less than "size" */ return ((target - str) + overflow); }

int xp_atomic_dec (  struct xp_atomic *  atomic  )  [inline]

Definition at line 302 of file daz_main.c. References xp_atomic::atomic. { #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) #ifdef MODULE if (atomic == &active) MOD_DEC_USE_COUNT; #endif #endif atomic_dec(&(atomic->atomic)); return 0; }

int xp_atomic_inc (  struct xp_atomic *  atomic  )  [inline]

Definition at line 289 of file daz_main.c. References xp_atomic::atomic. { #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) #ifdef MODULE if (atomic == &active) MOD_INC_USE_COUNT; #endif #endif atomic_inc(&(atomic->atomic)); return 0; }

int xp_atomic_read (  struct xp_atomic *  atomic  )  [inline]

Definition at line 315 of file daz_main.c. References xp_atomic::atomic. { return atomic_read(&(atomic->atomic)); }

int xp_atomic_set (  struct xp_atomic *  atomic, int  value )  [inline]

Definition at line 283 of file daz_main.c. References xp_atomic::atomic. { atomic_set(&(atomic->atomic), value); return 0; }

int xp_compare_file (  struct xp_file *  file1, struct xp_file *  file2 )  [inline]

Definition at line 328 of file daz_main.c. { return 0; }

int xp_copy_file (  struct xp_file *  dest, struct xp_file *  src )  [inline]

Definition at line 323 of file daz_main.c. { return 0; }

int xp_copyin (  const void *  user_src, void *  kernel_dest, size_t  size )  [inline]

Definition at line 252 of file daz_main.c. { return copy_from_user(kernel_dest, user_src, size); }

int xp_copyout (  const void *  kernel_src, void *  user_dest, size_t  size )  [inline]

Definition at line 257 of file daz_main.c. { return copy_to_user(user_dest, kernel_src, size); }

int xp_destroy_mutex (  struct xp_mutex *  mutex  )  [inline]

Definition at line 159 of file daz_main.c. { return 0; }

int xp_destroy_queue (  struct xp_queue *  queue  )  [inline]

Definition at line 233 of file daz_main.c. { return 0; }

int xp_destroy_rwlock (  struct xp_rwlock *  rwlock  )  [inline]

Definition at line 197 of file daz_main.c. { return 0; }

int xp_down (  struct xp_mutex *  mutex  )  [inline]

Definition at line 147 of file daz_main.c. References xp_mutex::mutex. { down(&(mutex->mutex)); return 0; }

int xp_fill_file_struct (  struct dazuko_file_struct *  dfs  )  [inline]

Definition at line 333 of file daz_main.c. References dazuko_get_filename_length(), xp_file_struct::dentry, file_properties::device_type, dazuko_file_struct::extra_data, dazuko_file_struct::file_p, dazuko_file_struct::filename, dazuko_file_struct::filename_length, xp_file_struct::free_full_filename, xp_file_struct::full_filename, xp_file_struct::full_filename_length, file_properties::gid, file_properties::mode, NULL, rsbac_get_full_path(), rsbac_get_full_path_length(), file_properties::set_device_type, file_properties::set_gid, file_properties::set_mode, file_properties::set_size, file_properties::set_uid, file_properties::size, file_properties::uid, and xp_malloc(). { int length; /* make sure we have access to everything */ if (dfs == NULL) return -1; if (dfs->extra_data == NULL) return -1; if (dfs->extra_data->dentry == NULL) return -1; if (dfs->extra_data->dentry->d_inode == NULL) return -1; /* ok, we have everything we need */ length = rsbac_get_full_path_length(dfs->extra_data->dentry); if (length < 1) return -1; dfs->extra_data->full_filename = xp_malloc(length + 1); if (dfs->extra_data->full_filename == NULL) return -1; /* the full_filename will need to be deleted later */ dfs->extra_data->free_full_filename = 1; if (rsbac_get_full_path(dfs->extra_data->dentry, dfs->extra_data->full_filename, length + 1) < 1) return -1; /* find the actual value of the length */ dfs->extra_data->full_filename_length = dazuko_get_filename_length(dfs->extra_data->full_filename); /* reference copy of full path */ dfs->filename = dfs->extra_data->full_filename; dfs->filename_length = dfs->extra_data->full_filename_length; dfs->file_p.size = dfs->extra_data->dentry->d_inode->i_size; dfs->file_p.set_size = 1; dfs->file_p.uid = dfs->extra_data->dentry->d_inode->i_uid; dfs->file_p.set_uid = 1; dfs->file_p.gid = dfs->extra_data->dentry->d_inode->i_gid; dfs->file_p.set_gid = 1; dfs->file_p.mode = dfs->extra_data->dentry->d_inode->i_mode; dfs->file_p.set_mode = 1; #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) dfs->file_p.device_type = dfs->extra_data->dentry->d_inode->i_dev; #else dfs->file_p.device_type = dfs->extra_data->dentry->d_inode->i_rdev; #endif dfs->file_p.set_device_type = 1; return 0; }

int xp_free (  void *  ptr  )  [inline]

Definition at line 246 of file daz_main.c. { kfree(ptr); return 0; }

int xp_id_compare (  struct xp_daemon_id *  id1, struct xp_daemon_id *  id2 )

Definition at line 419 of file daz_main.c. References xp_daemon_id::file, NULL, and xp_daemon_id::pid. { if (id1 == NULL || id2 == NULL) return -1; /* if file's are available and they match, * then we say that the id's match */ if (id1->file != NULL && id1->file == id2->file) return 0; if (id1->pid == id2->pid) return 0; return 1; }

struct xp_daemon_id* xp_id_copy (  struct xp_daemon_id *  id  )  [inline]

Definition at line 442 of file daz_main.c. References xp_daemon_id::file, NULL, xp_daemon_id::pid, and xp_malloc(). { struct xp_daemon_id *ptr; if (id == NULL) return NULL; ptr = (struct xp_daemon_id *)xp_malloc(sizeof(struct xp_daemon_id)); if (ptr != NULL) { ptr->pid = id->pid; ptr->file = id->file; } return ptr; }

int xp_id_free (  struct xp_daemon_id *  id  )  [inline]

Definition at line 435 of file daz_main.c. References xp_free(). { xp_free(id); return 0; }

int xp_init_mutex (  struct xp_mutex *  mutex  )  [inline]

Definition at line 136 of file daz_main.c. References xp_mutex::mutex. { #ifdef init_MUTEX init_MUTEX(&(mutex->mutex)); #else sema_init(&(mutex->mutex), 1); #endif return 0; }

int xp_init_queue (  struct xp_queue *  queue  )  [inline]

Definition at line 205 of file daz_main.c. References xp_queue::queue. { init_waitqueue_head(&(queue->queue)); return 0; }

int xp_init_rwlock (  struct xp_rwlock *  rwlock  )  [inline]

Definition at line 167 of file daz_main.c. References xp_rwlock::rwlock. { rwlock_init(&(rwlock->rwlock)); return 0; }

int xp_is_absolute_path (  const char *  path  )  [inline]

Definition at line 275 of file daz_main.c. { return (path[0] == '/'); }

void* xp_malloc (  size_t  size  )  [inline]

Definition at line 241 of file daz_main.c. References rsbac_kmalloc(). { return rsbac_kmalloc(size); }

int xp_notify (  struct xp_queue *  queue  )  [inline]

Definition at line 227 of file daz_main.c. References xp_queue::queue. { wake_up(&(queue->queue)); return 0; }

int xp_print (  const char *  fmt,   ... )

Definition at line 522 of file daz_main.c. References dazuko_vsnprintf(), rsbac_printk(), xp_free(), and xp_malloc(). { va_list args; char *p; size_t size = 1024; p = (char *)xp_malloc(size); if (!p) return -1; va_start(args, fmt); dazuko_vsnprintf(p, size-1, fmt, args); va_end(args); p[size-1] = 0; rsbac_printk(p); xp_free(p); return 0; }

int xp_read_lock (  struct xp_rwlock *  rlock  )  [inline]

Definition at line 185 of file daz_main.c. References xp_rwlock::rwlock. { read_lock(&(rlock->rwlock)); return 0; }

int xp_read_unlock (  struct xp_rwlock *  rlock  )  [inline]

Definition at line 191 of file daz_main.c. References xp_rwlock::rwlock. { read_unlock(&(rlock->rwlock)); return 0; }

int xp_sys_hook (  void   )  [inline]

Definition at line 463 of file daz_main.c. References dev_major, DEVICE_NAME, fops, NULL, and xp_print(). { /* Called insmod when inserting the module. */ /* register the dazuko device */ #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) dev_major = register_chrdev(CONFIG_RSBAC_DAZ_DEV_MAJOR, DEVICE_NAME, &fops); devfs_mk_cdev(MKDEV(dev_major, CONFIG_RSBAC_DAZ_DEV_MAJOR), S_IFCHR | S_IRUSR | S_IWUSR, DEVICE_NAME); #else #ifdef CONFIG_DEVFS_FS dev_major = devfs_register_chrdev(CONFIG_RSBAC_DAZ_DEV_MAJOR, DEVICE_NAME, &fops); devfs_register(NULL, DEVICE_NAME, DEVFS_FL_DEFAULT, dev_major, 0, S_IFCHR | S_IRUSR | S_IWUSR, &fops, NULL); #else dev_major = register_chrdev(CONFIG_RSBAC_DAZ_DEV_MAJOR, DEVICE_NAME, &fops); #endif #endif if (dev_major < 0) { xp_print("dazuko: unable to register device chrdev, err=%d\n", dev_major); return dev_major; } /* initialization complete */ return 0; }

int xp_sys_unhook (  void   )  [inline]

Definition at line 493 of file daz_main.c. References dev_major, DEVICE_NAME, NULL, and xp_print(). { /* Called by rmmod when removing the module. */ int error; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) error = unregister_chrdev(dev_major, DEVICE_NAME); devfs_remove(DEVICE_NAME); #else #ifdef CONFIG_DEVFS_FS error = devfs_unregister_chrdev(dev_major, DEVICE_NAME); devfs_unregister(devfs_find_handle(NULL, DEVICE_NAME, dev_major, 0, DEVFS_SPECIAL_CHR, 0)); #else error = unregister_chrdev(dev_major, DEVICE_NAME); #endif #endif if (error < 0) { xp_print("dazuko: error unregistering chrdev, err=%d\n", error); } return 0; }

int xp_up (  struct xp_mutex *  mutex  )  [inline]

Definition at line 153 of file daz_main.c. References xp_mutex::mutex. { up(&(mutex->mutex)); return 0; }

int xp_verify_user_readable (  const void *  user_ptr, size_t  size )  [inline]

Definition at line 267 of file daz_main.c. { return 0; }

int xp_verify_user_writable (  const void *  user_ptr, size_t  size )  [inline]

Definition at line 262 of file daz_main.c. { return 0; }

int xp_wait_until_condition (  struct xp_queue *  queue, int(*)(void *)  cfunction, void *  cparam, int  allow_interrupt )  [inline]

Definition at line 211 of file daz_main.c. References xp_queue::queue, wait_event, and wait_event_interruptible. { /* wait until cfunction(cparam) != 0 (condition is true) */ if (allow_interrupt) { return wait_event_interruptible(queue->queue, cfunction(cparam) != 0); } else { wait_event(queue->queue, cfunction(cparam) != 0); } return 0; }

int xp_write_lock (  struct xp_rwlock *  rwlock  )  [inline]

Definition at line 173 of file daz_main.c. References xp_rwlock::rwlock. { write_lock(&(rwlock->rwlock)); return 0; }

int xp_write_unlock (  struct xp_rwlock *  rwlock  )  [inline]

Definition at line 179 of file daz_main.c. References xp_rwlock::rwlock. { write_unlock(&(rwlock->rwlock)); return 0; }

---