dazuko_xp.c File Reference

#include "dazuko_platform.h"
#include "dazuko_xp.h"
#include "dazukoio.h"
#include "dazuko_call.h"

Go to the source code of this file.

Data Structures
struct	path
struct	daemon_id
struct	slot
struct	slot_list
struct	slot_list_container
struct	one_slot_state_not_condition_param
struct	two_slot_state_not_condition_param
struct	get_ready_slot_condition_param
Defines
#define	NUM_SLOT_LISTS   5
#define	NUM_SLOTS   25
#define	SCAN_ON_OPEN   (access_mask & DAZUKO_ON_OPEN)
#define	SCAN_ON_CLOSE   (access_mask & DAZUKO_ON_CLOSE)
#define	SCAN_ON_EXEC   (access_mask & DAZUKO_ON_EXEC)
#define	SCAN_ON_CLOSE_MODIFIED   (access_mask & DAZUKO_ON_CLOSE_MODIFIED)
#define	DAZUKO_VSNPRINTF_PRINTSTRING
#define	DAZUKO_VSNPRINT(type, name)   dazuko_snprintf(request->reply_buffer + request->reply_buffer_size_used, (request->reply_buffer_size - request->reply_buffer_size_used) - 1, "%s%" #type , key, *((name *)value))
Functions
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,...)
void	dazuko_bzero (void *p, int len)
static int	dazuko_get_new_unique (void)
static int	dazuko_slot_state (struct slot *s)
static int	one_slot_state_not_condition (void *param)
static int	two_slot_state_not_condition (void *param)
static int	__dazuko_change_slot_state (struct slot *s, int from_state, int to_state)
static int	dazuko_change_slot_state (struct slot *s, int from_state, int to_state, int release)
static struct slot *	_dazuko_find_slot (struct daemon_id *did, int release, struct slot_list *sl)
static struct slot *	dazuko_find_slot_and_slotlist (struct daemon_id *did, int release, struct slot_list *slist, struct slot_list **sl_result)
static struct slot *	dazuko_find_slot (struct daemon_id *did, int release, struct slot_list *slist)
static int	dazuko_insert_path_fs (struct path **list, char *fs_path, int fs_len)
static void	dazuko_remove_all_hash (void)
static void	dazuko_remove_all_paths (void)
static int	_dazuko_unregister_daemon (struct daemon_id *did)
int	dazuko_unregister_daemon (struct xp_daemon_id *xp_id)
static int	dazuko_state_error (struct slot *s, int current_state)
static int	dazuko_register_daemon (struct daemon_id *did, const char *reg_name, int string_length, int write_mode)
static struct slot *	dazuko_get_an_access (struct daemon_id *did)
static int	dazuko_return_access (struct daemon_id *did, int response, struct slot *s)
static int	dazuko_isdigit (const char c)
static long	dazuko_strtol (const char *string)
static int	dazuko_strlen (const char *string)
static const char *	dazuko_strchr (const char *haystack, char needle)
static const char *	dazuko_strstr (const char *haystack, const char *needle)
int	dazuko_get_value (const char *key, const char *string, char **value)
static void	dazuko_clear_replybuffer (struct dazuko_request *request)
static void	dazuko_close_replybuffer (struct dazuko_request *request)
static void	dazuko_add_keyvalue_to_replybuffer (struct dazuko_request *request, const char *key, void *value, char vtype)
static int	dazuko_printable (char c)
static void	dazuko_add_esc_to_replybuffer (struct dazuko_request *request, const char *key, char **filename)
static int	dazuko_set_option (struct daemon_id *did, int opt, void *param, int len)
static int	dazuko_handle_request (struct dazuko_request *request, 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)
static struct slot *	dazuko_get_and_hold_ready_slot (struct slot_list *sl)
static int	get_ready_slot_condition (void *param)
static int	dazuko_run_daemon_on_slotlist (int event, char *filename, int filenamelength, struct event_properties *event_p, struct file_properties *file_p, int prev_response, struct slot_list *sl)
static int	dazuko_run_daemon (int event, char *filename, int filenamelength, struct event_properties *event_p, struct file_properties *file_p)
int	dazuko_is_our_daemon (struct xp_daemon_id *xp_id)
static int	dazuko_is_selected (struct dazuko_file_struct *kfs)
static int	dazuko_add_hash (struct xp_file *file, char *filename, int len)
static void	dazuko_mark_hash_dirty (struct xp_file *file)
static struct hash *	dazuko_get_hash (struct xp_file *file)
int	dazuko_get_filename_length (char *filename)
static int	dazuko_should_scan (struct dazuko_file_struct *kfs)
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)
Variables
static int	unique_count = 1
static char	access_mask = 7
static struct slot_list_container	slot_lists [NUM_SLOT_LISTS]
static struct path *	incl_paths = NULL
static struct path *	excl_paths = NULL
static struct hash *	hash = NULL
static struct xp_rwlock	lock_hash
static struct xp_rwlock	lock_lists
static struct xp_atomic	active
static struct xp_mutex	mutex_unique_count
static struct xp_queue	wait_kernel_waiting_for_free_slot
static struct xp_queue	wait_daemon_waiting_for_work
static struct xp_queue	wait_kernel_waiting_while_daemon_works
static struct xp_queue	wait_daemon_waiting_for_free

---

Define Documentation

#define DAZUKO_VSNPRINT (  type, name   )     dazuko_snprintf(request->reply_buffer + request->reply_buffer_size_used, (request->reply_buffer_size - request->reply_buffer_size_used) - 1, "%s%" #type , key, *((name *)value))

#define DAZUKO_VSNPRINTF_PRINTSTRING

Value: for ( ; *s ; s++) \ { \ if (target == end) \ { \ overflow = 1; \ goto dazuko_vsnprintf_out; \ } \ *target = *s; \ target++; \ }

#define NUM_SLOT_LISTS   5

Definition at line 42 of file dazuko_xp.c.

#define NUM_SLOTS   25

Definition at line 43 of file dazuko_xp.c.

#define SCAN_ON_CLOSE   (access_mask & DAZUKO_ON_CLOSE)

Definition at line 46 of file dazuko_xp.c. Referenced by dazuko_sys_check(), and dazuko_sys_post().

#define SCAN_ON_CLOSE_MODIFIED   (access_mask & DAZUKO_ON_CLOSE_MODIFIED)

Definition at line 48 of file dazuko_xp.c. Referenced by dazuko_sys_check(), and dazuko_sys_post().

#define SCAN_ON_EXEC   (access_mask & DAZUKO_ON_EXEC)

Definition at line 47 of file dazuko_xp.c.

#define SCAN_ON_OPEN   (access_mask & DAZUKO_ON_OPEN)

Definition at line 45 of file dazuko_xp.c. Referenced by dazuko_sys_check(), dazuko_sys_post(), and dazuko_sys_pre().

---

Function Documentation

static int __dazuko_change_slot_state (  struct slot *  s, int  from_state, int  to_state )  [inline, static]

Definition at line 329 of file dazuko_xp.c. References call_xp_notify(), DAZUKO_FREE, and DAZUKO_READY. { /* Make a predicted state transition. We fail if it * is an unpredicted change. We can ALWAYS go to the * to_state if it is the same as from_state. Not SMP safe! */ if (to_state != from_state) { /* make sure this is a predicted transition and there * is a daemon on this slot (unique != 0)*/ if (s->state != from_state || s->did.unique == 0) return 0; } s->state = to_state; /* handle appropriate wake_up's for basic * state changes */ if (to_state == DAZUKO_READY) { call_xp_notify(&wait_kernel_waiting_for_free_slot); } else if (to_state == DAZUKO_FREE) { call_xp_notify(&wait_kernel_waiting_while_daemon_works); call_xp_notify(&wait_daemon_waiting_for_free); } return 1; }

static struct slot* _dazuko_find_slot (  struct daemon_id *  did, int  release, struct slot_list *  sl )  [static]

