/*
 *  linux/drivers/net/netbomb.c
 *
 *  Based on linux/drivers/net/netconsole.c,
 *  adapted by Bruno Prémont <bonbons@linux-vserver.org>
 */

/****************************************************************
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License as published by
 *      the Free Software Foundation; either version 2, or (at your option)
 *      any later version.
 *
 *      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., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 ****************************************************************/

#include <linux/mm.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/console.h>
#include <linux/moduleparam.h>
#include <linux/string.h>
#include <linux/netpoll.h>
#include <linux/inet.h>
#include <linux/seq_file.h>
#include <linux/configfs.h>

MODULE_AUTHOR("Maintainer: Bruno Premont <bruno.premont@restena.lu>");
MODULE_DESCRIPTION("Network traffic generator");
MODULE_LICENSE("GPL");

#define MAX_PARAM_LENGTH	256
#define MAX_PRINT_CHUNK		1000

static char config[MAX_PARAM_LENGTH];
module_param_string(netbomb, config, MAX_PARAM_LENGTH, 0);
MODULE_PARM_DESC(netbomb, " netbomb=[src-port]@[src-ip]/[dev],[tgt-port]@<tgt-ip>/[tgt-macaddr]");

#ifndef	MODULE
static int __init option_setup(char *opt)
{
	strlcpy(config, opt, MAX_PARAM_LENGTH);
	return 1;
}
__setup("netbomb=", option_setup);
#endif	/* MODULE */

/* Linked list of all configured targets */
static LIST_HEAD(target_list);

/* This needs to be a spinlock because write_msg() cannot sleep */
static DEFINE_SPINLOCK(target_list_lock);

/**
 * struct netbomb_target - Represents a configured netbomb target.
 * @list:	Links this target into the target_list.
 * @item:	Links us into the configfs subsystem hierarchy.
 * @enabled:	On / off knob to enable / disable target.
 *		Visible from userspace (read-write).
 *		We maintain a strict 1:1 correspondence between this and
 *		whether the corresponding netpoll is active or inactive.
 *		Also, other parameters of a target may be modified at
 *		runtime only when it is disabled (enabled == 0).
 * @np:		The netpoll structure for this target.
 *		Contains the other userspace visible parameters:
 *		dev_name	(read-write)
 *		local_port	(read-write)
 *		remote_port	(read-write)
 *		local_ip	(read-write)
 *		remote_ip	(read-write)
 *		local_mac	(read-only)
 *		remote_mac	(read-write)
 */
struct netbomb_target {
	struct list_head	list;
	int			enabled;
	struct netpoll		np;
};

/*
 * No danger of targets going away from under us when dynamic
 * reconfigurability is off.
 */
static void netbomb_target_get(struct netbomb_target *nt)
{
}

static void netbomb_target_put(struct netbomb_target *nt)
{
}

/* Allocate new target (from boot/module param) and setup netpoll for it */
static struct netbomb_target *alloc_param_target(char *target_config)
{
	int err = -ENOMEM;
	struct netbomb_target *nt;

	/*
	 * Allocate and initialize with defaults.
	 * Note that these targets get their config_item fields zeroed-out.
	 */
	nt = kzalloc(sizeof(*nt), GFP_KERNEL);
	if (!nt) {
		printk(KERN_ERR "netbomb: failed to allocate memory\n");
		goto fail;
	}

	nt->np.name = "netbomb";
	strlcpy(nt->np.dev_name, "eth0", IFNAMSIZ);
	nt->np.local_port = 6665;
	nt->np.remote_port = 6666;
	memset(nt->np.remote_mac, 0xff, ETH_ALEN);

	/* Parse parameters and setup netpoll */
	err = netpoll_parse_options(&nt->np, target_config);
	if (err)
		goto fail;

	err = netpoll_setup(&nt->np);
	if (err)
		goto fail;

	nt->enabled = 1;

	return nt;

fail:
	kfree(nt);
	return ERR_PTR(err);
}

/* Cleanup netpoll for given target (from boot/module param) and free it */
static void free_param_target(struct netbomb_target *nt)
{
	netpoll_cleanup(&nt->np);
	kfree(nt);
}

/* Handle network interface device notifications */
static int netbomb_netdev_event(struct notifier_block *this,
				   unsigned long event,
				   void *ptr)
{
	unsigned long flags;
	struct netbomb_target *nt;
	struct net_device *dev = ptr;

	if (!(event == NETDEV_CHANGENAME || event == NETDEV_UNREGISTER))
		goto done;

	spin_lock_irqsave(&target_list_lock, flags);
	list_for_each_entry(nt, &target_list, list) {
		netbomb_target_get(nt);
		if (nt->np.dev == dev) {
			switch (event) {
			case NETDEV_CHANGENAME:
				strlcpy(nt->np.dev_name, dev->name, IFNAMSIZ);
				break;
			case NETDEV_UNREGISTER:
				if (!nt->enabled)
					break;
				netpoll_cleanup(&nt->np);
				nt->enabled = 0;
				printk(KERN_INFO "netbomb: network logging stopped"
					", interface %s unregistered\n",
					dev->name);
				break;
			}
		}
		netbomb_target_put(nt);
	}
	spin_unlock_irqrestore(&target_list_lock, flags);

done:
	return NOTIFY_DONE;
}

