/*
 * fastd.c - driver for the "Fast and Secure Tunneling Daemon"
 *
 * Copyright (c) 2012-2013, Matthias Schiffer <mschiffer@universe-factory.net>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * Alternatively, provided that this notice is retained in full, this
 * software may be distributed under the terms of the GNU General
 * Public License ("GPL") version 2, in which case the provisions of the
 * GPL apply INSTEAD OF those given above.
 *
 * The provided data structures and external interfaces from this code
 * are not restricted to be used by modules with a GPL compatible license.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 */


#define DRV_NAME	"fastd"
#define DRV_VERSION	"0.1"
#define DRV_DESCRIPTION	"fastd tunnel driver"
#define DRV_COPYRIGHT \
	"(C) 2013 Matthias Schiffer <mschiffer@universe-factory.net>"


#include <linux/module.h>
#include <linux/etherdevice.h>
#include <linux/ethtool.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/ip.h>
#include <linux/ipv6.h>
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <linux/rculist.h>
#include <net/genetlink.h>
#include <net/net_namespace.h>
#include <net/route.h>

#include "fastd.h"


#define FASTD_HEADROOM \
	(ETH_HLEN + sizeof(struct ipv6hdr) + sizeof(struct udphdr) + 24)

#define FASTD_DEFAULT_MTU 1500
#define FASTD_MIN_MTU 68


static LIST_HEAD(fastd_list);
static struct workqueue_struct *fastd_workqueue;


struct fastd_struct {
	struct list_head	list;

	struct net_device	*dev;

	struct net		*net;
	u32			owner;

	u16			mode;
	unsigned long		flags;

	struct work_struct	destroy_work;
};


static struct genl_family fastd_nl_family = {
	.id		= GENL_ID_GENERATE,
	.hdrsize	= 0,
	.name		= DRV_NAME,
	.version	= 1,
	.maxattr	= FASTD_A_MAX,
	.netnsok	= true,
	.parallel_ops	= true,
};


static int fastd_nl_event(struct notifier_block *nb,
			  unsigned long event, void *ptr)
{
	struct netlink_notify *n = ptr;
	struct fastd_struct *entry;

	if (event != NETLINK_URELEASE || n->protocol != NETLINK_GENERIC)
		return NOTIFY_DONE;

	rcu_read_lock();

	list_for_each_entry_rcu(entry, &fastd_list, list) {
		if (net_eq(entry->net, n->net) && entry->owner == n->portid) {
			entry->owner = 0;

			queue_work(fastd_workqueue, &entry->destroy_work);
		}
	}

	rcu_read_unlock();

	return NOTIFY_DONE;
}

static struct notifier_block nl_notifier = {
	.notifier_call  = fastd_nl_event,
};


static const struct net_device_ops fastd_netdev_ops_eth = {
};

static const struct net_device_ops fastd_netdev_ops_ip = {
};


static void fastd_ethtool_get_drvinfo(struct net_device *dev,
				      struct ethtool_drvinfo *info)
{
	struct fastd_struct *fastd = netdev_priv(dev);

	strcpy(info->driver, DRV_NAME);
	strcpy(info->version, DRV_VERSION);
	strcpy(info->fw_version, "N/A");

	switch (fastd->mode) {
	case FASTD_MODE_ETH:
		strcpy(info->bus_info, "ethernet");
		break;
	case FASTD_MODE_IP:
		strcpy(info->bus_info, "ip");
	}
}

static u32 fastd_ethtool_get_link(struct net_device *dev)
{
	return 1;
}


static const struct ethtool_ops fastd_ethtool_ops = {
	.get_drvinfo	= fastd_ethtool_get_drvinfo,
	.get_link	= fastd_ethtool_get_link,
};


static void fastd_netdev_free(struct net_device *dev) {
	struct fastd_struct *fastd = netdev_priv(dev);

	put_net(fastd->net);
	free_netdev(dev);

	module_put(THIS_MODULE);
}

static void fastd_netdev_setup(struct net_device *dev)
{
	dev->ethtool_ops = &fastd_ethtool_ops;
	dev->destructor = fastd_netdev_free;
}