Definition at line 387 of file dazuko_xp.c. References call_xp_down(), call_xp_id_compare(), call_xp_print, call_xp_up(), slot::did, slot::mutex, NULL, NUM_SLOTS, slot_list::slots, daemon_id::unique, and daemon_id::xp_id. { /* Find the first slot with the same given * pid number. SMP safe. Use this function * with CAUTION, since the mutex may or may not * be released depending on the return value AND * on the value of the "release" argument. */ int i; struct slot *s = NULL; if (sl == NULL) { call_xp_print("dazuko: invalid slot_list given (bug!)\n"); return NULL; } for (i=0 ; i<NUM_SLOTS ; i++) { s = &(sl->slots[i]); /* DOWN */ /* if we are interrupted, we say that no * slot was found */ if (call_xp_down(&(s->mutex)) != 0) return NULL; if (did == NULL) { /* we are looking for an empty slot */ if (s->did.unique == 0 && s->did.xp_id == NULL) { /* we release the mutex only if the * called wanted us to */ if (release) call_xp_up(&(s->mutex)); /* UP */ return s; } } else if (s->did.unique == 0 && s->did.xp_id == NULL) { /* this slot is emtpy, so it can't match */ /* do nothing */ } /* xp_id's must match! */ else if (call_xp_id_compare(s->did.xp_id, did->xp_id) == 0) { /* unique's must also match (unless unique is negative, * in which case we will trust xp_id) */ if (did->unique < 0 || (s->did.unique == did->unique)) { /* we release the mutex only if the * called wanted us to */ if (release) call_xp_up(&(s->mutex)); /* UP */ return s; } } call_xp_up(&(s->mutex)); /* UP */ } return NULL; }

static int _dazuko_unregister_daemon (  struct daemon_id *  did  )  [static]

Definition at line 632 of file dazuko_xp.c. References __dazuko_change_slot_state(), call_xp_atomic_dec(), call_xp_atomic_read(), call_xp_id_free(), call_xp_notify(), call_xp_print, call_xp_up(), dazuko_find_slot_and_slotlist(), DAZUKO_FREE, dazuko_remove_all_hash(), dazuko_remove_all_paths(), slot::did, DPRINT, slot::mutex, NULL, daemon_id::unique, slot_list::use_count, and daemon_id::xp_id. { /* We unregister the daemon by finding the * slot with the same slot->pid as the the * current process id, the daemon. */ struct slot *s; struct slot_list *sl; DPRINT(("dazuko: dazuko_unregister_daemon() [%d]\n", did->unique)); /* find our slot and hold the mutex * if we find it */ /* DOWN? */ s = dazuko_find_slot_and_slotlist(did, 0, NULL, &sl); if (s == NULL) { /* this daemon was not registered */ return 0; } /* DOWN */ /* clearing the unique and pid makes the slot available */ s->did.unique = 0; call_xp_id_free(s->did.xp_id); s->did.xp_id = NULL; /* reset slot state */ __dazuko_change_slot_state(s, DAZUKO_FREE, DAZUKO_FREE); call_xp_atomic_dec(&(sl->use_count)); call_xp_up(&(s->mutex)); /* UP */ /* active should always be positive here, but * let's check just to be sure. ;) */ if (call_xp_atomic_read(&active) > 0) { /* active and the kernel usage counter * should always reflect how many daemons * are active */ call_xp_atomic_dec(&active); } else { call_xp_print("dazuko: active count error (possible bug)\n"); } /* Wake up any kernel processes that are * waiting for an available slot. Remove * all the include and exclude paths * if there are no more daemons */ if (call_xp_atomic_read(&active) == 0) { /* clear out include and exclude paths */ /* are we sure we want to do this? */ dazuko_remove_all_paths(); /* clear out hash nodes */ dazuko_remove_all_hash(); } call_xp_notify(&wait_kernel_waiting_for_free_slot); call_xp_notify(&wait_kernel_waiting_while_daemon_works); return 0; }

static void dazuko_add_esc_to_replybuffer (  struct dazuko_request *  request, const char *  key, char **  filename )  [inline, static]

Definition at line 1223 of file dazuko_xp.c. References dazuko_add_keyvalue_to_replybuffer(), dazuko_printable(), dazuko_snprintf(), dazuko_request::reply_buffer, dazuko_request::reply_buffer_size, and dazuko_request::reply_buffer_size_used. { int found = 0; char *p_rq; const char *limit; const char *p_fn; unsigned char c; /* check for escape characters in filename */ for (p_fn=*filename ; *p_fn ; p_fn++) { if (!dazuko_printable(*p_fn)) { found = 1; break; } } if (found) { /* this is expensive, but it will also almost never occur */ p_rq = request->reply_buffer + request->reply_buffer_size_used; limit = request->reply_buffer + request->reply_buffer_size - 1; dazuko_snprintf(p_rq, limit - p_rq, "%s", key); p_rq += strlen(p_rq); for (p_fn=*filename ; *p_fn && (p_rq<limit) ; p_fn++) { if (dazuko_printable(*p_fn)) { *p_rq = *p_fn; p_rq++; } else { c = *p_fn & 0xFF; dazuko_snprintf(p_rq, limit - p_rq, "\\x%02x", c); p_rq += strlen(p_rq); } } request->reply_buffer_size_used += strlen(request->reply_buffer + request->reply_buffer_size_used); } else { /* no escape characters found */ dazuko_add_keyvalue_to_replybuffer(request, key, filename, 's'); } }

static int dazuko_add_hash (  struct xp_file *  file, char *  filename, int  len )  [static]

Definition at line 2341 of file dazuko_xp.c. References call_xp_copy_file(), call_xp_malloc(), call_xp_write_lock(), call_xp_write_unlock(), hash::dirty, hash::file, hash::name, hash::namelen, hash::next, NULL, and XP_ERROR_FAULT. Referenced by dazuko_sys_post(). { /* Add the given file and filename to the linked list * of files to scan once they are closed. */ struct hash *h; /* create a new struct hash structure making room for name also */ h = (struct hash *)call_xp_malloc(sizeof(struct hash) + len); if (h == NULL) return XP_ERROR_FAULT; /* fill in structure items */ call_xp_copy_file(&(h->file), file); h->dirty = 0; h->namelen = len; memcpy(h->name, filename, len); h->name[len] = 0; /* add the new struct hash item to the head of the * struct hash linked list */ /* LOCK */ call_xp_write_lock(&lock_hash); h->next = hash; hash = h; call_xp_write_unlock(&lock_hash); /* UNLOCK */ return 0; }

static void dazuko_add_keyvalue_to_replybuffer (  struct dazuko_request *  request, const char *  key, void *  value, char  vtype )  [inline, static]

