Admin Control Panel v2.0

✎ Editing: interface.c ← Back

/*
 * This source file is a part of a Kaspersky Antivirus Monitor.
 * Copyright (C) Kaspersky Lab, 1997-2010
 * See License.txt for details
 *
 */

#include "module.h"

/* monitor proc functions */
static int monitor_proc_open(struct inode* inode, struct file* filp);
static ssize_t monitor_proc_read(struct file* file, char __user *ubuf, size_t len,
                                 loff_t* offset);
#ifndef USE_REDIRFS
static int monitor_proc_ioctl(struct inode* inode, struct file* file,
                              unsigned int cmd, unsigned long arg);
#else
static long monitor_proc_ioctl(struct file* file, unsigned int cmd,
                               unsigned long arg);
#endif
static ssize_t monitor_proc_write(struct file* file, const char __user *ubuf, size_t len,
                                  loff_t* offset);

static struct file_operations kavmon_proc_operations = {
    .owner = THIS_MODULE,
    .open = monitor_proc_open,
    .read = monitor_proc_read,
    .write = monitor_proc_write,
#ifndef USE_REDIRFS
    .ioctl = monitor_proc_ioctl,
#else
    .unlocked_ioctl = monitor_proc_ioctl,
    .compat_ioctl = monitor_proc_ioctl,
#endif
    .llseek = generic_file_llseek,
};

static char* monitor_info;
static int monitor_major, compat_major;

int Monitor_interface_init(void)
{
    struct proc_dir_entry* proc_entry;
    struct proc_dir_entry* use_proc_root = NULL;

#if defined(CONFIG_X86_64) && (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11))
    int error;

error = register_ioctl32_conversion(MONITOR_REGISTER_CMD_COMPAT,
                                        monitor_ioctl32_old);
    if (error)
        return -EFAULT;

error =
        register_ioctl32_conversion(MONITOR_GROUP_CMD_COMPAT, monitor_ioctl32_old);
    if (error)
    {
        unregister_ioctl32_conversion(MONITOR_REGISTER_CMD_COMPAT);
        return -EFAULT;
    }
#endif

if (Monitor_module_init())
    {
#if defined(CONFIG_X86_64) && (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11))
        unregister_ioctl32_conversion(MONITOR_REGISTER_CMD_COMPAT);
        unregister_ioctl32_conversion(MONITOR_GROUP_CMD_COMPAT);
#endif
        printk("Failed to initialize Monitor_module_init()\n");
        return -ENOENT;
    }

monitor_info = MEM_ALLOC(PAGE_SIZE);
    if (!monitor_info)
        return -ENOMEM;

Monitor_queue_init();
    check_req_queue_init();

/* register the avir monitor device */
    monitor_major = register_chrdev(0, "kav4fs_oas", &kavdaemon_file_operations);
    register_chrdev(monitor_major, "kav4fs_oas", &kavdaemon_file_operations);

// register also "kavmonitor" for compatibility with old products
    compat_major = register_chrdev(0, "kavmonitor", &kavmonitor_file_operations);

#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26))
    use_proc_root = &proc_root;
#endif

#if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 10, 0))
    proc_entry = create_proc_entry(KAVMON_PROC, 0644, use_proc_root);
    if (proc_entry)
        proc_entry->proc_fops = &kavmon_proc_operations;
#else
    proc_entry =
        proc_create(KAVMON_PROC, 0644, use_proc_root, &kavmon_proc_operations);
#endif

if (!proc_entry || monitor_major < 0 || compat_major < 0)
    {
        if (monitor_major > 0)
            unregister_chrdev(monitor_major, "kav4fs_oas");
        if (compat_major > 0)
            unregister_chrdev(compat_major, "kavmonitor");
        MEM_FREE(monitor_info);
        return -ENOENT;
    }

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 3, 27) &&                              \
     LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 30))
    proc_entry->owner = THIS_MODULE;
#endif

return 0;
};

