/***
 *
 *  stack/rtnet_chrdev.c - implements char device for management interface
 *
 *  Copyright (C) 1999       Lineo, Inc
 *                1999, 2002 David A. Schleef <ds@schleef.org>
 *                2002       Ulrich Marx <marx@fet.uni-hannover.de>
 *                2003-2005  Jan Kiszka <jan.kiszka@web.de>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of version 2 of the GNU General Public License 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 License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/if_arp.h>
#include <linux/kmod.h>
#include <linux/miscdevice.h>
#include <linux/netdevice.h>
#include <linux/spinlock.h>

#include <rtnet_chrdev.h>
#include <rtnet_internal.h>
#include <ipv4/route.h>

static DEFINE_SPINLOCK(ioctl_handler_lock);
static LIST_HEAD(ioctl_handlers);

static long rtnet_ioctl(struct file *file, unsigned int request,
			unsigned long arg)
{
	struct rtnet_ioctl_head head;
	struct rtnet_device *rtdev = NULL;
	struct rtnet_ioctls *ioctls;
	struct list_head *entry;
	int ret;

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

	ret = copy_from_user(&head, (void *)arg, sizeof(head));
	if (ret != 0)
		return -EFAULT;

	spin_lock(&ioctl_handler_lock);

	list_for_each (entry, &ioctl_handlers) {
		ioctls = list_entry(entry, struct rtnet_ioctls, entry);

		if (ioctls->ioctl_type == _IOC_TYPE(request)) {
			atomic_inc(&ioctls->ref_count);

			spin_unlock(&ioctl_handler_lock);

			if ((_IOC_NR(request) & RTNET_IOC_NODEV_PARAM) == 0) {
				rtdev = rtdev_get_by_name(head.if_name);
				if (!rtdev) {
					atomic_dec(&ioctls->ref_count);
					return -ENODEV;
				}
			}

			ret = ioctls->handler(rtdev, request, arg);

			if (rtdev)
				rtdev_dereference(rtdev);
			atomic_dec(&ioctls->ref_count);

			return ret;
		}
	}

	spin_unlock(&ioctl_handler_lock);

	return -ENOTTY;
}

static int rtnet_core_ioctl(struct rtnet_device *rtdev, unsigned int request,
			    unsigned long arg)
{
	struct rtnet_core_cmd cmd;
	int ret;

	ret = copy_from_user(&cmd, (void *)arg, sizeof(cmd));
	if (ret != 0)
		return -EFAULT;

	switch (request) {
	case IOC_RT_IFUP:
		ret = rtdev_up(rtdev, &cmd);
		break;

	case IOC_RT_IFDOWN:
		ret = rtdev_down(rtdev);
		break;

	case IOC_RT_IFINFO:
		if (cmd.args.info.ifindex > 0)
			rtdev = rtdev_get_by_index(cmd.args.info.ifindex);
		else
			rtdev = rtdev_get_by_name(cmd.head.if_name);
		if (rtdev == NULL)
			return -ENODEV;

		if (mutex_lock_interruptible(&rtdev->nrt_lock)) {
			rtdev_dereference(rtdev);
			return -ERESTARTSYS;
		}

		memcpy(cmd.head.if_name, rtdev->name, IFNAMSIZ);
		cmd.args.info.ifindex = rtdev->ifindex;
		cmd.args.info.type = rtdev->type;
		cmd.args.info.ip_addr = rtdev->local_ip;
		cmd.args.info.broadcast_ip = rtdev->broadcast_ip;
		cmd.args.info.mtu = rtdev->mtu;
		cmd.args.info.flags = rtdev->flags;
		if ((cmd.args.info.flags & IFF_UP) &&
		    (rtdev->link_state &
		     (RTNET_LINK_STATE_PRESENT | RTNET_LINK_STATE_NOCARRIER)) ==
			    RTNET_LINK_STATE_PRESENT)
			cmd.args.info.flags |= IFF_RUNNING;

		memcpy(cmd.args.info.dev_addr, rtdev->dev_addr, MAX_ADDR_LEN);

		mutex_unlock(&rtdev->nrt_lock);

		rtdev_dereference(rtdev);

		if (copy_to_user((void *)arg, &cmd, sizeof(cmd)) != 0)
			return -EFAULT;
		break;

	default:
		ret = -ENOTTY;
	}

	return ret;
}

int rtnet_register_ioctls(struct rtnet_ioctls *ioctls)
{
	struct list_head *entry;
	struct rtnet_ioctls *registered_ioctls;

	RTNET_ASSERT(ioctls->handler != NULL, return -EINVAL;);

	spin_lock(&ioctl_handler_lock);

	list_for_each (entry, &ioctl_handlers) {
		registered_ioctls =
			list_entry(entry, struct rtnet_ioctls, entry);
		if (registered_ioctls->ioctl_type == ioctls->ioctl_type) {
			spin_unlock(&ioctl_handler_lock);
			return -EEXIST;
		}
	}

	list_add_tail(&ioctls->entry, &ioctl_handlers);
	atomic_set(&ioctls->ref_count, 0);

	spin_unlock(&ioctl_handler_lock);

	return 0;
}

void rtnet_unregister_ioctls(struct rtnet_ioctls *ioctls)
{
	spin_lock(&ioctl_handler_lock);

	while (atomic_read(&ioctls->ref_count) != 0) {
		spin_unlock(&ioctl_handler_lock);

		set_current_state(TASK_UNINTERRUPTIBLE);
		schedule_timeout(1 * HZ); /* wait a second */

		spin_lock(&ioctl_handler_lock);
	}

	list_del(&ioctls->entry);

	spin_unlock(&ioctl_handler_lock);
}

static struct file_operations rtnet_fops = {
	.owner = THIS_MODULE,
	.unlocked_ioctl = rtnet_ioctl,
	.compat_ioctl = rtnet_ioctl,
};

static struct miscdevice rtnet_chr_misc_dev = {
	.minor = RTNET_MINOR,
	.name = "rtnet",
	.fops = &rtnet_fops,
};

static struct rtnet_ioctls core_ioctls = { .service_name = "RTnet Core",
					   .ioctl_type = RTNET_IOC_TYPE_CORE,
					   .handler = rtnet_core_ioctl };

/**
 * rtnet_chrdev_init -
 *
 */
int __init rtnet_chrdev_init(void)
{
	int err;

	err = misc_register(&rtnet_chr_misc_dev);
	if (err) {
		printk("RTnet: unable to register rtnet management device/class "
		       "(error %d)\n",
		       err);
		return err;
	}

	rtnet_register_ioctls(&core_ioctls);
	return 0;
}

/**
 * rtnet_chrdev_release -
 *
 */
void rtnet_chrdev_release(void)
{
	misc_deregister(&rtnet_chr_misc_dev);
}

EXPORT_SYMBOL_GPL(rtnet_register_ioctls);
EXPORT_SYMBOL_GPL(rtnet_unregister_ioctls);