Definition at line 1187 of file dazuko_xp.c. References DAZUKO_VSNPRINT, dazuko_request::reply_buffer, and dazuko_request::reply_buffer_size_used. { #define DAZUKO_VSNPRINT(type, name) dazuko_snprintf(request->reply_buffer + request->reply_buffer_size_used, (request->reply_buffer_size - request->reply_buffer_size_used) - 1, "%s%" #type , key, *((name *)value)) switch (vtype) { case 'd': DAZUKO_VSNPRINT(d, const int); break; case 's': DAZUKO_VSNPRINT(s, const char *); break; case 'l': DAZUKO_VSNPRINT(lu, const unsigned long); break; default: /* all other types treated as chars */ DAZUKO_VSNPRINT(c, const char); break; } /* update how much buffer we have used */ request->reply_buffer_size_used += strlen(request->reply_buffer + request->reply_buffer_size_used); }

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

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

static int dazuko_change_slot_state (  struct slot *  s, int  from_state, int  to_state, int  release )  [static]

Definition at line 361 of file dazuko_xp.c. References __dazuko_change_slot_state(), call_xp_down(), call_xp_up(), and slot::mutex. { /* SMP safe version of __dazuko_change_slot_state(). * This should only be used if we haven't * already aquired slot.mutex. Use this function * with CAUTION, since the mutex may or may not * be released depending on the return value AND * on the value of the "release" argument. */ int success; /* if we are interrupted, report the state as unpredicted */ /* DOWN */ if (call_xp_down(&(s->mutex)) != 0) return 0; success = __dazuko_change_slot_state(s, from_state, to_state); /* the mutex is released if the state change was * unpredicted or if the called wants it released */ if (!success || release) call_xp_up(&(s->mutex)); /* UP */ return success; }

static void dazuko_clear_replybuffer (  struct dazuko_request *  request  )  [inline, static]

Definition at line 1175 of file dazuko_xp.c. References dazuko_bzero(), dazuko_request::reply_buffer, dazuko_request::reply_buffer_size, and dazuko_request::reply_buffer_size_used. { dazuko_bzero(request->reply_buffer, request->reply_buffer_size); request->reply_buffer_size_used = 0; }

static void dazuko_close_replybuffer (  struct dazuko_request *  request  )  [inline, static]

Definition at line 1181 of file dazuko_xp.c. References dazuko_request::reply_buffer, and dazuko_request::reply_buffer_size_used. { request->reply_buffer[request->reply_buffer_size_used] = 0; request->reply_buffer_size_used++; }

int dazuko_exit (  void   )  [inline]

Definition at line 2838 of file dazuko_xp.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; } dazuko_remove_all_paths(); dazuko_remove_all_hash(); error = call_xp_sys_unhook(); if (error == 0) { call_xp_destroy_mutex(&mutex_unique_count); call_xp_destroy_rwlock(&lock_hash); call_xp_destroy_rwlock(&lock_lists); call_xp_destroy_queue(&wait_kernel_waiting_for_free_slot); call_xp_destroy_queue(&wait_daemon_waiting_for_work); call_xp_destroy_queue(&wait_kernel_waiting_while_daemon_works); call_xp_destroy_queue(&wait_daemon_waiting_for_free); for (i=0 ; i<NUM_SLOT_LISTS ; i++) { if (slot_lists[i].slot_list != NULL) { 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_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); } return error; }

static struct slot* dazuko_find_slot (  struct daemon_id *  did, int  release, struct slot_list *  slist )  [inline, static]

Definition at line 498 of file dazuko_xp.c. References dazuko_find_slot_and_slotlist(), and NULL. { return dazuko_find_slot_and_slotlist(did, release, slist, NULL); }

static struct slot* dazuko_find_slot_and_slotlist (  struct daemon_id *  did, int  release, struct slot_list *  slist, struct slot_list **  sl_result )  [static]

Definition at line 455 of file dazuko_xp.c. References _dazuko_find_slot(), call_xp_down(), call_xp_up(), NULL, and slot_list_container::slot_list. { struct slot *s; int i; struct slot_list *sl; if (slist == NULL) { for (i=0 ; i<NUM_SLOT_LISTS ; i++) { /* DOWN */ /* if we are interrupted, we say that no * slot was found */ if (call_xp_down(&(slot_lists[i].mutex)) != 0) return NULL; sl = slot_lists[i].slot_list; call_xp_up(&(slot_lists[i].mutex)); /* UP */ if (sl != NULL) { s = _dazuko_find_slot(did, release, sl); if (s != NULL) { /* set the current slot_list */ if (sl_result != NULL) *sl_result = sl; return s; } } } } else { return _dazuko_find_slot(did, release, slist); } return NULL; }

static struct slot* dazuko_get_an_access (  struct daemon_id *  did  )  [static]

Definition at line 894 of file dazuko_xp.c. References call_xp_notify(), call_xp_print, call_xp_wait_until_condition(), DAZUKO_BROKEN, dazuko_change_slot_state(), dazuko_find_slot(), DAZUKO_READY, dazuko_register_daemon(), DAZUKO_WAITING, DAZUKO_WORKING, DPRINT, NULL, one_slot_state_not_condition(), one_slot_state_not_condition_param::slot, one_slot_state_not_condition_param::state, and daemon_id::unique. { /* 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) */ /* If a slot is returned, it will be already locked! */ int i; struct slot *s; struct one_slot_state_not_condition_param cond_p; tryagain: /* find our slot */ s = dazuko_find_slot(did, 1, NULL); if (s == NULL) { i = dazuko_register_daemon(did, "_COMPAT", 7, 1); if (i != 0) { call_xp_print("dazuko: unregistered daemon %d attempted to get access\n", did->unique); return NULL; } s = dazuko_find_slot(did, 1, NULL); if (s == NULL) { call_xp_print("dazuko: unregistered daemon %d attempted to get access\n", did->unique); return NULL; } call_xp_print("dazuko: warning: daemon %d is using a deprecated protocol\n", did->unique); } /* the daemon is now ready to receive a file */ dazuko_change_slot_state(s, DAZUKO_READY, DAZUKO_READY, 1); cond_p.slot = s; cond_p.state = DAZUKO_READY; if (call_xp_wait_until_condition(&wait_daemon_waiting_for_work, one_slot_state_not_condition, &cond_p, 1) != 0) { /* The user has issued an interrupt. * Return an error. The daemon should * unregister itself. */ DPRINT(("dazuko: daemon %d killed while waiting for work\n", did->unique)); if (dazuko_change_slot_state(s, DAZUKO_READY, DAZUKO_BROKEN, 1) || dazuko_change_slot_state(s, DAZUKO_WAITING, DAZUKO_BROKEN, 1)) { call_xp_notify(&wait_kernel_waiting_for_free_slot); call_xp_notify(&wait_kernel_waiting_while_daemon_works); } return NULL; } /* slot SHOULD now be in DAZUKO_WAITING state */ /* we will be working with the slot, so * we need to lock it */ /* DOWN? */ if (!dazuko_change_slot_state(s, DAZUKO_WAITING, DAZUKO_WORKING, 0)) { /* State transition error. Try again., */ goto tryagain; } /* DOWN */ /* Slot IS in DAZUKO_WORKING state. Copy all the * necessary information to userspace structure. */ /* IMPORTANT: slot is still locked! */ return s; /* access is available */ }

static struct slot* dazuko_get_and_hold_ready_slot (  struct slot_list *  sl  )  [static]

Definition at line 1991 of file dazuko_xp.c. References dazuko_change_slot_state(), DAZUKO_READY, DAZUKO_WAITING, NULL, NUM_SLOTS, and slot_list::slots. { /* This is a simple search to find a * slot whose state is DAZUKO_READY. This means * it is able to accept work. If a slot * is found, the slot.mutex is held so * it can be filled with work by the caller. * It is the responsibility of the caller * to RELEASE THE MUTEX. */ int i; struct slot *s; for (i=0 ; i<NUM_SLOTS ; i++) { s = &(sl->slots[i]); /* DOWN? */ if (dazuko_change_slot_state(s, DAZUKO_READY, DAZUKO_WAITING, 0)) { /* DOWN */ return s; } } /* we didn't find a slot that is ready for work */ return NULL; }

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

static struct hash* dazuko_get_hash (  struct xp_file *  file  )  [static]

Definition at line 2461 of file dazuko_xp.c. References call_xp_compare_file(), call_xp_write_lock(), call_xp_write_unlock(), hash::file, hash::next, and NULL. Referenced by dazuko_sys_post(). { /* Find the given file within our list * and then remove it from the list and * return it. */ struct hash *prev; struct hash *cur; /* LOCK */ call_xp_write_lock(&lock_hash); prev = NULL; cur = hash; while (cur) { if (call_xp_compare_file(&(cur->file), file) == 0) { /* we found the entry */ /* remove the item from the list */ if (!prev) hash = cur->next; else prev->next = cur->next; break; } prev = cur; cur = cur->next; } call_xp_write_unlock(&lock_hash); /* UNLOCK */ return cur; }

static int dazuko_get_new_unique (  void   )  [inline, static]