static struct notifier_block netbomb_netdev_notifier = {
	.notifier_call  = netbomb_netdev_event,
};

static void write_msg(struct console *con, const char *msg, unsigned int len)
{
	int frag, left;
	unsigned long flags;
	struct netbomb_target *nt;
	const char *tmp;

	/* Avoid taking lock and disabling interrupts unnecessarily */
	if (list_empty(&target_list))
		return;

	spin_lock_irqsave(&target_list_lock, flags);
	list_for_each_entry(nt, &target_list, list) {
		netbomb_target_get(nt);
		if (nt->enabled && netif_running(nt->np.dev)) {
			/*
			 * We nest this inside the for-each-target loop above
			 * so that we're able to get as much logging out to
			 * at least one target if we die inside here, instead
			 * of unnecessarily keeping all targets in lock-step.
			 */
			tmp = msg;
			for (left = len; left;) {
				frag = min(left, MAX_PRINT_CHUNK);
				netpoll_send_udp(&nt->np, tmp, frag);
				tmp += frag;
				left -= frag;
			}
		}
		netbomb_target_put(nt);
	}
	spin_unlock_irqrestore(&target_list_lock, flags);
}

static struct console netbomb = {
	.name	= "netcon",
	.flags	= CON_ENABLED,
	.write	= write_msg,
};

static int netbomb_show(struct seq_file *m, void *v)
{
	seq_printf(m, "Array of bytes indicating packet lengths\n");
	return 0;
}

static int netbomb_open(struct inode *inode, struct file *file)
{
	return single_open(file, netbomb_show, NULL);
}

static const char * bufs[256];

static ssize_t netbomb_write(struct file *file,
        const char __user *buffer, size_t count, loff_t *pos)
{
	int i;

	for (i = 0; i < count; i++) {
		unsigned char c;
		const char *buff;

		if (copy_from_user(&c, buffer+i, 1))
			return -EFAULT;

		if ((buff = bufs[c]) != NULL)
			write_msg(NULL, buff, strlen(buff));
	}
	return count;
}

static const struct file_operations netbomb_fops = {
	.owner   = THIS_MODULE,
	.open    = netbomb_open,
	.read    = seq_read,
	.llseek  = seq_lseek,
	.release = single_release,
	.write   = netbomb_write,
};

static int __init init_netbomb(void)
{
	int err, i;
	struct netbomb_target *nt, *tmp;
	unsigned long flags;
	char *target_config;
	char *input = config;

	if (strnlen(input, MAX_PARAM_LENGTH)) {
		while ((target_config = strsep(&input, ";"))) {
			nt = alloc_param_target(target_config);
			if (IS_ERR(nt)) {
				err = PTR_ERR(nt);
				goto fail;
			}
			/* Dump existing printks when we register */
			netbomb.flags |= CON_PRINTBUFFER;

			spin_lock_irqsave(&target_list_lock, flags);
			list_add(&nt->list, &target_list);
			spin_unlock_irqrestore(&target_list_lock, flags);
		}
	}

	for (i = 0; i < 256; i++) {
		char *p = kmalloc(i > 0 ? i+1 : 2, GFP_KERNEL);
		bufs[i] = p;
		if (p == NULL)
			continue;
		if (i == 0) {
			p[0] = '\n';
			p[1] = '\0';
		} else {
			memset(p, '_', i > 0 ? i+1 : 2);
			if (i < 10)
				sprintf(p + i - 1, "%d", i);
			else if (i < 100)
				sprintf(p + i - 2, "%d", i);
			else
				sprintf(p + i - 3, "%d", i);
			p[i] = '\0';
		}
	}

	err = register_netdevice_notifier(&netbomb_netdev_notifier);
	if (err)
		goto fail;
	proc_create("netbomb-trigger", 0, NULL, &netbomb_fops);

	printk(KERN_INFO "netbomb: network logging started\n");

	return err;

undonotifier:
	unregister_netdevice_notifier(&netbomb_netdev_notifier);

fail:
	printk(KERN_ERR "netbomb: cleaning up\n");

	/*
	 * Remove all targets and destroy them (only targets created
	 * from the boot/module option exist here). Skipping the list
	 * lock is safe here, and netpoll_cleanup() will sleep.
	 */
	list_for_each_entry_safe(nt, tmp, &target_list, list) {
		list_del(&nt->list);
		free_param_target(nt);
	}

	return err;
}

static void __exit cleanup_netbomb(void)
{
	struct netbomb_target *nt, *tmp;
	int i;

	remove_proc_entry("netbomb-trigger", NULL);
	unregister_netdevice_notifier(&netbomb_netdev_notifier);

	/*
	 * Targets created via configfs pin references on our module
	 * and would first be rmdir(2)'ed from userspace. We reach
	 * here only when they are already destroyed, and only those
	 * created from the boot/module option are left, so remove and
	 * destroy them. Skipping the list lock is safe here, and
	 * netpoll_cleanup() will sleep.
	 */
	list_for_each_entry_safe(nt, tmp, &target_list, list) {
		list_del(&nt->list);
		free_param_target(nt);
	}

	for (i = 0; i < 256; i++)
		kfree(bufs[i]);
}

module_init(init_netbomb);
module_exit(cleanup_netbomb);