int Monitor_interface_cleanup(void)
{

#if defined(CONFIG_X86_64) && (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11))
    unregister_ioctl32_conversion(MONITOR_REGISTER_CMD_COMPAT);
    unregister_ioctl32_conversion(MONITOR_GROUP_CMD_COMPAT);
#endif

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26))
    remove_proc_entry(KAVMON_PROC, NULL);
#else
    remove_proc_entry(KAVMON_PROC, &proc_root);
#endif
    unregister_chrdev(monitor_major, "kav4fs_oas");
    unregister_chrdev(compat_major, "kavmonitor");
    MEM_FREE(monitor_info);
    Monitor_module_cleanup();

return 0;
}

static int monitor_proc_open(struct inode* inode, struct file* filp)
{
    sprintf(monitor_info, "%d \n%d %d %d\n%d %d\n", FS_PROTOCOL_VERSION,
            monitor_major, 0, atomic_read(&monitor_started), compat_major, 0);

return 0;
}

/*	version
 *	(kavmonitor) major connected(1/0)
 *	(kavexploit) major connected(1/0)
 *
 */

static ssize_t monitor_proc_read(struct file* file, char __user *ubuf, size_t len, loff_t* offset)
{
    int count, info_len;

info_len = strlen(monitor_info);

if (*offset > info_len)
        return 0;

if (len < info_len - file->f_pos)
        count = len;
    else
        count = info_len - file->f_pos;

if (copy_to_user(ubuf, monitor_info + file->f_pos, count))
        return -EFAULT;
    file->f_pos += count;

*offset += count;

return count;
}

#ifndef USE_REDIRFS
static int monitor_proc_ioctl(struct inode* inode, struct file* file,
                              unsigned int cmd, unsigned long arg)
{
    return 0;
}

static ssize_t monitor_proc_write(struct file* file, const char* ubuf, size_t len,
                                  loff_t* offset)
{
    return (*offset = len);
}

#else
#define PREFIX_LEN 4

int interceptor_get_path(char const* mnt);
int interceptor_put_path(char const* mnt);
int interceptor_in_trace(char const* bin);
int interceptor_de_trace(char const* bin);
int interceptor_rs_trace(char const* bin);

struct user_command
{
    char const* prefix;
    int (*invoke)(char const* arg);
};

static struct user_command user_commands[] = {
    {"put ", interceptor_put_path}, {"get ", interceptor_get_path},
    {"itr ", interceptor_in_trace}, {"dtr ", interceptor_de_trace},
    {"rtr ", interceptor_rs_trace},
};

static ssize_t monitor_proc_write(struct file* file, const char __user *ubuf, size_t len,
                                  loff_t* offset)
{
    int res = -EIO;
    char prefix[PREFIX_LEN];
    char* mpath;
    int i, action = -1;

if (*offset || len < PREFIX_LEN)
        return -EIO;

if (copy_from_user(prefix, ubuf, PREFIX_LEN))
        return -EIO;

for (i = 0; i < ARRAY_SIZE(user_commands); i++)
        if (!strncmp(prefix, user_commands[i].prefix, PREFIX_LEN))
        {
            action = i;
            break;
        }
    if (-1 == action)
        return -ENOSYS;

mpath = (len - PREFIX_LEN) ? MEM_ALLOC(len - PREFIX_LEN) : NULL;
    if (!mpath)
        return -ENOMEM;

if (copy_from_user(mpath, ubuf + PREFIX_LEN, len - PREFIX_LEN))
        goto pwout;

if (mpath[len - PREFIX_LEN - 1] != '\n')
        goto pwout;

mpath[len - PREFIX_LEN - 1] = '\0';

res = user_commands[action].invoke(mpath);
pwout:
    MEM_FREE(mpath);
    return res ? res : (*offset = len);
}

static long monitor_proc_ioctl(struct file* file, unsigned int cmd,
                               unsigned long arg)
{
    return 0;
}
#endif

Cancel