Definition at line 283 of file dazuko_xp.c. References call_xp_down(), call_xp_up(), and unique_count. { int unique; /* DOWN */ call_xp_down(&mutex_unique_count); unique = unique_count; unique_count++; call_xp_up(&mutex_unique_count); /* UP */ return unique; }

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

Definition at line 1141 of file dazuko_xp.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; }

static int dazuko_handle_request (  struct dazuko_request *  request, struct xp_daemon_id *  xp_id )  [static]

Definition at line 1368 of file dazuko_xp.c. References access_mask, ADD_EXCLUDE_PATH, ADD_INCLUDE_PATH, dazuko_request::buffer, dazuko_request::buffer_size, call_xp_free(), call_xp_id_copy(), call_xp_id_free(), call_xp_print, call_xp_up(), dazuko_add_esc_to_replybuffer(), dazuko_add_keyvalue_to_replybuffer(), dazuko_clear_replybuffer(), dazuko_close_replybuffer(), dazuko_get_an_access(), dazuko_get_value(), dazuko_register_daemon(), dazuko_return_access(), dazuko_set_option(), dazuko_strchr(), dazuko_strlen(), dazuko_strtol(), file_properties::device_type, slot::event, slot::event_p, slot::file_p, slot::filename, event_properties::flags, GET_AN_ACCESS, file_properties::gid, file_properties::mode, event_properties::mode, slot::mutex, NULL, event_properties::pid, REGISTER, REMOVE_ALL_PATHS, dazuko_request::reply_buffer_size, RETURN_AN_ACCESS, SET_ACCESS_MASK, file_properties::set_device_type, event_properties::set_flags, file_properties::set_gid, file_properties::set_mode, event_properties::set_mode, event_properties::set_pid, file_properties::set_size, file_properties::set_uid, event_properties::set_uid, file_properties::size, dazuko_request::type, file_properties::uid, event_properties::uid, daemon_id::unique, UNREGISTER, slot::write_mode, XP_ERROR_INTERRUPT, and daemon_id::xp_id. { char *value1; char *value2; int error = 0; int type; struct slot *s; struct daemon_id did; if (request == NULL || xp_id == NULL) return -1; type = request->type[0] + (256 * request->type[1]); switch (type) { case REGISTER: /* read "\nRM=regmode\nGN=group" */ /* send "\nID=id" */ if (request->buffer_size <= 0) return -1; if (request->reply_buffer_size <= 0) return -1; if (dazuko_get_value("\nGN=", request->buffer, &value1) != 0) return -1; if (dazuko_get_value("\nRM=", request->buffer, &value2) != 0) { call_xp_free(value1); return -1; } did.xp_id = call_xp_id_copy(xp_id); did.unique = 0; /* a unique is not yet assigned */ error = dazuko_register_daemon(&did, value1, dazuko_strlen(value1), dazuko_strchr(value2, 'W') != NULL); dazuko_clear_replybuffer(request); dazuko_add_keyvalue_to_replybuffer(request, "\nID=", &(did.unique), 'd'); dazuko_close_replybuffer(request); call_xp_free(value1); call_xp_free(value2); call_xp_id_free(did.xp_id); break; case UNREGISTER: /* read "\nID=id" */ if (request->buffer_size <= 0) return -1; if (dazuko_get_value("\nID=", request->buffer, &value1) != 0) return -1; did.xp_id = call_xp_id_copy(xp_id); did.unique = dazuko_strtol(value1); error = dazuko_set_option(&did, UNREGISTER, NULL, 0); call_xp_free(value1); call_xp_id_free(did.xp_id); break; case SET_ACCESS_MASK: /* read "\nID=id\nAM=mask" */ if (request->buffer_size <= 0) return -1; if (dazuko_get_value("\nID=", request->buffer, &value1) != 0) return -1; if (dazuko_get_value("\nAM=", request->buffer, &value2) != 0) { call_xp_free(value1); return -1; } access_mask = (char)dazuko_strtol(value2); call_xp_free(value1); call_xp_free(value2); break; case ADD_INCLUDE_PATH: /* read "\nID=id\nPT=path" */ if (request->buffer_size <= 0) return -1; if (dazuko_get_value("\nID=", request->buffer, &value1) != 0) return -1; if (dazuko_get_value("\nPT=", request->buffer, &value2) != 0) { call_xp_free(value1); return -1; } did.xp_id = call_xp_id_copy(xp_id); did.unique = dazuko_strtol(value1); error = dazuko_set_option(&did, ADD_INCLUDE_PATH, value2, dazuko_strlen(value2)); call_xp_free(value1); call_xp_free(value2); call_xp_id_free(did.xp_id); break; case ADD_EXCLUDE_PATH: /* read "\nID=id\nPT=path" */ if (request->buffer_size <= 0) return -1; if (dazuko_get_value("\nID=", request->buffer, &value1) != 0) return -1; if (dazuko_get_value("\nPT=", request->buffer, &value2) != 0) { call_xp_free(value1); return -1; } did.xp_id = call_xp_id_copy(xp_id); did.unique = dazuko_strtol(value1); error = dazuko_set_option(&did, ADD_EXCLUDE_PATH, value2, dazuko_strlen(value2)); call_xp_free(value1); call_xp_free(value2); call_xp_id_free(did.xp_id); break; case REMOVE_ALL_PATHS: /* read "\nID=id" */ if (request->buffer_size <= 0) return -1; if (dazuko_get_value("\nID=", request->buffer, &value1) != 0) return -1; did.xp_id = call_xp_id_copy(xp_id); did.unique = dazuko_strtol(value1); error = dazuko_set_option(&did, REMOVE_ALL_PATHS, NULL, 0); call_xp_free(value1); call_xp_id_free(did.xp_id); break; case GET_AN_ACCESS: /* read "\nID=id" */ /* send "\nFN=file\nFL=flags\nMD=mode\nUI=uid\nPI=pid" */ if (request->buffer_size <= 0) return -1; if (request->reply_buffer_size <= 0) return -1; if (dazuko_get_value("\nID=", request->buffer, &value1) != 0) return -1; did.xp_id = call_xp_id_copy(xp_id); did.unique = dazuko_strtol(value1); call_xp_free(value1); /* DOWN? */ s = dazuko_get_an_access(&did); if (s == NULL) { call_xp_id_free(did.xp_id); return XP_ERROR_INTERRUPT; } /* DOWN */ /* Slot IS in DAZUKO_WORKING state. Copy all the * necessary information to userspace structure. */ dazuko_clear_replybuffer(request); dazuko_add_keyvalue_to_replybuffer(request, "\nEV=", &(s->event), 'd'); dazuko_add_esc_to_replybuffer(request, "\nFN=", &(s->filename)); if (s->event_p.set_uid) dazuko_add_keyvalue_to_replybuffer(request, "\nUI=", &(s->event_p.uid), 'd'); if (s->event_p.set_pid) dazuko_add_keyvalue_to_replybuffer(request, "\nPI=", &(s->event_p.pid), 'd'); if (s->event_p.set_flags) dazuko_add_keyvalue_to_replybuffer(request, "\nFL=", &(s->event_p.flags), 'd'); if (s->event_p.set_mode) dazuko_add_keyvalue_to_replybuffer(request, "\nMD=", &(s->event_p.mode), 'd'); if (s->file_p.set_size) dazuko_add_keyvalue_to_replybuffer(request, "\nFS=", &(s->file_p.size), 'l'); if (s->file_p.set_uid) dazuko_add_keyvalue_to_replybuffer(request, "\nFU=", &(s->file_p.uid), 'd'); if (s->file_p.set_gid) dazuko_add_keyvalue_to_replybuffer(request, "\nFG=", &(s->file_p.gid), 'd'); if (s->file_p.set_mode) dazuko_add_keyvalue_to_replybuffer(request, "\nFM=", &(s->file_p.mode), 'd'); if (s->file_p.set_device_type) dazuko_add_keyvalue_to_replybuffer(request, "\nDT=", &(s->file_p.device_type), 'd'); dazuko_close_replybuffer(request); /* XXX: What do we do if there is a problem copying back to userspace?! */ /* dazuko_state_error(s, DAZUKO_WORKING); */ /* are we in read_only mode? */ if (!(s->write_mode)) { /* the access is immediately (and at the kernel level) * returned */ call_xp_up(&(s->mutex)); /* UP */ dazuko_return_access(&did, 0, s); } else { call_xp_up(&(s->mutex)); /* UP */ } call_xp_id_free(did.xp_id); break; case RETURN_AN_ACCESS: /* read "\nID=id\nDN=deny" */ if (request->buffer_size <= 0) return -1; if (dazuko_get_value("\nID=", request->buffer, &value1) != 0) return -1; if (dazuko_get_value("\nDN=", request->buffer, &value2) != 0) { call_xp_free(value1); return -1; } did.xp_id = call_xp_id_copy(xp_id); did.unique = dazuko_strtol(value1); error = dazuko_return_access(&did, dazuko_strtol(value2), NULL); call_xp_free(value1); call_xp_free(value2); call_xp_id_free(did.xp_id); break; default: call_xp_print("dazuko: daemon made unknown request %d (possible bug)\n", type); break; } return error; }

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, access_compat12::event, slot::event, slot::event_p, slot::filename, access_compat12::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, access_compat12::pid, event_properties::pid, REGISTER, access_compat12::uid, event_properties::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 2808 of file dazuko_xp.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_rwlock(&lock_hash); call_xp_init_rwlock(&lock_lists); call_xp_init_queue(&wait_kernel_waiting_for_free_slot); call_xp_init_queue(&wait_daemon_waiting_for_work); call_xp_init_queue(&wait_kernel_waiting_while_daemon_works); call_xp_init_queue(&wait_daemon_waiting_for_free); dazuko_bzero(&slot_lists, sizeof(slot_lists)); for (i=0 ; i<NUM_SLOT_LISTS ; i++) call_xp_init_mutex(&(slot_lists[i].mutex)); call_xp_atomic_set(&active, 0); error = call_xp_sys_hook(); if (error == 0) call_xp_print("dazuko: loaded, version=%s\n", VERSION); return error; }