static void fastd_netdev_init(struct net_device *dev)
{
	struct fastd_struct *fastd = netdev_priv(dev);

	switch (fastd->mode) {
	case FASTD_MODE_ETH:
		dev->netdev_ops = &fastd_netdev_ops_eth;

		eth_hw_addr_random(dev);
		ether_setup(dev);

		dev->hard_header_len = FASTD_HEADROOM + ETH_HLEN;

		break;

	case FASTD_MODE_IP:
		dev->netdev_ops = &fastd_netdev_ops_eth;

		dev->addr_len = 0;
		dev->hard_header_len = FASTD_HEADROOM;

		dev->type = ARPHRD_NONE;
		dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
	}
}

static void fastd_destroy_work(struct work_struct *work)
{
	struct fastd_struct *fastd = container_of(work, struct fastd_struct,
						  destroy_work);

	rtnl_lock();

	list_del_rcu(&fastd->list);
	unregister_netdevice(fastd->dev);

	rtnl_unlock();
}

static int fastd_cmd_create(struct sk_buff *skb, struct genl_info *info)
{
	struct net *net = genl_info_net(info);
	struct net_device *dev;
	struct fastd_struct *fastd;
	u16 mode;
	u16 mtu = FASTD_DEFAULT_MTU;
	const char *name = "fastd%d";
	int err;

	if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
		return -EPERM;

	if (!info->attrs[FASTD_A_MODE])
		return -EINVAL;

	mode = nla_get_u16(info->attrs[FASTD_A_MODE]);
	if (mode != FASTD_MODE_ETH && mode != FASTD_MODE_IP)
		return -EINVAL;

	if (info->attrs[FASTD_A_MTU])
		mtu = nla_get_u16(info->attrs[FASTD_A_MTU]);

	if (mtu < FASTD_MIN_MTU)
		return -EINVAL;


	if (info->attrs[FASTD_A_IFNAME])
		name = nla_data(info->attrs[FASTD_A_IFNAME]);

	if (!try_module_get(THIS_MODULE))
		return -ENOENT;

	dev = alloc_netdev(sizeof(struct fastd_struct), name,
			   fastd_netdev_setup);
	if (!dev) {
		err = -ENOMEM;
		goto err_module_put;
	}

	dev_net_set(dev, net);

	fastd = netdev_priv(dev);
	fastd->dev = dev;
	fastd->net = get_net(net);
	fastd->owner = info->snd_portid;
	fastd->mode = mode;
	INIT_WORK(&fastd->destroy_work, fastd_destroy_work);

	fastd_netdev_init(dev);
	dev->mtu = mtu;

	rtnl_lock();
	err = register_netdevice(dev);
	if (err < 0) {
		rtnl_unlock();
		goto err_free_dev;
	}

	list_add_tail_rcu(&fastd->list, &fastd_list);

	rtnl_unlock();

	return 0;

err_free_dev:
	free_netdev(dev);

err_module_put:
	module_put(THIS_MODULE);

	return err;
}


static struct nla_policy fastd_nl_policy[__FASTD_A_MAX] = {
	[FASTD_A_IFNAME]	= { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
	[FASTD_A_MODE]		= { .type = NLA_U16 },
	[FASTD_A_MTU]		= { .type = NLA_U16 },
};

static struct genl_ops fastd_nl_ops[] = {
	{
		.cmd = FASTD_CMD_CREATE,
		.doit = fastd_cmd_create,
		.policy = fastd_nl_policy,
	},
};


static int __init fastd_init(void)
{
	int ret = 0;

	fastd_workqueue = alloc_workqueue("fastd", 0, 0);
	if (!fastd_workqueue)
		return -ENOMEM;

	netlink_register_notifier(&nl_notifier);

	ret = genl_register_family_with_ops(&fastd_nl_family, fastd_nl_ops,
					    ARRAY_SIZE(fastd_nl_ops));
	if (ret)
		goto unregister_notifier;

	pr_info("%s %s\n", DRV_DESCRIPTION, DRV_VERSION);

	return 0;

unregister_notifier:
	netlink_unregister_notifier(&nl_notifier);
	destroy_workqueue(fastd_workqueue);

	return ret;
}

static void fastd_cleanup(void)
{
	genl_unregister_family(&fastd_nl_family);
	netlink_unregister_notifier(&nl_notifier);
	destroy_workqueue(fastd_workqueue);
}


module_init(fastd_init);
module_exit(fastd_cleanup);
MODULE_DESCRIPTION(DRV_DESCRIPTION);
MODULE_AUTHOR(DRV_COPYRIGHT);
MODULE_LICENSE("Dual BSD/GPL");
MODULE_ALIAS_GENL_FAMILY(DRV_NAME);