dazuko_linux.c File Reference

#include "dazuko_linux.h"
#include "dazuko_core.h"

Go to the source code of this file.

Defines
#define	DAZUKO_DM   0
#define	__wait_event_interruptible(wq, condition, ret)
#define	wait_event_interruptible(wq, condition)
#define	wait_event(wq, condition)
#define	DAZUKO_HOOK(syscall_func)
#define	DAZUKO_UNHOOK(syscall_func)
Functions
int	linux_dazuko_device_read (struct file *file, char *buffer, size_t length, loff_t *pos)
int	linux_dazuko_device_write (struct file *file, const char *buffer, size_t length, loff_t *pos)
int	linux_dazuko_device_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long param)
int	linux_dazuko_device_open (struct inode *inode, struct file *file)
int	linux_dazuko_device_release (struct inode *inode, struct file *file)
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)
static int	dazuko_get_filename_dentry (struct xp_file_struct *xfs, int follow_symlinks, const char *local_filename, int user_ptr)
static int	dazuko_get_fd_dentry (struct xp_file_struct *xfs)
static char *	__d_path (struct dentry *dentry, struct dentry *root, char *buffer, int buflen)
static int	dazuko_get_full_filename (struct xp_file_struct *xfs)
static int	dazuko_fill_file_struct_cleanup (struct dazuko_file_struct *dfs)
int	xp_fill_file_struct (struct dazuko_file_struct *dfs)
static int	dazuko_file_struct_cleanup (struct dazuko_file_struct **dfs)
static int	check_parent (struct task_struct *parent, struct task_struct *child)
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)
static int	linux_dazuko_sys_generic (int event, const char *user_pathname, int daemon_is_allowed)
int	xp_sys_hook ()
int	xp_sys_unhook ()
int	xp_print (const char *fmt,...)
int __init	linux_dazuko_init (void)
void	linux_dazuko_exit (void)
	module_init (linux_dazuko_init)
	module_exit (linux_dazuko_exit)
Variables
void *	sys_call_table []
xp_atomic	active
static struct dentry *	orig_root = NULL
static int	dev_major = -1
static struct file_operations	fops

---

Define Documentation

#define __wait_event_interruptible (  wq, condition, ret   )

Value: do { \ struct wait_queue __wait; \ \ __wait.task = current; \ add_wait_queue(&wq, &__wait); \ for (;;) { \ current->state = TASK_INTERRUPTIBLE; \ mb(); \ if (condition) \ break; \ if (!signal_pending(current)) { \ schedule(); \ continue; \ } \ ret = -ERESTARTSYS; \ break; \ } \ current->state = TASK_RUNNING; \ remove_wait_queue(&wq, &__wait); \ } while (0) Definition at line 99 of file dazuko_linux.c.

#define DAZUKO_DM   0

Definition at line 35 of file dazuko_linux.c. Referenced by xp_sys_hook().

#define DAZUKO_HOOK (  syscall_func   )