static int dazuko_insert_path_fs (  struct path **  list, char *  fs_path, int  fs_len )  [static]

Definition at line 503 of file dazuko_xp.c. References call_xp_free(), call_xp_is_absolute_path(), call_xp_malloc(), call_xp_write_lock(), call_xp_write_unlock(), DPRINT, path::len, path::next, NULL, path::path, XP_ERROR_FAULT, and XP_ERROR_INVALID. { /* Create a new struct path structure and insert it * into the linked list given (list argument). * The fs_len argument is to help speed things * up so we don't have to calculate the length * of fs_path. */ struct path *newitem; struct path *tmp; if (fs_path == NULL || fs_len < 1) return XP_ERROR_INVALID; /* we want only absolute paths */ if (!call_xp_is_absolute_path(fs_path)) return XP_ERROR_INVALID; /* create a new struct path structure making room for path also */ newitem = (struct path *)call_xp_malloc(sizeof(struct path) + fs_len); if (newitem == NULL) return XP_ERROR_FAULT; /* fs_path is already in kernelspace */ memcpy(newitem->path, fs_path, fs_len); newitem->path[fs_len] = 0; while (newitem->path[fs_len-1] == 0) { fs_len--; if (fs_len == 0) break; } if (fs_len < 1) { call_xp_free(newitem); return XP_ERROR_INVALID; } newitem->len = fs_len; /* check if this path already exists in the list */ for (tmp=*list ; tmp ; tmp=tmp->next) { if (newitem->len == tmp->len) { if (memcmp(newitem->path, tmp->path, tmp->len) == 0) { /* we already have this path */ call_xp_free(newitem); return 0; } } } DPRINT(("dazuko: adding %s %s\n", (list == &incl_paths) ? "incl" : "excl", newitem->path)); /* add struct path to head of linked list */ /* LOCK */ call_xp_write_lock(&lock_lists); newitem->next = *list; *list = newitem; call_xp_write_unlock(&lock_lists); /* UNLOCK */ return 0; }

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

static int dazuko_is_selected (  struct dazuko_file_struct *  kfs  )  [static]

Definition at line 2236 of file dazuko_xp.c. References dazuko_file_struct::aliases, call_xp_print, call_xp_read_lock(), call_xp_read_unlock(), dazuko_bzero(), dazuko_file_listnode::filename, dazuko_file_struct::filename, dazuko_file_struct::filename_length, dazuko_file_listnode::filename_length, path::len, path::next, dazuko_file_listnode::next, NULL, path::path, xp_free(), and xp_malloc(). { /* Check if the given filename (with path) is * under our include directories but not under * the exclude directories. */ struct dazuko_file_listnode *cur; struct path *path; int selected = 0; int use_aliases = 1; if (kfs == NULL) return 0; /* If we are interrupted here, we will report that * this file is not selected. This will make the * kernel allow normal access. Is this dangerous? */ /* LOCK */ call_xp_read_lock(&lock_lists); if (kfs->aliases == NULL && kfs->filename != NULL) { /* extension is not using aliases */ use_aliases = 0; kfs->aliases = (struct dazuko_file_listnode *)xp_malloc(sizeof(struct dazuko_file_listnode)); if (kfs->aliases == NULL) { call_xp_print("dazuko: warning: access not controlled (%s)\n", kfs->filename); return 0; } dazuko_bzero(kfs->aliases, sizeof(struct dazuko_file_listnode)); kfs->aliases->filename = kfs->filename; kfs->aliases->filename_length = kfs->filename_length; } for (cur=kfs->aliases ; cur ; cur=cur->next) { if (cur->filename != NULL && cur->filename_length > 0) { /* check if filename is under our include paths */ for (path=incl_paths ; path ; path=path->next) { /* the include item must be at least as long as the given filename */ if (path->len <= cur->filename_length) { /* the include item should match the beginning of the given filename */ if (memcmp(path->path, cur->filename, path->len) == 0) { kfs->filename = cur->filename; kfs->filename_length = cur->filename_length; selected = 1; break; } } } /* If we didn't find a path, it isn't in our * include directories. It can't be one of * the selected files to scan. */ if (!selected) { continue; } /* check if filename is under our exclude paths */ for (path=excl_paths ; path ; path=path->next) { /* the exclude item must be at least as long as the given filename */ if (path->len <= cur->filename_length) { /* the exclude item should match the beginning of the given filename */ if (memcmp(path->path, cur->filename, path->len) == 0) { kfs->filename = NULL; kfs->filename_length = 0; selected = 0; break; } } } /* If we are still selected, then we can stop. */ if (selected) break; } } call_xp_read_unlock(&lock_lists); /* UNLOCK */ if (!use_aliases) { xp_free(kfs->aliases); kfs->aliases = NULL; } return selected; }

static int dazuko_isdigit (  const char  c  )  [inline, static]

Definition at line 1043 of file dazuko_xp.c. { return (c >= '0' && c <= '9'); }

static void dazuko_mark_hash_dirty (  struct xp_file *  file  )  [static]

Definition at line 2374 of file dazuko_xp.c. References call_xp_compare_file(), call_xp_write_lock(), call_xp_write_unlock(), hash::dirty, hash::file, hash::next, and NULL. Referenced by dazuko_sys_post(). { struct hash *h = NULL; struct hash *entry = NULL; struct hash *prev = NULL; struct hash *prev_entry = NULL; /* LOCK */ call_xp_write_lock(&lock_hash); for (h=hash ; h ; h=h->next) { /* not found if hit first dirty entry */ if (h->dirty) { entry = NULL; break; } if (call_xp_compare_file(&(h->file), file) == 0) { /* we found the entry */ prev_entry = prev; entry = h; break; } prev = h; } if (entry) { if (!entry->dirty) { /* mark as dirty */ entry->dirty = 1; /* If we already are last entry or next * entry dirty, we don't need to move */ if (entry->next) { if (!entry->next->dirty) { for (h=entry->next ; h ; h=h->next) { if (h->dirty) break; prev = h; } /* remove from current position */ if (prev_entry) prev_entry->next = entry->next; else hash = entry->next; if (prev == NULL) { /* insert as first item */ entry->next = hash; hash = entry; } else if (h) { /* insert before h (after prev) */ entry->next = prev->next; prev->next = entry; } else { /* insert as last item (after prev) */ entry->next = NULL; prev->next = entry; } } } } } call_xp_write_unlock(&lock_hash); /* UNLOCK */ }

