/*
 * Copyright 2004 Peter M. Jones <pjones@redhat.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public Licens
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-
 *
 */

#include <linux/list.h>
#include <linux/genhd.h>
#include <linux/spinlock.h>
#include <linux/capability.h>
#include <linux/bitops.h>
#include <linux/blkdev.h>

#include <scsi/scsi.h>
#include <linux/cdrom.h>

int blk_verify_command(struct blk_cmd_filter *filter,
                       unsigned char *cmd, fmode_t has_write_perm)
{
        /* root can do any command. */
        if (capable(CAP_SYS_RAWIO))
                return 0;

        /* if there's no filter set, assume we're filtering everything out */
        if (!filter)
                return -EPERM;

        /* Anybody who can open the device can do a read-safe command */
        if (test_bit(cmd[0], filter->read_ok))
                return 0;

        /* Write-safe commands require a writable open */
        if (test_bit(cmd[0], filter->write_ok) && has_write_perm)
                return 0;

        return -EPERM;
}
EXPORT_SYMBOL(blk_verify_command);

#if 0
/* and now, the sysfs stuff */
static ssize_t rcf_cmds_show(struct blk_cmd_filter *filter, char *page,
                             int rw)
{
        char *npage = page;
        unsigned long *okbits;
        int i;

        if (rw == READ)
                okbits = filter->read_ok;
        else
                okbits = filter->write_ok;

        for (i = 0; i < BLK_SCSI_MAX_CMDS; i++) {
                if (test_bit(i, okbits)) {
                        npage += sprintf(npage, "0x%02x", i);
                        if (i < BLK_SCSI_MAX_CMDS - 1)
                                sprintf(npage++, " ");
                }
        }

        if (npage != page)
                npage += sprintf(npage, "\n");

        return npage - page;
}

static ssize_t rcf_readcmds_show(struct blk_cmd_filter *filter, char *page)
{
        return rcf_cmds_show(filter, page, READ);
}

static ssize_t rcf_writecmds_show(struct blk_cmd_filter *filter,
                                 char *page)
{
        return rcf_cmds_show(filter, page, WRITE);
}

static ssize_t rcf_cmds_store(struct blk_cmd_filter *filter,
                              const char *page, size_t count, int rw)
{
        unsigned long okbits[BLK_SCSI_CMD_PER_LONG], *target_okbits;
        int cmd, set;
        char *p, *status;

        if (rw == READ) {
                memcpy(&okbits, filter->read_ok, sizeof(okbits));
                target_okbits = filter->read_ok;
        } else {
                memcpy(&okbits, filter->write_ok, sizeof(okbits));
                target_okbits = filter->write_ok;
        }

        while ((p = strsep((char **)&page, " ")) != NULL) {
                set = 1;

                if (p[0] == '+') {
                        p++;
                } else if (p[0] == '-') {
                        set = 0;
                        p++;
                }

                cmd = simple_strtol(p, &status, 16);

                /* either of these cases means invalid input, so do nothing. */
                if ((status == p) || cmd >= BLK_SCSI_MAX_CMDS)
                        return -EINVAL;

                if (set)
                        __set_bit(cmd, okbits);
                else
                        __clear_bit(cmd, okbits);
        }

        memcpy(target_okbits, okbits, sizeof(okbits));
        return count;
}

static ssize_t rcf_readcmds_store(struct blk_cmd_filter *filter,
                                  const char *page, size_t count)
{
        return rcf_cmds_store(filter, page, count, READ);
}

static ssize_t rcf_writecmds_store(struct blk_cmd_filter *filter,
                                   const char *page, size_t count)
{
        return rcf_cmds_store(filter, page, count, WRITE);
}

struct rcf_sysfs_entry {
        struct attribute attr;
        ssize_t (*show)(struct blk_cmd_filter *, char *);
        ssize_t (*store)(struct blk_cmd_filter *, const char *, size_t);
};

static struct rcf_sysfs_entry rcf_readcmds_entry = {
        .attr = { .name = "read_table", .mode = S_IRUGO | S_IWUSR },
        .show = rcf_readcmds_show,
        .store = rcf_readcmds_store,
};

static struct rcf_sysfs_entry rcf_writecmds_entry = {
        .attr = {.name = "write_table", .mode = S_IRUGO | S_IWUSR },
        .show = rcf_writecmds_show,
        .store = rcf_writecmds_store,
};

static struct attribute *default_attrs[] = {
        &rcf_readcmds_entry.attr,
        &rcf_writecmds_entry.attr,
        NULL,
};

#define to_rcf(atr) container_of((atr), struct rcf_sysfs_entry, attr)

static ssize_t
rcf_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
{
        struct rcf_sysfs_entry *entry = to_rcf(attr);
        struct blk_cmd_filter *filter;

        filter = container_of(kobj, struct blk_cmd_filter, kobj);
        if (entry->show)
                return entry->show(filter, page);

        return 0;
}

static ssize_t
rcf_attr_store(struct kobject *kobj, struct attribute *attr,
                        const char *page, size_t length)
{
        struct rcf_sysfs_entry *entry = to_rcf(attr);
        struct blk_cmd_filter *filter;

        if (!capable(CAP_SYS_RAWIO))
                return -EPERM;

        if (!entry->store)
                return -EINVAL;

        filter = container_of(kobj, struct blk_cmd_filter, kobj);
        return entry->store(filter, page, length);
}

static struct sysfs_ops rcf_sysfs_ops = {
        .show = rcf_attr_show,
        .store = rcf_attr_store,
};

static struct kobj_type rcf_ktype = {
        .sysfs_ops = &rcf_sysfs_ops,
        .default_attrs = default_attrs,
};

int blk_register_filter(struct gendisk *disk)
{
        int ret;
        struct blk_cmd_filter *filter = &disk->queue->cmd_filter;

        ret = kobject_init_and_add(&filter->kobj, &rcf_ktype,
                                   &disk_to_dev(disk)->kobj,
                                   "%s", "cmd_filter");
        if (ret < 0)
                return ret;

        return 0;
}
EXPORT_SYMBOL(blk_register_filter);

void blk_unregister_filter(struct gendisk *disk)
{
        struct blk_cmd_filter *filter = &disk->queue->cmd_filter;

        kobject_put(&filter->kobj);
}
EXPORT_SYMBOL(blk_unregister_filter);
#endif