dazuko_core.h File Reference

#include "dazuko_transport.h"
#include "dazuko_events.h"

Go to the source code of this file.

Defines
#define	DAZUKO_DIFFERENT   0
#define	DAZUKO_SUSPICIOUS   1
#define	DAZUKO_CHILD   2
#define	DAZUKO_SAME   3
#define	DAZUKO_NONE   0
#define	DAZUKO_REGULAR   1
#define	DAZUKO_DIRECTORY   2
#define	DAZUKO_LINK   3
#define	DPRINT(fmt)
Functions
void	xp_init_mutex (struct xp_mutex *mutex)
void	xp_down (struct xp_mutex *mutex)
void	xp_up (struct xp_mutex *mutex)
void	xp_destroy_mutex (struct xp_mutex *mutex)
void	xp_init_rwlock (struct xp_rwlock *rwlock)
void	xp_write_lock (struct xp_rwlock *rwlock)
void	xp_write_unlock (struct xp_rwlock *rwlock)
void	xp_read_lock (struct xp_rwlock *rlock)
void	xp_read_unlock (struct xp_rwlock *rlock)
void	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_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 check_related)
int	xp_id_free (struct xp_daemon_id *id)
xp_daemon_id *	xp_id_copy (struct xp_daemon_id *id)
int	xp_set_event_properties (struct event_properties *event_p, struct xp_daemon_id *xp_id)
int	xp_init_cache (unsigned long ttl)
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, struct slot_list **slotlist)
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 (const char *request_buffer, struct xp_daemon_id *xp_id)
int	dazuko_handle_user_request_compat1 (void *ptr, int cmd, struct xp_daemon_id *xp_id)
int	dazuko_get_filename_length (const char *filename)
void	dazuko_bzero (void *p, int len)
int	dazuko_check_access (unsigned long event, int daemon_is_allowed, struct xp_daemon_id *xp_id, struct slot_list **cached_lookup)
int	dazuko_process_access (unsigned long event, struct dazuko_file_struct *kfs, struct event_properties *event_p, struct slot_list *cached_lookup)
int	dazuko_init (void)
int	dazuko_exit (void)

---

Define Documentation

#define DAZUKO_CHILD   2

Definition at line 44 of file dazuko_core.h. Referenced by dazuko_is_our_daemon(), and xp_id_compare().

#define DAZUKO_DIFFERENT   0

Definition at line 42 of file dazuko_core.h. Referenced by xp_id_compare().

#define DAZUKO_DIRECTORY   2

Definition at line 50 of file dazuko_core.h. Referenced by xp_fill_file_struct().

#define DAZUKO_LINK   3

Definition at line 51 of file dazuko_core.h. Referenced by xp_fill_file_struct().

#define DAZUKO_NONE   0

Definition at line 48 of file dazuko_core.h.

#define DAZUKO_REGULAR   1

Definition at line 49 of file dazuko_core.h. Referenced by xp_fill_file_struct().

#define DAZUKO_SAME   3

Definition at line 45 of file dazuko_core.h. Referenced by _dazuko_find_slot(), dazuko_add_trusted_daemon(), dazuko_is_our_daemon(), dazuko_unregister_trusted_daemon(), and xp_id_compare().

#define DAZUKO_SUSPICIOUS   1

Definition at line 43 of file dazuko_core.h. Referenced by dazuko_is_our_daemon(), and xp_id_compare().

#define DPRINT (  fmt   )

Definition at line 187 of file dazuko_core.h. Referenced by _dazuko_unregister_daemon(), dazuko_get_an_access(), dazuko_handle_request_return_an_access(), dazuko_handle_user_request_compat1(), dazuko_insert_path_fs(), dazuko_is_our_daemon(), dazuko_register_daemon(), dazuko_remove_all_hash(), dazuko_remove_all_paths(), dazuko_return_access(), dazuko_run_daemon_on_slotlist(), linux_dazuko_device_open(), linux_dazuko_device_read(), and linux_dazuko_device_release().