static int dazuko_printable (  char  c  )  [inline, static]

Definition at line 1216 of file dazuko_xp.c. { /* hopefully this counts for all operating systems! */ return ((c >= ' ') && (c <= '~') && (c != '\\')); }

static int dazuko_register_daemon (  struct daemon_id *  did, const char *  reg_name, int  string_length, int  write_mode )  [static]

Definition at line 734 of file dazuko_xp.c. References __dazuko_change_slot_state(), call_xp_atomic_inc(), call_xp_atomic_set(), call_xp_down(), call_xp_free(), call_xp_id_copy(), call_xp_init_mutex(), call_xp_malloc(), call_xp_print, call_xp_up(), dazuko_bzero(), dazuko_find_slot(), DAZUKO_FREE, dazuko_get_new_unique(), slot::did, DPRINT, slot::id, slot::mutex, NULL, NUM_SLOTS, slot_list::reg_name, slot_list_container::slot_list, daemon_id::unique, slot_list::use_count, slot::write_mode, XP_ERROR_BUSY, XP_ERROR_FAULT, XP_ERROR_INTERRUPT, XP_ERROR_PERMISSION, and daemon_id::xp_id. { const char *p1; char *p2; struct slot *s; struct slot_list *sl; int i; DPRINT(("dazuko: dazuko_register_daemon() [%d]\n", did->unique)); if (did == NULL || reg_name == NULL) return XP_ERROR_PERMISSION; s = dazuko_find_slot(did, 1, NULL); if (s != NULL) { /* We are already registered! */ call_xp_print("dazuko: daemon %d already assigned to slot[%d]\n", did->unique, s->id); return XP_ERROR_PERMISSION; } /* Find the slot_list with the matching name. */ for (i=0 ; i<NUM_SLOT_LISTS ; i++) { /* DOWN */ /* if we are interrupted, we say that it * was interrupted */ if (call_xp_down(&(slot_lists[i].mutex)) != 0) return XP_ERROR_INTERRUPT; sl = slot_lists[i].slot_list; call_xp_up(&(slot_lists[i].mutex)); /* UP */ if (sl != NULL) { p1 = reg_name; p2 = sl->reg_name; while (*p1 == *p2) { if (*p1 == 0) break; p1++; p2++; } if (*p1 == *p2) break; } } if (i == NUM_SLOT_LISTS) { /* There is no slot_list with this name. We * need to make one. */ sl = (struct slot_list *)call_xp_malloc(sizeof(struct slot_list) + string_length); if (sl == NULL) return XP_ERROR_FAULT; dazuko_bzero(sl, sizeof(struct slot_list) + string_length); call_xp_atomic_set(&(sl->use_count), 0); p1 = reg_name; p2 = sl->reg_name; while (*p1) { *p2 = *p1; p1++; p2++; } *p2 = 0; /* give each slot a unique id */ for (i=0 ; i<NUM_SLOTS ; i++) { sl->slots[i].id = i; call_xp_init_mutex(&(sl->slots[i].mutex)); } /* we need to find an empty slot */ for (i=0 ; i<NUM_SLOT_LISTS ; i++) { /* DOWN */ /* if we are interrupted, we need to cleanup * and return error */ if (call_xp_down(&(slot_lists[i].mutex)) != 0) { call_xp_free(sl); return XP_ERROR_INTERRUPT; } if (slot_lists[i].slot_list == NULL) { slot_lists[i].slot_list = sl; call_xp_up(&(slot_lists[i].mutex)); /* UP */ break; } call_xp_up(&(slot_lists[i].mutex)); /* UP */ } if (i == NUM_SLOT_LISTS) { /* no empty slot :( */ call_xp_free(sl); return XP_ERROR_BUSY; } } /* find an available slot and hold the mutex * if we find one */ /* DOWN? */ s = dazuko_find_slot(NULL, 0, sl); if (s == NULL) return XP_ERROR_BUSY; /* DOWN */ /* We have found a slot, so increment the active * variable and the kernel module use counter. * The module counter will always reflect the * number of daemons. */ call_xp_atomic_inc(&active); /* get new unique id for this process */ did->unique = dazuko_get_new_unique(); s->did.unique = did->unique; s->did.xp_id = call_xp_id_copy(did->xp_id); s->write_mode = write_mode; call_xp_atomic_inc(&(sl->use_count)); /* the daemon is registered, but not yet * ready to receive files */ __dazuko_change_slot_state(s, DAZUKO_FREE, DAZUKO_FREE); DPRINT(("dazuko: slot[%d] assigned to daemon %d\n", s->id, s->did.unique)); call_xp_up(&(s->mutex)); /* UP */ return 0; }

static void dazuko_remove_all_hash (  void   )  [static]

Definition at line 575 of file dazuko_xp.c. References call_xp_free(), call_xp_write_lock(), call_xp_write_unlock(), DPRINT, hash::name, and hash::next. Referenced by _dazuko_unregister_daemon(), and dazuko_exit(). { /* Empty the hash linked list. */ struct hash *tmp; /* LOCK */ call_xp_write_lock(&lock_hash); while (hash) { tmp = hash; hash = hash->next; DPRINT(("dazuko: removing hash %s\n", tmp->name)); call_xp_free(tmp); } call_xp_write_unlock(&lock_hash); /* UNLOCK */ }

static void dazuko_remove_all_paths (  void   )  [static]

Definition at line 596 of file dazuko_xp.c. References call_xp_free(), call_xp_write_lock(), call_xp_write_unlock(), DPRINT, path::next, and path::path. { /* Empty both include and exclude struct path * linked lists. */ struct path *tmp; /* LOCK */ call_xp_write_lock(&lock_lists); /* empty include paths list */ while (incl_paths) { tmp = incl_paths; incl_paths = incl_paths->next; DPRINT(("dazuko: removing incl %s\n", tmp->path)); call_xp_free(tmp); } /* empty exclude paths list */ while (excl_paths) { tmp = excl_paths; excl_paths = excl_paths->next; DPRINT(("dazuko: removing excl %s\n", tmp->path)); call_xp_free(tmp); } call_xp_write_unlock(&lock_lists); /* UNLOCK */ }

static int dazuko_return_access (  struct daemon_id *  did, int  response, struct slot *  s )  [static]