Value: do \ { \ original_sys_##syscall_func = sys_call_table[__NR_##syscall_func]; \ sys_call_table[__NR_##syscall_func] = linux_dazuko_sys_##syscall_func; \ DPRINT(("dazuko: hooked sys_" #syscall_func "\n")); \ } \ while (0) Definition at line 1602 of file dazuko_linux.c. Referenced by xp_sys_hook().

#define DAZUKO_UNHOOK (  syscall_func   )

Value: do \ { \ if (sys_call_table[__NR_##syscall_func] != linux_dazuko_sys_##syscall_func) \ xp_print("dazuko: " #syscall_func " system call has been changed (system may be left in an unstable state!)\n"); \ sys_call_table[__NR_##syscall_func] = original_sys_##syscall_func; \ DPRINT(("dazuko: unhooked sys_" #syscall_func "\n")); \ } \ while (0) Definition at line 1723 of file dazuko_linux.c. Referenced by xp_sys_unhook().

#define wait_event (  wq, condition   )

Value: ({ \ int __ret = 0; \ if (!(condition)) \ __wait_event_interruptible(wq, condition, __ret);\ __ret; \ }) Definition at line 130 of file dazuko_linux.c. Referenced by xp_wait_until_condition().

#define wait_event_interruptible (  wq, condition   )

Value: ({ \ int __ret = 0; \ if (!(condition)) \ __wait_event_interruptible(wq, condition, __ret);\ __ret; \ }) Definition at line 123 of file dazuko_linux.c. Referenced by xp_wait_until_condition().

---

Function Documentation

static char* __d_path (  struct dentry *  dentry, struct dentry *  root, char *  buffer, int  buflen )  [static]

Definition at line 489 of file dazuko_linux.c. Referenced by dazuko_get_full_filename(). { /* Copy of d_path from linux/dcache.c but using * a given root instead of the current root. */ char * end = buffer+buflen; char * retval; *--end = '\0'; buflen--; if (dentry->d_parent != dentry && list_empty(&dentry->d_hash)) { buflen -= 10; end -= 10; memcpy(end, " (deleted)", 10); } /* Get '/' right */ retval = end-1; *retval = '/'; for (;;) { struct dentry * parent; int namelen; if (dentry == root) break; dentry = dentry->d_covers; parent = dentry->d_parent; if (dentry == parent) break; namelen = dentry->d_name.len; buflen -= namelen + 1; if (buflen < 0) break; end -= namelen; memcpy(end, dentry->d_name.name, namelen); *--end = '/'; retval = end; dentry = parent; } return retval; }

static int check_parent (  struct task_struct *  parent, struct task_struct *  child )  [inline, static]

Definition at line 900 of file dazuko_linux.c. References NULL. { struct task_struct *ts = child; if (parent == NULL || child == NULL) return -1; while (1) { if (ts == parent) return 0; #ifdef TASKSTRUCT_USES_PARENT if (ts->parent == NULL) break; if (ts == ts->parent) break; ts = ts->parent; #else if (ts->p_pptr == NULL) break; if (ts == ts->p_pptr) break; ts = ts->p_pptr; #endif } return -1; }

static int dazuko_file_struct_cleanup (  struct dazuko_file_struct **  dfs  )  [static]

Definition at line 866 of file dazuko_linux.c. References dazuko_file_listnode::filename, dazuko_file_listnode::next, NULL, and xp_free(). { struct dazuko_file_listnode *cur; if (dfs == NULL) return 0; if (*dfs == NULL) return 0; while ((*dfs)->aliases != NULL) { cur = (*dfs)->aliases; (*dfs)->aliases = cur->next; if (cur->filename != NULL) xp_free(cur->filename); xp_free(cur); } if ((*dfs)->extra_data != NULL) xp_free((*dfs)->extra_data); xp_free(*dfs); *dfs = NULL; return 0; }

static int dazuko_fill_file_struct_cleanup (  struct dazuko_file_struct *  dfs  )  [inline, static]

Definition at line 612 of file dazuko_linux.c. References xp_file_struct::buffer, xp_file_struct::dentry, xp_file_struct::dput_dentry, dazuko_file_struct::extra_data, xp_file_struct::free_page_buffer, xp_file_struct::mntput_vfsmount, xp_file_struct::nd, NULL, and xp_file_struct::vfsmount. Referenced by xp_fill_file_struct(). { /* Delete all the flagged structures from the * given dazuko_file_struct and reset all critical * values back to 0. */ if (dfs->extra_data == NULL) return 0; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0) { if (dfs->extra_data->mntput_vfsmount) { mntput(dfs->extra_data->vfsmount); dfs->extra_data->mntput_vfsmount = 0; } } #endif if (dfs->extra_data->free_page_buffer) { free_page((unsigned long)dfs->extra_data->buffer); dfs->extra_data->free_page_buffer = 0; } if (dfs->extra_data->dput_dentry) { dput(dfs->extra_data->dentry); dfs->extra_data->dput_dentry = 0; } #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0) { if (dfs->extra_data->path_release_nd) { path_release(&(dfs->extra_data->nd)); dfs->extra_data->path_release_nd = 0; } } #endif return 0; }

static int dazuko_get_fd_dentry (  struct xp_file_struct *  xfs  )  [static]

Definition at line 432 of file dazuko_linux.c. References xp_file_struct::dentry, xp_file_struct::dput_dentry, xp_file_struct::mntput_vfsmount, NULL, and xp_file_struct::vfsmount. Referenced by xp_fill_file_struct(). { if (current->files != NULL) { #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0) { read_lock(&current->files->file_lock); } #endif if (current->files->fd != NULL) { if (current->files->fd[xfs->fd] != NULL) { if (current->files->fd[xfs->fd]->f_dentry != NULL) { xfs->dentry = dget(current->files->fd[xfs->fd]->f_dentry); xfs->dput_dentry = 1; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0) { if (current->files->fd[xfs->fd]->f_vfsmnt != NULL) { xfs->vfsmount = mntget(current->files->fd[xfs->fd]->f_vfsmnt); xfs->mntput_vfsmount = 1; } else { dput(xfs->dentry); xfs->dentry = NULL; xfs->dput_dentry = 0; } } #endif } } } #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0) { read_unlock(&current->files->file_lock); } #endif } /* check if we got the dentry */ if (xfs->dentry == NULL) return 0; /* check if this file has no inode */ if (xfs->dentry->d_inode == NULL) return 0; return 1; }

static int dazuko_get_filename_dentry (  struct xp_file_struct *  xfs, int  follow_symlinks, const char *  local_filename, int  user_ptr )  [static]

Definition at line 333 of file dazuko_linux.c. References dazuko_bzero(), dazuko_get_filename_length(), xp_file_struct::dentry, xp_file_struct::dput_dentry, xp_file_struct::nd, and NULL. Referenced by xp_fill_file_struct(). { /* We get the appropriate structures in order * to acquire the inode and store them in the * dazuko_file_struct structure. */ const char *filename = NULL; int putname_filename = 0; int filename_length = 0; int rc = 0; /* make sure we really need to get the filename */ if (user_ptr) { /* grab filename from filename cache */ filename = (char *)getname(local_filename); /* make sure it is a valid name */ if (IS_ERR(filename)) { filename = NULL; return 0; } /* the name will need to be put back */ putname_filename = 1; } else { filename = local_filename; } filename_length = dazuko_get_filename_length(filename); #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0) { dazuko_bzero(&(xfs->nd), sizeof(struct nameidata)); /* initialize nameidata structure for finding file data */ if (!path_init(filename, (follow_symlinks ? LOOKUP_FOLLOW : 0) | LOOKUP_POSITIVE, &(xfs->nd))) goto dentry_exit; if (!xfs->path_release_nd) { /* find file data and fill it in nameidata structure */ if (path_walk(filename, &(xfs->nd))) /* !=0 -> error */ goto dentry_exit; /* the nameidata will need to be released */ xfs->path_release_nd = 1; } /* get a local copy of the dentry to make kernel version * compatibility code eaiser to read */ /* make sure we don't already have a dentry */ if (!xfs->dput_dentry) { xfs->dentry = dget(xfs->nd.dentry); /* the dentry will need to be put back */ xfs->dput_dentry = 1; } } #else { if (!xfs->dput_dentry) { xfs->dentry = lookup_dentry(filename, NULL, (follow_symlinks ? LOOKUP_FOLLOW : 0)); if (IS_ERR(xfs->dentry)) { xfs->dentry = NULL; goto dentry_exit; } /* the dentry will need to be put back */ xfs->dput_dentry = 1; } } #endif /* check if this file has no inode */ if (xfs->dentry->d_inode == NULL) { goto dentry_exit; } else { /* if we made it this far, we got the inode */ rc = 1; } dentry_exit: if (putname_filename) putname(filename); return rc; }

static int dazuko_get_full_filename (  struct xp_file_struct *  xfs  )  [static]

Definition at line 533 of file dazuko_linux.c. References __d_path(), xp_file_struct::buffer, dazuko_get_filename_length(), xp_file_struct::dentry, xp_file_struct::free_full_filename, xp_file_struct::free_page_buffer, xp_file_struct::full_filename, xp_file_struct::full_filename_length, xp_file_struct::mntput_vfsmount, xp_file_struct::nd, NULL, orig_root, orig_rootmnt, xp_file_struct::vfsmount, and xp_malloc(). Referenced by xp_fill_file_struct(). { /* Get the filename with the full path appended * to the beginning. */ char *temp; struct dentry *root; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0) struct vfsmount *rootmnt; #endif /* check if we need to allocate a buffer */ if (!xfs->free_page_buffer) { /* get pre-requisites for d_path function */ xfs->buffer = (char *)__get_free_page(GFP_USER); /* the buffer will need to be freed */ xfs->free_page_buffer = 1; } root = dget(orig_root); #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0) { /* make sure we don't already have a vfsmount */ if (!xfs->mntput_vfsmount) { xfs->vfsmount = mntget(xfs->nd.mnt); /* the vfsmount will need to be put back */ xfs->mntput_vfsmount = 1; } /* build new filename with path included, using temp */ rootmnt = mntget(orig_rootmnt); spin_lock(&dcache_lock); temp = __d_path(xfs->dentry, xfs->vfsmount, root, rootmnt, xfs->buffer, PAGE_SIZE); spin_unlock(&dcache_lock); mntput(rootmnt); } #else { /* build new filename with path included, using temp */ temp = __d_path(xfs->dentry, root, xfs->buffer, PAGE_SIZE); } #endif dput(root); /* make sure we really got a new filename */ if (temp == NULL) return 0; /* make sure we don't already have a full_filename */ if (!xfs->free_full_filename) { xfs->full_filename_length = dazuko_get_filename_length(temp); xfs->full_filename = (char *)xp_malloc(xfs->full_filename_length + 1); if (!xfs->full_filename) return 0; /* the char array will need to be freed */ xfs->free_full_filename = 1; memcpy(xfs->full_filename, temp, xfs->full_filename_length + 1); } /* we have a filename with the full path */ return 1; }

int linux_dazuko_device_ioctl (  struct inode *  inode, struct file *  file, unsigned int  cmd, unsigned long  param )

int linux_dazuko_device_open (  struct inode *  inode, struct file *  file )

int linux_dazuko_device_read (  struct file *  file, char *  buffer, size_t  length, loff_t *  pos )

Definition at line 1137 of file dazuko_linux26.c. { /* Reading from the dazuko device simply * returns the device number. This is to * help out the daemon. */ char tmp[20]; size_t dev_major_len; DPRINT(("dazuko: linux_dazuko_device_read() [%d]\n", current->pid)); if (*pos != 0) return 0; if (dev_major < 0) return XP_ERROR_NODEVICE; /* print dev_major to a string * and get length (with terminator) */ dazuko_bzero(tmp, sizeof(tmp)); dev_major_len = dazuko_snprintf(tmp, sizeof(tmp), "%d", dev_major) + 1; if (tmp[sizeof(tmp)-1] != 0) { xp_print("dazuko: failing device_read, device number overflow for dameon %d (dev_major=%d)\n", current->pid, dev_major); return XP_ERROR_FAULT; } if (length < dev_major_len) return XP_ERROR_INVALID; /* copy dev_major string to userspace */ if (xp_copyout(tmp, buffer, dev_major_len) != 0) return XP_ERROR_FAULT; *pos += dev_major_len; return dev_major_len; }

int linux_dazuko_device_release (  struct inode *  inode, struct file *  file )

int linux_dazuko_device_write (  struct file *  file, const char *  buffer, size_t  length, loff_t *  pos )

Definition at line 1178 of file dazuko_linux26.c. { struct xp_daemon_id xp_id; char tmpbuffer[32]; int size; size = length; if (length >= sizeof(tmpbuffer)) size = sizeof(tmpbuffer) -1; /* copy request pointer string to kernelspace */ if (xp_copyin(buffer, tmpbuffer, size) != 0) return XP_ERROR_FAULT; tmpbuffer[size] = 0; xp_id.pid = current->pid; xp_id.file = file; xp_id.current_p = current; xp_id.files = current->files; if (dazuko_handle_user_request(tmpbuffer, &xp_id) == 0) return size; return XP_ERROR_INTERRUPT; }

void linux_dazuko_exit (  void   )

Definition at line 1964 of file dazuko_linux.c. References dazuko_exit(). { dazuko_exit(); }

int __init linux_dazuko_init (  void   )

Definition at line 1956 of file dazuko_linux.c. References dazuko_init(). { return dazuko_init(); }

static int linux_dazuko_sys_generic (  int  event, const char *  user_pathname, int  daemon_is_allowed )  [inline, static]

Definition at line 1500 of file dazuko_linux.c. References dazuko_bzero(), dazuko_check_access(), dazuko_file_struct_cleanup(), dazuko_process_access(), xp_daemon_id::file, NULL, xp_daemon_id::pid, xp_free(), and xp_malloc(). { struct dazuko_file_struct *dfs = NULL; int error = 0; int check_error = 0; struct event_properties event_p; struct xp_daemon_id xp_id; struct slot_list *sl = NULL; xp_id.pid = current->pid; xp_id.file = NULL; xp_id.current_p = current; xp_id.files = current->files; check_error = dazuko_check_access(event, daemon_is_allowed, &xp_id, &sl); if (!check_error) { dfs = (struct dazuko_file_struct *)xp_malloc(sizeof(struct dazuko_file_struct)); if (dfs) { dazuko_bzero(dfs, sizeof(struct dazuko_file_struct)); dfs->extra_data = (struct xp_file_struct *)xp_malloc(sizeof(struct xp_file_struct)); if (dfs->extra_data != NULL) { dazuko_bzero(dfs->extra_data, sizeof(struct xp_file_struct)); dfs->extra_data->user_filename = user_pathname; dazuko_bzero(&event_p, sizeof(event_p)); event_p.pid = current->pid; event_p.set_pid = 1; event_p.uid = current->uid; event_p.set_uid = 1; error = dazuko_process_access(event, dfs, &event_p, sl); dazuko_file_struct_cleanup(&dfs); } else { xp_free(dfs); dfs = NULL; } } } return error; }

module_exit (  linux_dazuko_exit   )

module_init (  linux_dazuko_init   )

int xp_atomic_dec (  struct xp_atomic *  atomic  )  [inline]

Definition at line 314 of file dazuko_linux.c. References xp_atomic::atomic. { #ifdef MODULE if (atomic == &active) MOD_DEC_USE_COUNT; #endif atomic_dec(&(atomic->atomic)); return 0; }

int xp_atomic_inc (  struct xp_atomic *  atomic  )  [inline]

Definition at line 303 of file dazuko_linux.c. References xp_atomic::atomic. { #ifdef MODULE if (atomic == &active) MOD_INC_USE_COUNT; #endif atomic_inc(&(atomic->atomic)); return 0; }

int xp_atomic_read (  struct xp_atomic *  atomic  )  [inline]

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

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

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

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

Definition at line 258 of file dazuko_linux.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 263 of file dazuko_linux.c. { return copy_to_user(user_dest, kernel_src, size); }

void xp_destroy_mutex (  struct xp_mutex *  mutex  )  [inline]

Definition at line 163 of file dazuko_linux.c. { }

int xp_destroy_queue (  struct xp_queue *  queue  )  [inline]

Definition at line 239 of file dazuko_linux.c. { return 0; }

void xp_destroy_rwlock (  struct xp_rwlock *  rwlock  )  [inline]

Definition at line 199 of file dazuko_linux.c. { }

void xp_down (  struct xp_mutex *  mutex  )  [inline]

Definition at line 153 of file dazuko_linux.c. References xp_mutex::mutex. { down(&(mutex->mutex)); }

int xp_fill_file_struct (  struct dazuko_file_struct *  dfs  )  [inline]

Definition at line 656 of file dazuko_linux.c. References dazuko_file_struct::aliases, dazuko_bzero(), DAZUKO_DIRECTORY, dazuko_fill_file_struct_cleanup(), dazuko_get_fd_dentry(), dazuko_get_filename_dentry(), dazuko_get_filename_length(), dazuko_get_full_filename(), DAZUKO_LINK, DAZUKO_REGULAR, xp_file_struct::dentry, file_properties::device_type, dazuko_file_struct::extra_data, dazuko_file_struct::file_p, xp_file_struct::free_full_filename, xp_file_struct::full_filename, xp_file_struct::full_filename_length, file_properties::gid, file_properties::mode, dazuko_file_listnode::next, NULL, file_properties::set_device_type, file_properties::set_gid, file_properties::set_mode, file_properties::set_size, file_properties::set_type, file_properties::set_uid, file_properties::size, file_properties::type, file_properties::uid, xp_file_struct::user_filename, xp_free(), and xp_malloc(). { struct dazuko_file_listnode *listnode; int follow_symlinks = 0; int error = -1; int loopcount = 0; char *freeparentpath = NULL; char *parentpath = NULL; char *rawfilename = NULL; int i; if (dfs == NULL) return error; /* check if filenames have already been filled in */ if (dfs->aliases != NULL) return 0; if (dfs->extra_data == NULL) return error; /* make sure we can get an inode */ while (1) { loopcount++; if (dfs->extra_data->user_filename != NULL) { if (!dazuko_get_filename_dentry(dfs->extra_data, follow_symlinks, dfs->extra_data->user_filename, 1)) { /* we will try to build a "fake" name from the parent directory */ freeparentpath = getname(dfs->extra_data->user_filename); /* make sure it is a valid name */ if (IS_ERR(freeparentpath)) { freeparentpath = NULL; break; } parentpath = freeparentpath; i = dazuko_get_filename_length(parentpath); if (i == 0) break; while (i > 0) { if (parentpath[i] == '/') { rawfilename = parentpath + i + 1; parentpath[i] = 0; break; } i--; } if (i == 0) { if (parentpath[i] == '/') { rawfilename = parentpath + 1; parentpath = "/"; } else { rawfilename = parentpath; parentpath = "."; } } if (!dazuko_get_filename_dentry(dfs->extra_data, follow_symlinks, parentpath, 0)) { putname(freeparentpath); freeparentpath = NULL; break; } } } else { if (!dazuko_get_fd_dentry(dfs->extra_data)) { break; } else { /* make sure we don't loop a 2nd time */ loopcount++; } } /* make sure we can get the full path */ if (!dazuko_get_full_filename(dfs->extra_data)) break; if (freeparentpath != NULL) { /* we are working with a "fake" name */ parentpath = dfs->extra_data->full_filename; i = dazuko_get_filename_length(rawfilename); dfs->extra_data->full_filename = (char *)xp_malloc(dfs->extra_data->full_filename_length + 1 + i + 1); if (dfs->extra_data->full_filename == NULL) { /* put things back how they were and get out */ dfs->extra_data->full_filename = parentpath; break; } /* copy parent path */ memcpy(dfs->extra_data->full_filename, parentpath, dfs->extra_data->full_filename_length); /* possibly copy "/" */ if (dfs->extra_data->full_filename[dfs->extra_data->full_filename_length - 1] != '/') { dfs->extra_data->full_filename[dfs->extra_data->full_filename_length] = '/'; dfs->extra_data->full_filename_length++; } /* copy filename */ memcpy(dfs->extra_data->full_filename + dfs->extra_data->full_filename_length, rawfilename, i + 1); dfs->extra_data->full_filename_length += i; /* free allocated parent path */ xp_free(parentpath); } else { 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; dfs->file_p.device_type = dfs->extra_data->dentry->d_inode->i_dev; dfs->file_p.set_device_type = 1; } if (S_ISREG(dfs->extra_data->dentry->d_inode->i_mode)) { dfs->file_p.type = DAZUKO_REGULAR; dfs->file_p.set_type = 1; } else if (S_ISLNK(dfs->extra_data->dentry->d_inode->i_mode)) { dfs->file_p.type = DAZUKO_LINK; dfs->file_p.set_type = 1; } else if (S_ISDIR(dfs->extra_data->dentry->d_inode->i_mode)) { dfs->file_p.type = DAZUKO_DIRECTORY; dfs->file_p.set_type = 1; } listnode = (struct dazuko_file_listnode *)xp_malloc(sizeof(struct dazuko_file_listnode)); if (listnode == NULL) break; dazuko_bzero(listnode, sizeof(struct dazuko_file_listnode)); listnode->filename = dfs->extra_data->full_filename; listnode->filename_length = dfs->extra_data->full_filename_length; /* the string length */ dfs->extra_data->free_full_filename = 0; dfs->extra_data->full_filename = NULL; dfs->extra_data->full_filename_length = 0; if (dfs->aliases == NULL) { listnode->next = dfs->aliases; dfs->aliases = listnode; } else { listnode->next = dfs->aliases->next; dfs->aliases->next = listnode; } /* we successfully got the file information */ error = 0; if (!follow_symlinks && dfs->file_p.set_type && dfs->file_p.type == DAZUKO_LINK && loopcount < 2) { /* this is a link, we will grab the real path now */ follow_symlinks = 1; /* clean up because we are going to fill it again */ dazuko_fill_file_struct_cleanup(dfs); } else { /* we've grabbed the real path (or we already have 2 paths), so we are done */ break; } } if (freeparentpath != NULL) putname(freeparentpath); dazuko_fill_file_struct_cleanup(dfs); return error; }

int xp_free (  void *  ptr  )  [inline]

Definition at line 252 of file dazuko_linux.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. References check_parent, DAZUKO_CHILD, DAZUKO_DIFFERENT, DAZUKO_SAME, DAZUKO_SUSPICIOUS, xp_daemon_id::file, NULL, and xp_daemon_id::pid. { 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 972 of file dazuko_linux.c. References xp_daemon_id::file, NULL, xp_daemon_id::pid, and xp_malloc(). { struct xp_daemon_id *ptr; if (id == NULL) return NULL; ptr = (struct xp_daemon_id *)xp_malloc(sizeof(struct xp_daemon_id)); if (ptr != NULL) { ptr->pid = id->pid; ptr->file = id->file; ptr->current_p = id->current_p; ptr->files = id->files; } return ptr; }

int xp_id_free (  struct xp_daemon_id *  id  )  [inline]

Definition at line 965 of file dazuko_linux.c. References xp_free(). { 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 144 of file dazuko_linux.c. References xp_mutex::mutex. { #ifdef init_MUTEX init_MUTEX(&(mutex->mutex)); #else sema_init(&(mutex->mutex), 1); #endif }

int xp_init_queue (  struct xp_queue *  queue  )  [inline]

Definition at line 206 of file dazuko_linux.c. References NULL, and xp_queue::queue. { #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0) init_waitqueue_head(&(queue->queue)); #else queue = NULL; #endif return 0; }

void xp_init_rwlock (  struct xp_rwlock *  rwlock  )  [inline]

Definition at line 170 of file dazuko_linux.c. References xp_rwlock::rwlock. { #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0) rwlock_init(&(rwlock->rwlock)); #else rwlock->rwlock = RW_LOCK_UNLOCKED; #endif }

int xp_is_absolute_path (  const char *  path  )  [inline]

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

void* xp_malloc (  size_t  size  )  [inline]

Definition at line 247 of file dazuko_linux.c. { return kmalloc(size, GFP_KERNEL); }

int xp_notify (  struct xp_queue *  queue  )  [inline]

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

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

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

void xp_read_lock (  struct xp_rwlock *  rlock  )  [inline]

Definition at line 189 of file dazuko_linux.c. References xp_rwlock::rwlock. { read_lock(&(rlock->rwlock)); }

void xp_read_unlock (  struct xp_rwlock *  rlock  )  [inline]

Definition at line 194 of file dazuko_linux.c. References xp_rwlock::rwlock. { read_unlock(&(rlock->rwlock)); }

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 1610 of file dazuko_linux.c. References DAZUKO_DM, DAZUKO_HOOK, dev_major, DEVICE_NAME, fops, NULL, orig_root, orig_rootmnt, sys_call_table, and xp_print(). { /* Called insmod when inserting the module. */ #ifdef HIDDEN_SCT sys_call_table = dazuko_get_sct(); if (sys_call_table == NULL) { xp_print("dazuko: panic (sys_call_table == NULL)\n"); return -1; } #endif /* Make sure we have a valid task_struct. */ if (current == NULL) { xp_print("dazuko: panic (current == NULL)\n"); return -1; } if (current->fs == NULL) { xp_print("dazuko: panic (current->fs == NULL)\n"); return -1; } if (current->fs->root == NULL) { xp_print("dazuko: panic (current->fs->root == NULL)\n"); return -1; } #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0) { if (current->fs->rootmnt == NULL) { xp_print("dazuko: panic (current->fs->rootmnt == NULL)\n"); return -1; } } #endif /* register the dazuko device */ #ifdef DEVFS_SUPPORT dev_major = devfs_register_chrdev(0, 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(DAZUKO_DM, DEVICE_NAME, &fops); #endif if (dev_major < 0) { xp_print("dazuko: unable to register device chrdev, err=%d\n", dev_major); return dev_major; } /* Grab the current root. This is assumed to be the real. * If it is not the real root, we could have problems * looking up filenames. */ #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0) { read_lock(&current->fs->lock); orig_rootmnt = current->fs->rootmnt; } #endif orig_root = current->fs->root; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0) read_unlock(&current->fs->lock); #endif /* do a file syncronization on all devices (IMPORTANT!) and replace system calls */ #ifdef __SMP__ lock_kernel(); #endif fsync_dev(0); #if defined(ON_OPEN_SUPPORT) DAZUKO_HOOK(open); DAZUKO_HOOK(dup); #endif #if defined(ON_OPEN_SUPPORT) || defined(ON_CLOSE_SUPPORT) || defined(ON_CLOSE_MODIFIED_SUPPORT) DAZUKO_HOOK(dup2); #endif #if defined(ON_CLOSE_SUPPORT) || defined(ON_CLOSE_MODIFIED_SUPPORT) DAZUKO_HOOK(close); #endif #ifdef ON_EXEC_SUPPORT DAZUKO_HOOK(execve); #endif #ifdef ON_UNLINK_SUPPORT DAZUKO_HOOK(unlink); #endif #ifdef ON_RMDIR_SUPPORT DAZUKO_HOOK(rmdir); #endif #ifdef __SMP__ unlock_kernel(); #endif /* done syncing and replacing */ /* initialization complete */ return 0; }

int xp_sys_unhook (  void   )  [inline]

Definition at line 1732 of file dazuko_linux.c. References DAZUKO_UNHOOK, dev_major, DEVICE_NAME, NULL, and xp_print(). { /* Called by rmmod when removing the module. */ int error; /* do a file syncronization on all devices (IMPORTANT!) and replace system calls */ #ifdef __SMP__ lock_kernel(); #endif fsync_dev(0); #if defined(ON_OPEN_SUPPORT) DAZUKO_UNHOOK(open); DAZUKO_UNHOOK(dup); #endif #if defined(ON_OPEN_SUPPORT) || defined(ON_CLOSE_SUPPORT) || defined(ON_CLOSE_MODIFIED_SUPPORT) DAZUKO_UNHOOK(dup2); #endif #if defined(ON_CLOSE_SUPPORT) || defined(ON_CLOSE_MODIFIED_SUPPORT) DAZUKO_UNHOOK(close); #endif #ifdef ON_EXEC_SUPPORT DAZUKO_UNHOOK(execve); #endif #ifdef ON_UNLINK_SUPPORT DAZUKO_UNHOOK(unlink); #endif #ifdef ON_RMDIR_SUPPORT DAZUKO_UNHOOK(rmdir); #endif #ifdef __SMP__ unlock_kernel(); #endif /* done syncing and replacing */ #ifdef DEVFS_SUPPORT 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 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 158 of file dazuko_linux.c. References xp_mutex::mutex. { up(&(mutex->mutex)); }

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

Definition at line 277 of file dazuko_linux.c. { #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0) return verify_area(VERIFY_READ, user_ptr, size); #else return 0; #endif }

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

Definition at line 268 of file dazuko_linux.c. { #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0) return verify_area(VERIFY_WRITE, user_ptr, size); #else return 0; #endif }

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

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

void xp_write_lock (  struct xp_rwlock *  rwlock  )  [inline]

Definition at line 179 of file dazuko_linux.c. References xp_rwlock::rwlock. { write_lock(&(rwlock->rwlock)); }

void xp_write_unlock (  struct xp_rwlock *  rwlock  )  [inline]

Definition at line 184 of file dazuko_linux.c. References xp_rwlock::rwlock. { write_unlock(&(rwlock->rwlock)); }

---

Variable Documentation

struct xp_atomic active

int dev_major = -1 [static]

Definition at line 63 of file dazuko_linux.c.

struct file_operations fops [static]

Initial value: { read: linux_dazuko_device_read, write: linux_dazuko_device_write, ioctl: linux_dazuko_device_ioctl, open: linux_dazuko_device_open, release: linux_dazuko_device_release, } Definition at line 85 of file dazuko_linux.c.

struct dentry* orig_root = NULL [static]

Definition at line 62 of file dazuko_linux.c. Referenced by dazuko_get_full_filename(), and xp_sys_hook().

void* sys_call_table[]

Referenced by xp_sys_hook().

---