---

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_check_access (  unsigned long  event, int  daemon_is_allowed, struct xp_daemon_id *  xp_id, struct slot_list **  cached_lookup )

Definition at line 3327 of file dazuko_core.c. References access_mask_cache, AMC_UNSET, call_xp_atomic_read(), call_xp_down(), call_xp_up(), dazuko_event2index(), dazuko_is_our_daemon(), NULL, and NUM_EVENTS. Referenced by dazuko_sys_generic(), and linux_dazuko_sys_generic(). { int i; struct slot_list *sl = NULL; /* do we have any daemons? */ if (call_xp_atomic_read(&active) <= 0) return -1; /* is a group interested in this event type? */ i = dazuko_event2index(event); if (i < 0 || i >= NUM_EVENTS) return -1; /* DOWN */ call_xp_down(&mutex_amc); i = access_mask_cache[i][0]; call_xp_up(&mutex_amc); /* UP */ if (i == AMC_UNSET) return -1; if (dazuko_is_our_daemon(xp_id, &sl)) { /* should daemons be allowed this event without a scan? */ if (daemon_is_allowed) { /* this is one of our daemons, so we will report as * as if this event was not in the mask */ return -1; } else { /* this is one of our daemons, but the * other groups must be informed */ /* if there are no other groups, allow this event */ if (call_xp_atomic_read(&groupcount) == 1) return -1; if (cached_lookup != NULL) { /* this slot list (ours) will be skipped */ *cached_lookup = sl; } } } /* if we made it this far, then the * access should be processed */ return 0; }

int dazuko_exit (  void   )  [inline]