Definition at line 976 of file dazuko_xp.c. References call_xp_notify(), call_xp_up(), call_xp_wait_until_condition(), dazuko_change_slot_state(), DAZUKO_DONE, dazuko_find_slot(), DAZUKO_WORKING, DPRINT, slot::id, slot::mutex, NULL, one_slot_state_not_condition(), slot::response, one_slot_state_not_condition_param::slot, one_slot_state_not_condition_param::state, daemon_id::unique, XP_ERROR_INTERRUPT, and XP_ERROR_PERMISSION. { /* The daemon has finished scanning a file * and has the response to give. The daemon's * slot should be in the DAZUKO_WORKING state. */ struct one_slot_state_not_condition_param cond_p; /* do we already have a slot? */ if (s == NULL) { /* 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\n", did->unique)); return XP_ERROR_PERMISSION; } } /* we will be writing into the slot, so we * need to lock it */ /* DOWN? */ if (!dazuko_change_slot_state(s, DAZUKO_WORKING, DAZUKO_DONE, 0)) { /* The slot is in the wrong state. We will * assume the kernel has cancelled the file * access. */ DPRINT(("dazuko: response from daemon %d on slot[%d] not needed\n", did->unique, s->id)); return 0; } /* DOWN */ s->response = response; call_xp_up(&(s->mutex)); /* UP */ /* wake up any kernel processes that are * waiting for responses */ call_xp_notify(&wait_kernel_waiting_while_daemon_works); cond_p.slot = s; cond_p.state = DAZUKO_DONE; if (call_xp_wait_until_condition(&wait_daemon_waiting_for_free, one_slot_state_not_condition, &cond_p, 1) != 0) { /* The user has issued an interrupt. * Return an error. The daemon should * unregister itself. */ DPRINT(("dazuko: daemon %d killed while waiting for response acknowledgement\n", did->unique)); return XP_ERROR_INTERRUPT; } return 0; }

static int dazuko_run_daemon (  int  event, char *  filename, int  filenamelength, struct event_properties *  event_p, struct file_properties *  file_p )  [static]

Definition at line 2170 of file dazuko_xp.c. References call_xp_down(), call_xp_up(), dazuko_run_daemon_on_slotlist(), NULL, slot_list_container::slot_list, event_properties::thrown, and XP_ERROR_INTERRUPT. { struct slot_list *sl; int i; int rc = 0; int error; if (event_p != NULL) { /* we don't want to throw the same event twice */ if (event_p->thrown) return 0; event_p->thrown = 1; } for (i=0 ; i<NUM_SLOT_LISTS ; i++) { /* DOWN */ /* if we are interrupted, we report error */ if (call_xp_down(&(slot_lists[i].mutex)) != 0) return XP_ERROR_INTERRUPT; sl = slot_lists[i].slot_list; call_xp_up(&(slot_lists[i].mutex)); /* UP */ if (sl != NULL) { error = dazuko_run_daemon_on_slotlist(event, filename, filenamelength, event_p, file_p, rc, sl); if (error < 0) { /* most likely user interrupt */ rc = error; break; } else if (error > 0) { /* this daemon wants access blocked */ rc = 1; } } } return rc; }

static int dazuko_run_daemon_on_slotlist (  int  event, char *  filename, int  filenamelength, struct event_properties *  event_p, struct file_properties *  file_p, int  prev_response, struct slot_list *  sl )  [static]

Definition at line 2027 of file dazuko_xp.c. References __dazuko_change_slot_state(), call_xp_down(), call_xp_notify(), call_xp_up(), call_xp_wait_until_condition(), dazuko_bzero(), dazuko_change_slot_state(), DAZUKO_DONE, DAZUKO_FREE, DAZUKO_WAITING, DAZUKO_WORKING, slot::did, DPRINT, slot::event, slot::event_p, slot::file_p, slot::filename, slot::filenamelength, get_ready_slot_condition(), slot::mutex, NULL, event_properties::pid, slot::response, get_ready_slot_condition_param::slot, two_slot_state_not_condition_param::slot1, two_slot_state_not_condition_param::slot2, get_ready_slot_condition_param::slotlist, two_slot_state_not_condition_param::state1, two_slot_state_not_condition_param::state2, two_slot_state_not_condition(), and daemon_id::unique. { /* This is the main function called by the kernel * to work with a daemon. */ int rc; int unique; struct slot *s; struct get_ready_slot_condition_param cond_p1; struct two_slot_state_not_condition_param cond_p2; begin: /* we initialize the slot value because * we cannot guarentee that it will be * assigned a new value BEFORE !active * is checked */ s = NULL; /* wait for a slot to become ready */ cond_p1.slotlist = sl; cond_p1.slot = s; if (call_xp_wait_until_condition(&wait_kernel_waiting_for_free_slot, get_ready_slot_condition, &cond_p1, 0) != 0) { /* The kernel process was killed while * waiting for a slot to become ready. * This is fine. */ DPRINT(("dazuko: kernel process %d killed while waiting for free slot\n", event_p->pid)); return -1; /* user interrupted */ } /* Make sure we have a slot. We may have * gotten past the last wait because we * are no longer active. */ s = cond_p1.slot; if (s == NULL) { /* We were no longer active. We don't * need to initiate a daemon. This also * means we never acquired the lock. */ return 0; /* allow access */ } /* DOWN */ /* the slot is already locked at this point */ /* grab the daemon's unique */ unique = s->did.unique; /* At this point we have a locked slot. It IS * sitting in the DAZUKO_WAITING state, waiting for * us to give it some work. */ /* set up the slot to do work */ s->filename = filename; s->event = event; s->response = prev_response; s->filenamelength = filenamelength; if (event_p == NULL) dazuko_bzero(&(s->event_p), sizeof(struct event_properties)); else memcpy(&(s->event_p), event_p, sizeof(struct event_properties)); if (file_p == NULL) dazuko_bzero(&(s->file_p), sizeof(struct file_properties)); else memcpy(&(s->file_p), file_p, sizeof(struct file_properties)); /* we are done modifying the slot */ call_xp_up(&(s->mutex)); /* UP */ /* wake up any daemons waiting for work */ call_xp_notify(&wait_daemon_waiting_for_work); /* wait until the daemon is finished with the slot */ cond_p2.slot1 = s; cond_p2.state1 = DAZUKO_WAITING; cond_p2.slot2 = s; cond_p2.state2 = DAZUKO_WORKING; if (call_xp_wait_until_condition(&wait_kernel_waiting_while_daemon_works, two_slot_state_not_condition, &cond_p2, 0) != 0) { /* The kernel process was killed while * waiting for a daemon to process the file. * This is fine. */ DPRINT(("dazuko: kernel process %d killed while waiting for daemon response\n", event_p->pid)); /* change the slot's state to let the * daemon know we are not interested * in a response */ dazuko_change_slot_state(s, DAZUKO_FREE, DAZUKO_FREE, 1); return -1; /* user interrupted */ } /* we are working with the slot, so * we need to lock it */ /* DOWN */ if (call_xp_down(&(s->mutex)) != 0) { return -1; /* user interrupted */ } /* make sure this is the right daemon */ if (s->did.unique != unique) { /* This is a different daemon than * the one we assigned work to. * We need to scan again. */ call_xp_up(&(s->mutex)); /* UP */ goto begin; } /* The slot should now be in the DAZUKO_DONE state. */ if (!__dazuko_change_slot_state(s, DAZUKO_DONE, DAZUKO_FREE)) { /* The daemon was killed while scanning. * We need to scan again. */ call_xp_up(&(s->mutex)); /* UP */ goto begin; } /* grab the response */ rc = s->response; call_xp_up(&(s->mutex)); /* UP */ /* CONGRATULATIONS! You successfully completed a full state cycle! */ return rc; }

static int dazuko_set_option (  struct daemon_id *  did, int  opt, void *  param, int  len )  [static]

Definition at line 1276 of file dazuko_xp.c. References _dazuko_unregister_daemon(), access_mask, ADD_EXCLUDE_PATH, ADD_INCLUDE_PATH, call_xp_print, dazuko_find_slot(), dazuko_insert_path_fs(), dazuko_register_daemon(), dazuko_remove_all_paths(), NULL, REGISTER, REMOVE_ALL_PATHS, SET_ACCESS_MASK, UNREGISTER, and XP_ERROR_PERMISSION. { /* The daemon wants to set a configuration * option in the kernel. */ struct slot *s; int error; /* sanity check */ if (len < 0 || len > 8192) return XP_ERROR_PERMISSION; /* make sure we are already registered * (or that we don't register twice) */ /* find our slot */ s = dazuko_find_slot(did, 1, NULL); switch (opt) { case REGISTER: call_xp_print("dazuko: dazuko_set_option does not support REGISTER (bug!)\n"); return XP_ERROR_PERMISSION; case UNREGISTER: if (s == NULL) { /* We are not registered! */ return 0; } break; default: if (s == NULL) { error = dazuko_register_daemon(did, "_COMPAT", 7, 1); if (error) { call_xp_print("dazuko: unregistered daemon %d attempted access\n", did->unique); return XP_ERROR_PERMISSION; } s = dazuko_find_slot(did, 1, NULL); if (s == NULL) { call_xp_print("dazuko: unregistered daemon %d attempted access\n", did->unique); return XP_ERROR_PERMISSION; } call_xp_print("dazuko: warning: daemon %d is using a deprecated protocol\n", did->unique); } break; } /* check option type and take the appropriate action */ switch (opt) { case UNREGISTER: error = _dazuko_unregister_daemon(did); if (error) return error; break; case SET_ACCESS_MASK: memcpy(&access_mask, (char *)param, sizeof(char)); break; case ADD_INCLUDE_PATH: error = dazuko_insert_path_fs(&incl_paths, (char *)param, len); if (error) return error; break; case ADD_EXCLUDE_PATH: error = dazuko_insert_path_fs(&excl_paths, (char *)param, len); if (error) return error; break; case REMOVE_ALL_PATHS: dazuko_remove_all_paths(); break; default: call_xp_print("dazuko: daemon %d requested unknown set %d (possible bug)\n", did->unique, opt); break; } return 0; }

static int dazuko_should_scan (  struct dazuko_file_struct *  kfs  )  [static]

Definition at line 2508 of file dazuko_xp.c. References call_xp_fill_file_struct(), dazuko_is_selected(), and dazuko_file_struct::should_scan. { /* Check if we are supposed to scan this file. * This checks for all the correct file types, * permissions, and if it is within the desired * paths to scan. */ int result = 0; /* check if we already know if we scan this file */ switch (kfs->should_scan) { /* case 0 means that we do not know yet. This is a little * confusing, because 0 represents uninitialized. However, * the should_scan variable is used in this function ONLY * so this optimization shouldn't cause any problems. */ case 1: /* we already know it should be scanned */ return 1; case 2: /* we already know it should not be scanned */ return 2; } /* make necessary platform-dependent checks */ if (call_xp_fill_file_struct(kfs) == 0) { if (dazuko_is_selected(kfs)) { /* If we made it this far, we are supposed * to scan this file. We mark it so that * any further immediate inquiries don't have * to do all this work all over again. */ /* yes, should be scanned */ kfs->should_scan = 1; result = 1; } else { /* We will still mark it so that any further * immediate inquiries don't have to do all * this work all over again. */ /* no, should not be scanned */ kfs->should_scan = 2; } } return result; }

static int dazuko_slot_state (  struct slot *  s  )  [inline, static]

Definition at line 299 of file dazuko_xp.c. References call_xp_down(), call_xp_up(), slot::mutex, slot::state, and XP_ERROR_INTERRUPT. { int state; /* DOWN */ if (call_xp_down(&(s->mutex)) != 0) return XP_ERROR_INTERRUPT; state = s->state; call_xp_up(&(s->mutex)); /* UP */ return state; }

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

Definition at line 261 of file dazuko_xp.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; }