Definition at line 3458 of file dazuko_core.c. { 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 (  const char *  filename  )  [inline]

Definition at line 1990 of file dazuko_core.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. { 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 (  const char *  request_buffer, struct xp_daemon_id *  xp_id )

Definition at line 2711 of file dazuko_core.c. References dazuko_request::buffer, dazuko_request::buffer_size, call_xp_copyin(), call_xp_copyout(), call_xp_free(), call_xp_malloc(), dazuko_bzero(), dazuko_get_value(), dazuko_handle_request(), dazuko_reqstream_chunksize(), dazuko_reqstream_ll2hl(), dazuko_reqstream_updll(), dazuko_strtoul(), NULL, dazuko_request::reply_buffer, dazuko_request::reply_buffer_size, dazuko_request::reply_buffer_size_used, dazuko_request::type, XP_ERROR_FAULT, XP_ERROR_PERMISSION, and xp_free(). { int error = 0; struct dazuko_request *user_request = NULL; unsigned char *ll_request = NULL; unsigned char *ll_stream = NULL; struct dazuko_request *request = NULL; struct dazuko_request *temp_request = NULL; char *value; unsigned char tempslen[4]; int streamlen = 0; /* * some notes on the variables: we allocate a "request" struct which * has a kernel space address and references data which is _completely_ * valid from within the kernel, in addition we allocate a * "temp_request" struct which has a kernel space address and its data * mirrors the userland struct "user_request", the "ll_stream" byte * array has a kernel space address and holds a copy of the user space * request stream */ if (request_buffer == NULL || xp_id == NULL) return XP_ERROR_FAULT; if (dazuko_get_value("\nra=", request_buffer, &value) == 0) { ll_request = (unsigned char *)dazuko_strtoul(value); xp_free(value); } else if (dazuko_get_value("\nRA=", request_buffer, &value) == 0) { user_request = (struct dazuko_request *)dazuko_strtoul(value); xp_free(value); } /* * at least one kind of request presentation needs to be given (having * multiple kinds does not hurt -- we pick the most portable one and * process it) */ if (ll_request == NULL && user_request == NULL) return XP_ERROR_FAULT; /* allocate temp kernel request */ temp_request = (struct dazuko_request *)call_xp_malloc(sizeof(struct dazuko_request)); if (temp_request == NULL) return XP_ERROR_FAULT; /* allocate kernel request */ request = (struct dazuko_request *)call_xp_malloc(sizeof(struct dazuko_request)); if (request == NULL) { error = XP_ERROR_FAULT; goto dazuko_handle_user_request_out; } /* request bytes are zero'd out because the "out" will check * these values */ dazuko_bzero(request, sizeof(struct dazuko_request)); if (ll_request != NULL) { /* * this is the "new style ra= (streamed) request" -- we have a * description which is high level language independent: fill in *OUR* * C language struct with the data we read in in a portable way */ /* copy in the length bytes (4 bytes) */ if (call_xp_copyin(ll_request, tempslen, 4) != 0) { error = XP_ERROR_FAULT; goto dazuko_handle_user_request_out; } if (dazuko_reqstream_chunksize(tempslen, &streamlen) != 0) { error = XP_ERROR_FAULT; goto dazuko_handle_user_request_out; } /* allocate a buffer and copyin the stream */ ll_stream = (unsigned char *)call_xp_malloc(streamlen); if (ll_stream == NULL) { error = XP_ERROR_FAULT; goto dazuko_handle_user_request_out; } if (call_xp_copyin(ll_request, ll_stream, streamlen) != 0) { error = XP_ERROR_FAULT; goto dazuko_handle_user_request_out; } /* convert the stream to into a (our) struct */ if (dazuko_reqstream_ll2hl(ll_stream, temp_request, 0) != 0) { error = XP_ERROR_FAULT; goto dazuko_handle_user_request_out; } /* do NOT release the stream buffer here */ } else if (user_request != NULL) { /* * this is the "old style (high level language struct) request" -- we * HAVE TO ASSUME that the memory layout of the application and the * kernel module match regarding the "struct dazuko_request" data type * (yes, it's dangerous but we have no means to check anything here) */ /* 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_out; } } /* * at this point we have a valid request structure in "temp_request" * (still pointing to userland buffers for request and reply) */ memcpy(request->type, temp_request->type, sizeof(char[2])); /* sanity check */ request->buffer_size = temp_request->buffer_size; if (request->buffer_size < 0 || request->buffer_size > 8192) { error = XP_ERROR_FAULT; goto dazuko_handle_user_request_out; } /* sanity check */ request->reply_buffer_size = temp_request->reply_buffer_size; if (request->reply_buffer_size < 0 || request->reply_buffer_size > 8192) { error = XP_ERROR_PERMISSION; goto dazuko_handle_user_request_out; } if (request->buffer_size > 0) { /* allocate request command string buffer */ request->buffer = (char *)call_xp_malloc(request->buffer_size + 1); if (request->buffer == NULL) { error = XP_ERROR_FAULT; goto dazuko_handle_user_request_out; } } if (request->reply_buffer_size > 0) { /* allocate reply text 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_out; } request->reply_buffer_size_used = 0; } if (request->buffer_size > 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_out; } request->buffer[request->buffer_size] = 0; } /* process the request */ error = dazuko_handle_request(request, xp_id); /* successfully processed and a response to be transferred back? */ 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 (ll_request != NULL) { /* new style (streamed) request */ /* update a few return fields */ if (dazuko_reqstream_updll(temp_request, ll_stream) != 0) { error = XP_ERROR_FAULT; goto dazuko_handle_user_request_out; } /* copyout the stream back to the application */ if (call_xp_copyout(ll_stream, ll_request, streamlen) != 0) { error = XP_ERROR_FAULT; goto dazuko_handle_user_request_out; } } else if (user_request != NULL) { /* old style (high level language struct) request */ /* copyout the complete "struct dazuko_request" struct */ if (call_xp_copyout(temp_request, user_request, sizeof(struct dazuko_request)) != 0) { error = XP_ERROR_FAULT; goto dazuko_handle_user_request_out; } } /* transfer back the reply data itself */ if (request->reply_buffer_size_used > 0) { /* reply_buffer_size_used already includes the NUL byte */ 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_out; } } } dazuko_handle_user_request_out: if (request != NULL) { if (request->buffer != NULL) call_xp_free(request->buffer); if (request->reply_buffer != NULL) call_xp_free(request->reply_buffer); call_xp_free(request); } if (temp_request != NULL) call_xp_free(temp_request); if (ll_stream != NULL) call_xp_free(ll_stream); return error; }

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

Definition at line 2967 of file dazuko_core.c. References slot_list::access_mask, call_xp_copyin(), call_xp_copyout(), call_xp_free(), call_xp_id_copy(), call_xp_id_free(), call_xp_malloc(), call_xp_notify(), call_xp_up(), call_xp_verify_user_readable(), call_xp_verify_user_writable(), DAZUKO_BROKEN, dazuko_change_slot_state(), DAZUKO_FILENAME_MAX_LENGTH_COMPAT1, dazuko_find_slot(), dazuko_find_slot_and_slotlist(), dazuko_get_an_access(), dazuko_register_daemon(), dazuko_return_access(), dazuko_set_option(), dazuko_setup_amc_cache(), DAZUKO_WORKING, access_compat1::deny, DPRINT, slot::event, access_compat1::event, slot::event_p, access_compat1::filename, slot::filename, slot::filenamelength, event_properties::flags, handle_event_as_readonly(), IOCTL_GET_AN_ACCESS, IOCTL_RETURN_ACCESS, IOCTL_SET_OPTION, event_properties::mode, slot::mutex, NULL, access_compat1::o_flags, access_compat1::o_mode, event_properties::pid, access_compat1::pid, REGISTER, SET_ACCESS_MASK, event_properties::uid, access_compat1::uid, daemon_id::unique, XP_ERROR_FAULT, XP_ERROR_INTERRUPT, XP_ERROR_INVALID, XP_ERROR_PERMISSION, and daemon_id::xp_id. { struct access_compat1 *user_request_1; struct access_compat1 *temp_request_1; struct slot_list *sl; 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_request_1 = (struct access_compat1 *)ptr; error = call_xp_verify_user_writable(user_request_1, sizeof(struct access_compat1)); 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_COMPAT1) { /* filename length overflow :( */ s->filename[DAZUKO_FILENAME_MAX_LENGTH_COMPAT1 - 1] = 0; temp_length = DAZUKO_FILENAME_MAX_LENGTH_COMPAT1; } else { temp_length = s->filenamelength + 1; } temp_request_1 = (struct access_compat1 *)call_xp_malloc(sizeof(struct access_compat1)); if (temp_request_1 == NULL) { error = XP_ERROR_FAULT; } else if (call_xp_copyin(user_request_1, temp_request_1, sizeof(struct access_compat1)) != 0) { error = XP_ERROR_FAULT; } if (error == 0) { temp_request_1->event = s->event; temp_request_1->o_flags = s->event_p.flags; temp_request_1->o_mode = s->event_p.mode; temp_request_1->uid = s->event_p.uid; temp_request_1->pid = s->event_p.pid; memcpy(temp_request_1->filename, s->filename, temp_length); if (call_xp_copyout(temp_request_1, user_request_1, sizeof(struct access_compat1)) != 0) { error = XP_ERROR_FAULT; } } call_xp_up(&(s->mutex)); /* UP */ if (error) { if (dazuko_change_slot_state(s, DAZUKO_WORKING, DAZUKO_BROKEN, 1)) { /* slot->state has changed to BROKEN, notifiy appropriate queue */ call_xp_notify(&(s->wait_kernel_waiting_until_this_slot_not_WAITING_and_not_WORKING)); } } if (temp_request_1 != NULL) { call_xp_free(temp_request_1); } 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_request_1 = (struct access_compat1 *)ptr; error = call_xp_verify_user_readable(user_request_1, sizeof(struct access_compat1)); if (error) { error = XP_ERROR_FAULT; break; } temp_request_1 = (struct access_compat1 *)call_xp_malloc(sizeof(struct access_compat1)); if (temp_request_1 == NULL) { error = XP_ERROR_FAULT; break; } if (call_xp_copyin(user_request_1, temp_request_1, sizeof(struct access_compat1)) != 0) { error = XP_ERROR_FAULT; } temp_int = temp_request_1->deny; call_xp_free(temp_request_1); /* find our slot */ s = dazuko_find_slot(&did, 1, NULL); if (s == NULL) { /* It appears the kernel isn't interested * in us or our response. It gave our slot away! */ DPRINT(("dazuko: daemon %d unexpectedly lost slot (by return access compat1)\n", did.unique)); error = XP_ERROR_FAULT; } else if (!handle_event_as_readonly(s)) { error = dazuko_return_access(&did, temp_int, s); } 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; switch (temp_int) { case REGISTER: error = dazuko_register_daemon(&did, k_param, temp_length, 1); break; case SET_ACCESS_MASK: /* find our slot */ if (dazuko_find_slot_and_slotlist(&did, 1, NULL, &sl) == NULL) { error = XP_ERROR_PERMISSION; } else if (sl == NULL) { error = XP_ERROR_PERMISSION; } else { sl->access_mask = k_param[0]; /* rebuild access_mask_cache */ dazuko_setup_amc_cache(); } break; default: error = dazuko_set_option(&did, temp_int, k_param, temp_length); break; } call_xp_free(k_param); break; default: error = XP_ERROR_INVALID; break; } call_xp_id_free(did.xp_id); return error; }