static int dazuko_state_error (  struct slot *  s, int  current_state )  [inline, static]

Definition at line 723 of file dazuko_xp.c. References call_xp_notify(), DAZUKO_BROKEN, and dazuko_change_slot_state(). Referenced by dazuko_handle_user_request_compat12(). { if (dazuko_change_slot_state(s, current_state, DAZUKO_BROKEN, 1)) { call_xp_notify(&wait_kernel_waiting_for_free_slot); call_xp_notify(&wait_kernel_waiting_while_daemon_works); } return 0; }

static const char* dazuko_strchr (  const char *  haystack, char  needle )  [inline, static]

Definition at line 1101 of file dazuko_xp.c. References NULL. { const char *p; if (haystack == NULL) return NULL; for (p=haystack ; *p ; p++) { if (*p == needle) return p; } return NULL; }

static int dazuko_strlen (  const char *  string  )  [inline, static]

Definition at line 1088 of file dazuko_xp.c. References NULL. { const char *p; if (string == NULL) return -1; for (p=string ; *p ; p++) continue; return (p - string); }

static const char* dazuko_strstr (  const char *  haystack, const char *  needle )  [inline, static]

Definition at line 1117 of file dazuko_xp.c. References NULL. { const char *p1; const char *p2; const char *p3; if (haystack == NULL || needle == NULL) return NULL; for (p1=haystack ; *p1 ; p1++) { for (p2=needle,p3=p1 ; *p2&&*p3 ; p2++,p3++) { if (*p2 != *p3) break; } if (*p2 == 0) return p1; } return NULL; }

static long dazuko_strtol (  const char *  string  )  [inline, static]

Definition at line 1048 of file dazuko_xp.c. References dazuko_isdigit(), and NULL. { long num = 1; const char *p = string; if (string == NULL) return 0; switch (*p) { case '-': num = -1; p++; break; case '+': p++; break; } if (dazuko_isdigit(*p)) { num *= *p - '0'; p++; } else { return 0; } while (dazuko_isdigit(*p)) { num *= 10; num += *p - '0'; p++; } return num; }

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 705 of file dazuko_xp.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 149 of file dazuko_xp.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 '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); }

static int get_ready_slot_condition (  void *  param  )  [static]

Definition at line 2020 of file dazuko_xp.c. References call_xp_atomic_read(), dazuko_get_and_hold_ready_slot(), and NULL. { return ((((struct get_ready_slot_condition_param *)param)->slot = dazuko_get_and_hold_ready_slot(((struct get_ready_slot_condition_param *)param)->slotlist)) != NULL || call_xp_atomic_read(&active) == 0 || call_xp_atomic_read(&(((struct get_ready_slot_condition_param *)param)->slotlist->use_count)) == 0); }

static int one_slot_state_not_condition (  void *  param  )  [static]

Definition at line 315 of file dazuko_xp.c. References dazuko_slot_state(). { return (dazuko_slot_state(((struct one_slot_state_not_condition_param *)param)->slot) != ((struct one_slot_state_not_condition_param *)param)->state); }

static int two_slot_state_not_condition (  void *  param  )  [static]

Definition at line 321 of file dazuko_xp.c. References dazuko_slot_state(). { return (dazuko_slot_state(((struct two_slot_state_not_condition_param *)param)->slot1) != ((struct two_slot_state_not_condition_param *)param)->state1 && dazuko_slot_state(((struct two_slot_state_not_condition_param *)param)->slot2) != ((struct two_slot_state_not_condition_param *)param)->state2); }

---

Variable Documentation

char access_mask = 7 [static]

Definition at line 133 of file dazuko_xp.c. Referenced by dazuko_handle_request(), dazuko_set_option(), and dazuko_sys_check().

struct xp_atomic active [static]

Definition at line 140 of file dazuko_xp.c.

struct path* excl_paths = NULL [static]

Definition at line 136 of file dazuko_xp.c.

struct hash* hash = NULL [static]

Definition at line 137 of file dazuko_xp.c.

struct path* incl_paths = NULL [static]

Definition at line 135 of file dazuko_xp.c.

struct xp_rwlock lock_hash [static]

Definition at line 138 of file dazuko_xp.c.

struct xp_rwlock lock_lists [static]

Definition at line 139 of file dazuko_xp.c.

struct xp_mutex mutex_unique_count [static]

Definition at line 141 of file dazuko_xp.c.

struct slot_list_container slot_lists[NUM_SLOT_LISTS] [static]

Definition at line 134 of file dazuko_xp.c.

int unique_count = 1 [static]

Definition at line 132 of file dazuko_xp.c.

struct xp_queue wait_daemon_waiting_for_free [static]

Definition at line 146 of file dazuko_xp.c.

struct xp_queue wait_daemon_waiting_for_work [static]

Definition at line 144 of file dazuko_xp.c.

struct xp_queue wait_kernel_waiting_for_free_slot [static]

Definition at line 143 of file dazuko_xp.c.

struct xp_queue wait_kernel_waiting_while_daemon_works [static]

Definition at line 145 of file dazuko_xp.c.

---