int dazuko_init (  void   )  [inline]

Definition at line 3432 of file dazuko_core.c. { 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, struct slot_list **  slotlist )  [inline]

Definition at line 3228 of file dazuko_core.c. References _dazuko_find_slot(), _remove_trusted_node(), call_xp_down(), call_xp_id_compare(), call_xp_id_copy(), call_xp_id_free(), call_xp_read_lock(), call_xp_read_unlock(), call_xp_up(), DAZUKO_CHILD, DAZUKO_SAME, DAZUKO_SUSPICIOUS, DPRINT, slot_list::lock_trusted_list, trusted_container::next, NULL, slot_list::set_trusted_list, slot_list_container::slot_list, trusted_container::trust_children, slot_list::trusted_list, daemon_id::unique, trusted_container::xp_id, and daemon_id::xp_id. { /* Check if the current process is one * of the daemons. */ int ret = 0; struct daemon_id did; struct slot *s; int i; struct slot_list *sl; #ifdef TRUSTED_APPLICATION_SUPPORT int cmp; struct trusted_container *tc; struct trusted_container *prev; #endif did.xp_id = call_xp_id_copy(xp_id); did.unique = -1; for (i=0 ; i<NUM_SLOT_LISTS ; i++) { /* DOWN */ call_xp_down(&(slot_lists[i].mutex)); sl = slot_lists[i].slot_list; call_xp_up(&(slot_lists[i].mutex)); /* UP */ if (sl == NULL) continue; s = _dazuko_find_slot(&did, 1, sl); if (s != NULL) { ret = 1; if (slotlist != NULL) *slotlist = sl; break; } if (did.xp_id == NULL) continue; #ifdef TRUSTED_APPLICATION_SUPPORT /* This boolean is not protected by a lock on purpose. * It is used as optimization when there are no trusted * processes. If it is set, then we will use the lock. */ if (!(sl->set_trusted_list)) continue; /* LOCK */ call_xp_read_lock(&(sl->lock_trusted_list)); tc = sl->trusted_list; prev = NULL; while (tc != NULL) { cmp = call_xp_id_compare(tc->xp_id, did.xp_id, 1); if (cmp == DAZUKO_SAME || (cmp == DAZUKO_CHILD && tc->trust_children)) { ret = 1; if (slotlist != NULL) *slotlist = sl; break; } else if (cmp == DAZUKO_SUSPICIOUS) { DPRINT(("dazuko: detected suspicios activity, removing trusted daemon [%d]\n", did.unique)); /* remove invalid trusted node */ tc = _remove_trusted_node(prev, tc, sl); break; } else { prev = tc; tc = tc->next; } } call_xp_read_unlock(&(sl->lock_trusted_list)); /* UNLOCK */ if (ret) break; #endif } call_xp_id_free(did.xp_id); return ret; }

int dazuko_process_access (  unsigned long  event, struct dazuko_file_struct *  kfs, struct event_properties *  event_p, struct slot_list *  cached_lookup )

Definition at line 3386 of file dazuko_core.c. References call_xp_print, dazuko_run_daemon(), NULL, XP_ERROR_INTERRUPT, and XP_ERROR_PERMISSION. Referenced by dazuko_sys_generic(), and linux_dazuko_sys_generic(). { /* return codes: * >0 -> access should be blocked * <0 -> access should be blocked (because user interrupted) * 0 -> access is allowed * 2 -> access is not taken care of (unscanned) */ int error = 0; if (kfs == NULL) { /* kfs is required */ call_xp_print("dazuko: kfs=NULL (possible bug)\n"); return XP_ERROR_PERMISSION; } /* check and handle this event */ error = dazuko_run_daemon(event, kfs, event_p, cached_lookup); if (error == 2) { /* access will be skipped */ return 2; } else if (error > 0) { /* access will be blocked */ return XP_ERROR_PERMISSION; } else if (error < 0) { /* user interrupted */ return XP_ERROR_INTERRUPT; } /* access allowed */ return 0; }

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

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

int dazuko_unregister_daemon (  struct xp_daemon_id *  xp_id  )

Definition at line 834 of file dazuko_core.c. { 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. { 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. { #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. { #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. { 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. { atomic_set(&(atomic->atomic), value); 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); }

void 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; }

void xp_destroy_rwlock (  struct xp_rwlock *  rwlock  )  [inline]

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

void xp_down (  struct xp_mutex *  mutex  )  [inline]

Definition at line 147 of file daz_main.c. { 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. { 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, int  check_related )  [inline]

Definition at line 934 of file dazuko_linux.c. { if (id1 == NULL || id2 == NULL) return DAZUKO_DIFFERENT; /* if file's are available and they match, * then we say that the id's match * ("file" is only used to unregister daemons and * here we allow other processes to do this) * Note: this is a Linux-only "hack" */ if (id1->file != NULL && id1->file == id2->file) return DAZUKO_SAME; if (id1->pid == id2->pid && id1->current_p == id2->current_p && id1->files == id2->files) return DAZUKO_SAME; if (check_related) { if (check_parent(id1->current_p, id2->current_p) == 0) { return DAZUKO_CHILD; } else if (id1->pid == id2->pid || id1->current_p == id2->current_p || id1->files == id2->files) { return DAZUKO_SUSPICIOUS; } } return DAZUKO_DIFFERENT; }

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

Definition at line 442 of file daz_main.c. { 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. { xp_free(id); return 0; }

int xp_init_cache (  unsigned long  ttl  )

Definition at line 1006 of file dazuko_linux.c. { return -1; }

void xp_init_mutex (  struct xp_mutex *  mutex  )  [inline]

Definition at line 136 of file daz_main.c. { #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. { init_waitqueue_head(&(queue->queue)); return 0; }

void xp_init_rwlock (  struct xp_rwlock *  rwlock  )  [inline]

Definition at line 167 of file daz_main.c. { 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. { return rsbac_kmalloc(size); }

int xp_notify (  struct xp_queue *  queue  )  [inline]

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

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

Definition at line 522 of file daz_main.c. { 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; }

void xp_read_lock (  struct xp_rwlock *  rlock  )  [inline]

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

void xp_read_unlock (  struct xp_rwlock *  rlock  )  [inline]

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

int xp_set_event_properties (  struct event_properties *  event_p, struct xp_daemon_id *  xp_id )

Definition at line 995 of file dazuko_linux.c. References xp_daemon_id::pid. { event_p->pid = xp_id->pid; event_p->set_pid = 1; return 0; }

int xp_sys_hook (  void   )  [inline]

Definition at line 463 of file daz_main.c. { /* 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. { /* 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; }

void xp_up (  struct xp_mutex *  mutex  )  [inline]

Definition at line 153 of file daz_main.c. { 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. { /* 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; }

void xp_write_lock (  struct xp_rwlock *  rwlock  )  [inline]

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

void xp_write_unlock (  struct xp_rwlock *  rwlock  )  [inline]

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

---