[mirror_ubuntu-bionic-kernel.git] / net / netfilter / xt_IDLETIMER.c

/*
 * linux/net/netfilter/xt_IDLETIMER.c
 *
 * Netfilter module to trigger a timer when packet matches.
 * After timer expires a kevent will be sent.
 *
 * Copyright (C) 2004, 2010 Nokia Corporation
 * Written by Timo Teras <ext-timo.teras@nokia.com>
 *
 * Converted to x_tables and reworked for upstream inclusion
 * by Luciano Coelho <luciano.coelho@nokia.com>
 *
 * Contact: Luciano Coelho <luciano.coelho@nokia.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 License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/module.h>
#include <linux/timer.h>
#include <linux/list.h>
#include <linux/mutex.h>
#include <linux/netfilter.h>
#include <linux/netfilter/x_tables.h>
#include <linux/netfilter/xt_IDLETIMER.h>
#include <linux/kdev_t.h>
#include <linux/kobject.h>
#include <linux/workqueue.h>
#include <linux/sysfs.h>

struct idletimer_tg_attr {
	struct attribute attr;
	ssize_t	(*show)(struct kobject *kobj,
			struct attribute *attr, char *buf);
};

struct idletimer_tg {
	struct list_head entry;
	struct timer_list timer;
	struct work_struct work;

	struct kobject *kobj;
	struct idletimer_tg_attr attr;

	unsigned int refcnt;
};

static LIST_HEAD(idletimer_tg_list);
static DEFINE_MUTEX(list_mutex);

static struct kobject *idletimer_tg_kobj;

static
struct idletimer_tg *__idletimer_tg_find_by_label(const char *label)
{
	struct idletimer_tg *entry;

	BUG_ON(!label);

	list_for_each_entry(entry, &idletimer_tg_list, entry) {
		if (!strcmp(label, entry->attr.attr.name))
			return entry;
	}

	return NULL;
}

static ssize_t idletimer_tg_show(struct kobject *kobj, struct attribute *attr,
				 char *buf)
{
	struct idletimer_tg *timer;
	unsigned long expires = 0;

	mutex_lock(&list_mutex);

	timer =	__idletimer_tg_find_by_label(attr->name);
	if (timer)
		expires = timer->timer.expires;

	mutex_unlock(&list_mutex);

	if (time_after(expires, jiffies))
		return sprintf(buf, "%u\n",
			       jiffies_to_msecs(expires - jiffies) / 1000);

	return sprintf(buf, "0\n");
}

static void idletimer_tg_work(struct work_struct *work)
{
	struct idletimer_tg *timer = container_of(work, struct idletimer_tg,
						  work);

	sysfs_notify(idletimer_tg_kobj, NULL, timer->attr.attr.name);
}

static void idletimer_tg_expired(struct timer_list *t)
{
	struct idletimer_tg *timer = from_timer(timer, t, timer);

	pr_debug("timer %s expired\n", timer->attr.attr.name);

	schedule_work(&timer->work);
}

static int idletimer_tg_create(struct idletimer_tg_info *info)
{
	int ret;

	info->timer = kmalloc(sizeof(*info->timer), GFP_KERNEL);
	if (!info->timer) {
		ret = -ENOMEM;
		goto out;
	}

	sysfs_attr_init(&info->timer->attr.attr);
	info->timer->attr.attr.name = kstrdup(info->label, GFP_KERNEL);
	if (!info->timer->attr.attr.name) {
		ret = -ENOMEM;
		goto out_free_timer;
	}
	info->timer->attr.attr.mode = S_IRUGO;
	info->timer->attr.show = idletimer_tg_show;

	ret = sysfs_create_file(idletimer_tg_kobj, &info->timer->attr.attr);
	if (ret < 0) {
		pr_debug("couldn't add file to sysfs");
		goto out_free_attr;
	}

	list_add(&info->timer->entry, &idletimer_tg_list);

	timer_setup(&info->timer->timer, idletimer_tg_expired, 0);
	info->timer->refcnt = 1;

	INIT_WORK(&info->timer->work, idletimer_tg_work);

	mod_timer(&info->timer->timer,
		  msecs_to_jiffies(info->timeout * 1000) + jiffies);

	return 0;

out_free_attr:
	kfree(info->timer->attr.attr.name);
out_free_timer:
	kfree(info->timer);
out:
	return ret;
}

/*
 * The actual xt_tables plugin.
 */
static unsigned int idletimer_tg_target(struct sk_buff *skb,
					 const struct xt_action_param *par)
{
	const struct idletimer_tg_info *info = par->targinfo;

	pr_debug("resetting timer %s, timeout period %u\n",
		 info->label, info->timeout);

	BUG_ON(!info->timer);

	mod_timer(&info->timer->timer,
		  msecs_to_jiffies(info->timeout * 1000) + jiffies);

	return XT_CONTINUE;
}

static int idletimer_tg_checkentry(const struct xt_tgchk_param *par)
{
	struct idletimer_tg_info *info = par->targinfo;
	int ret;

	pr_debug("checkentry targinfo%s\n", info->label);

	if (info->timeout == 0) {
		pr_debug("timeout value is zero\n");
		return -EINVAL;
	}
	if (info->timeout >= INT_MAX / 1000) {
		pr_debug("timeout value is too big\n");
		return -EINVAL;
	}
	if (info->label[0] == '\0' ||
	    strnlen(info->label,
		    MAX_IDLETIMER_LABEL_SIZE) == MAX_IDLETIMER_LABEL_SIZE) {
		pr_debug("label is empty or not nul-terminated\n");
		return -EINVAL;
	}

	mutex_lock(&list_mutex);

	info->timer = __idletimer_tg_find_by_label(info->label);
	if (info->timer) {
		info->timer->refcnt++;
		mod_timer(&info->timer->timer,
			  msecs_to_jiffies(info->timeout * 1000) + jiffies);

		pr_debug("increased refcnt of timer %s to %u\n",
			 info->label, info->timer->refcnt);
	} else {
		ret = idletimer_tg_create(info);
		if (ret < 0) {
			pr_debug("failed to create timer\n");
			mutex_unlock(&list_mutex);
			return ret;
		}
	}

	mutex_unlock(&list_mutex);
	return 0;
}

static void idletimer_tg_destroy(const struct xt_tgdtor_param *par)
{
	const struct idletimer_tg_info *info = par->targinfo;

	pr_debug("destroy targinfo %s\n", info->label);

	mutex_lock(&list_mutex);

	if (--info->timer->refcnt == 0) {
		pr_debug("deleting timer %s\n", info->label);

		list_del(&info->timer->entry);
		del_timer_sync(&info->timer->timer);
		cancel_work_sync(&info->timer->work);
		sysfs_remove_file(idletimer_tg_kobj, &info->timer->attr.attr);
		kfree(info->timer->attr.attr.name);
		kfree(info->timer);
	} else {
		pr_debug("decreased refcnt of timer %s to %u\n",
			 info->label, info->timer->refcnt);
	}

	mutex_unlock(&list_mutex);
}

static struct xt_target idletimer_tg __read_mostly = {
	.name		= "IDLETIMER",
	.family		= NFPROTO_UNSPEC,
	.target		= idletimer_tg_target,
	.targetsize     = sizeof(struct idletimer_tg_info),
	.usersize	= offsetof(struct idletimer_tg_info, timer),
	.checkentry	= idletimer_tg_checkentry,
	.destroy        = idletimer_tg_destroy,
	.me		= THIS_MODULE,
};

static struct class *idletimer_tg_class;

static struct device *idletimer_tg_device;

static int __init idletimer_tg_init(void)
{
	int err;

	idletimer_tg_class = class_create(THIS_MODULE, "xt_idletimer");
	err = PTR_ERR(idletimer_tg_class);
	if (IS_ERR(idletimer_tg_class)) {
		pr_debug("couldn't register device class\n");
		goto out;
	}

	idletimer_tg_device = device_create(idletimer_tg_class, NULL,
					    MKDEV(0, 0), NULL, "timers");
	err = PTR_ERR(idletimer_tg_device);
	if (IS_ERR(idletimer_tg_device)) {
		pr_debug("couldn't register system device\n");
		goto out_class;
	}

	idletimer_tg_kobj = &idletimer_tg_device->kobj;

	err =  xt_register_target(&idletimer_tg);
	if (err < 0) {
		pr_debug("couldn't register xt target\n");
		goto out_dev;
	}

	return 0;
out_dev:
	device_destroy(idletimer_tg_class, MKDEV(0, 0));
out_class:
	class_destroy(idletimer_tg_class);
out:
	return err;
}

static void __exit idletimer_tg_exit(void)
{
	xt_unregister_target(&idletimer_tg);

	device_destroy(idletimer_tg_class, MKDEV(0, 0));
	class_destroy(idletimer_tg_class);
}

module_init(idletimer_tg_init);
module_exit(idletimer_tg_exit);

MODULE_AUTHOR("Timo Teras <ext-timo.teras@nokia.com>");
MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
MODULE_DESCRIPTION("Xtables: idle time monitor");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("ipt_IDLETIMER");
MODULE_ALIAS("ip6t_IDLETIMER");
Commit	Line	Data
0902b469 LC	1	/*
	2	* linux/net/netfilter/xt_IDLETIMER.c
	3	*
	4	* Netfilter module to trigger a timer when packet matches.
	5	* After timer expires a kevent will be sent.
	6	*
	7	* Copyright (C) 2004, 2010 Nokia Corporation
	8	* Written by Timo Teras <ext-timo.teras@nokia.com>
	9	*
	10	* Converted to x_tables and reworked for upstream inclusion
	11	* by Luciano Coelho <luciano.coelho@nokia.com>
	12	*
	13	* Contact: Luciano Coelho <luciano.coelho@nokia.com>
	14	*
	15	* This program is free software; you can redistribute it and/or
	16	* modify it under the terms of the GNU General Public License
	17	* version 2 as published by the Free Software Foundation.
	18	*
	19	* This program is distributed in the hope that it will be useful, but
	20	* WITHOUT ANY WARRANTY; without even the implied warranty of
	21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	22	* General Public License for more details.
	23	*
	24	* You should have received a copy of the GNU General Public License
	25	* along with this program; if not, write to the Free Software
	26	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
	27	* 02110-1301 USA
	28	*/
	29
	30	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
	31
	32	#include <linux/module.h>
	33	#include <linux/timer.h>
	34	#include <linux/list.h>
	35	#include <linux/mutex.h>
	36	#include <linux/netfilter.h>
	37	#include <linux/netfilter/x_tables.h>
	38	#include <linux/netfilter/xt_IDLETIMER.h>
600069da	39	#include <linux/kdev_t.h>
0902b469 LC	40	#include <linux/kobject.h>
	41	#include <linux/workqueue.h>
	42	#include <linux/sysfs.h>
	43
	44	struct idletimer_tg_attr {
	45	struct attribute attr;
	46	ssize_t (show)(struct kobject kobj,
	47	struct attribute attr, char buf);
	48	};
	49
	50	struct idletimer_tg {
	51	struct list_head entry;
	52	struct timer_list timer;
	53	struct work_struct work;
	54
	55	struct kobject *kobj;
	56	struct idletimer_tg_attr attr;
	57
	58	unsigned int refcnt;
	59	};
	60
	61	static LIST_HEAD(idletimer_tg_list);
	62	static DEFINE_MUTEX(list_mutex);
	63
	64	static struct kobject *idletimer_tg_kobj;
	65
	66	static
	67	struct idletimer_tg __idletimer_tg_find_by_label(const char label)
	68	{
	69	struct idletimer_tg *entry;
	70
	71	BUG_ON(!label);
	72
	73	list_for_each_entry(entry, &idletimer_tg_list, entry) {
	74	if (!strcmp(label, entry->attr.attr.name))
	75	return entry;
	76	}
	77
	78	return NULL;
	79	}
	80
	81	static ssize_t idletimer_tg_show(struct kobject kobj, struct attribute attr,
	82	char *buf)
	83	{
	84	struct idletimer_tg *timer;
	85	unsigned long expires = 0;
	86
	87	mutex_lock(&list_mutex);
	88
	89	timer = __idletimer_tg_find_by_label(attr->name);
	90	if (timer)
	91	expires = timer->timer.expires;
	92
	93	mutex_unlock(&list_mutex);
	94
	95	if (time_after(expires, jiffies))
	96	return sprintf(buf, "%u\n",
	97	jiffies_to_msecs(expires - jiffies) / 1000);
	98
	99	return sprintf(buf, "0\n");
	100	}
	101
	102	static void idletimer_tg_work(struct work_struct *work)
	103	{
104	struct idletimer_tg *timer = container_of(work, struct idletimer_tg,
105	work);
106
107	sysfs_notify(idletimer_tg_kobj, NULL, timer->attr.attr.name);
108	}
109
e99e88a9	110	static void idletimer_tg_expired(struct timer_list *t)
0902b469	111	{
e99e88a9	112	struct idletimer_tg *timer = from_timer(timer, t, timer);
0902b469 LC	113
	114	pr_debug("timer %s expired\n", timer->attr.attr.name);
	115
	116	schedule_work(&timer->work);
	117	}
	118
	119	static int idletimer_tg_create(struct idletimer_tg_info *info)
	120	{
	121	int ret;
	122
	123	info->timer = kmalloc(sizeof(*info->timer), GFP_KERNEL);
	124	if (!info->timer) {
0902b469 LC	125	ret = -ENOMEM;
	126	goto out;
	127	}
	128
484836ec	129	sysfs_attr_init(&info->timer->attr.attr);
0902b469 LC	130	info->timer->attr.attr.name = kstrdup(info->label, GFP_KERNEL);
0902b469 LC	131	if (!info->timer->attr.attr.name) {
0902b469 LC	132	ret = -ENOMEM;
	133	goto out_free_timer;
	134	}
	135	info->timer->attr.attr.mode = S_IRUGO;
	136	info->timer->attr.show = idletimer_tg_show;
	137
	138	ret = sysfs_create_file(idletimer_tg_kobj, &info->timer->attr.attr);
	139	if (ret < 0) {
	140	pr_debug("couldn't add file to sysfs");
	141	goto out_free_attr;
	142	}
	143
	144	list_add(&info->timer->entry, &idletimer_tg_list);
	145
e99e88a9	146	timer_setup(&info->timer->timer, idletimer_tg_expired, 0);
0902b469 LC	147	info->timer->refcnt = 1;
0902b469 LC	148
54eaccf1 ED	149	INIT_WORK(&info->timer->work, idletimer_tg_work);
54eaccf1 ED	150
0902b469 LC	151	mod_timer(&info->timer->timer,
	152	msecs_to_jiffies(info->timeout * 1000) + jiffies);
	153
0902b469 LC	154	return 0;
	155
	156	out_free_attr:
	157	kfree(info->timer->attr.attr.name);
	158	out_free_timer:
	159	kfree(info->timer);
	160	out:
	161	return ret;
	162	}
	163
	164	/*
	165	* The actual xt_tables plugin.
	166	*/
	167	static unsigned int idletimer_tg_target(struct sk_buff *skb,
	168	const struct xt_action_param *par)
	169	{
	170	const struct idletimer_tg_info *info = par->targinfo;
	171
	172	pr_debug("resetting timer %s, timeout period %u\n",
	173	info->label, info->timeout);
	174
	175	BUG_ON(!info->timer);
	176
	177	mod_timer(&info->timer->timer,
	178	msecs_to_jiffies(info->timeout * 1000) + jiffies);
	179
	180	return XT_CONTINUE;
	181	}
	182
	183	static int idletimer_tg_checkentry(const struct xt_tgchk_param *par)
	184	{
	185	struct idletimer_tg_info *info = par->targinfo;
	186	int ret;
	187
	188	pr_debug("checkentry targinfo%s\n", info->label);
	189
	190	if (info->timeout == 0) {
	191	pr_debug("timeout value is zero\n");
	192	return -EINVAL;
	193	}
54eaccf1 ED	194	if (info->timeout >= INT_MAX / 1000) {
	195	pr_debug("timeout value is too big\n");
	196	return -EINVAL;
	197	}
0902b469 LC	198	if (info->label[0] == '\0' \|\|
	199	strnlen(info->label,
	200	MAX_IDLETIMER_LABEL_SIZE) == MAX_IDLETIMER_LABEL_SIZE) {
	201	pr_debug("label is empty or not nul-terminated\n");
	202	return -EINVAL;
	203	}
	204
	205	mutex_lock(&list_mutex);
	206
	207	info->timer = __idletimer_tg_find_by_label(info->label);
	208	if (info->timer) {
	209	info->timer->refcnt++;
	210	mod_timer(&info->timer->timer,
	211	msecs_to_jiffies(info->timeout * 1000) + jiffies);
	212
	213	pr_debug("increased refcnt of timer %s to %u\n",
	214	info->label, info->timer->refcnt);
	215	} else {
	216	ret = idletimer_tg_create(info);
	217	if (ret < 0) {
	218	pr_debug("failed to create timer\n");
	219	mutex_unlock(&list_mutex);
	220	return ret;
	221	}
	222	}
	223
	224	mutex_unlock(&list_mutex);
	225	return 0;
	226	}
	227
	228	static void idletimer_tg_destroy(const struct xt_tgdtor_param *par)
	229	{
	230	const struct idletimer_tg_info *info = par->targinfo;
	231
	232	pr_debug("destroy targinfo %s\n", info->label);
	233
	234	mutex_lock(&list_mutex);
	235
	236	if (--info->timer->refcnt == 0) {
	237	pr_debug("deleting timer %s\n", info->label);
	238
	239	list_del(&info->timer->entry);
	240	del_timer_sync(&info->timer->timer);
cec5913c	241	cancel_work_sync(&info->timer->work);
0902b469 LC	242	sysfs_remove_file(idletimer_tg_kobj, &info->timer->attr.attr);
	243	kfree(info->timer->attr.attr.name);
	244	kfree(info->timer);
	245	} else {
	246	pr_debug("decreased refcnt of timer %s to %u\n",
	247	info->label, info->timer->refcnt);
	248	}
	249
	250	mutex_unlock(&list_mutex);
	251	}
	252
	253	static struct xt_target idletimer_tg __read_mostly = {
	254	.name = "IDLETIMER",
	255	.family = NFPROTO_UNSPEC,
	256	.target = idletimer_tg_target,
	257	.targetsize = sizeof(struct idletimer_tg_info),
9a0e1295	258	.usersize = offsetof(struct idletimer_tg_info, timer),
0902b469 LC	259	.checkentry = idletimer_tg_checkentry,
	260	.destroy = idletimer_tg_destroy,
	261	.me = THIS_MODULE,
	262	};
	263
	264	static struct class *idletimer_tg_class;
	265
	266	static struct device *idletimer_tg_device;
	267
	268	static int __init idletimer_tg_init(void)
	269	{
	270	int err;
	271
	272	idletimer_tg_class = class_create(THIS_MODULE, "xt_idletimer");
	273	err = PTR_ERR(idletimer_tg_class);
	274	if (IS_ERR(idletimer_tg_class)) {
	275	pr_debug("couldn't register device class\n");
	276	goto out;
	277	}
	278
	279	idletimer_tg_device = device_create(idletimer_tg_class, NULL,
	280	MKDEV(0, 0), NULL, "timers");
	281	err = PTR_ERR(idletimer_tg_device);
	282	if (IS_ERR(idletimer_tg_device)) {
	283	pr_debug("couldn't register system device\n");
	284	goto out_class;
	285	}
	286
	287	idletimer_tg_kobj = &idletimer_tg_device->kobj;
	288
	289	err = xt_register_target(&idletimer_tg);
	290	if (err < 0) {
	291	pr_debug("couldn't register xt target\n");
	292	goto out_dev;
	293	}
	294
	295	return 0;
	296	out_dev:
	297	device_destroy(idletimer_tg_class, MKDEV(0, 0));
	298	out_class:
	299	class_destroy(idletimer_tg_class);
	300	out:
	301	return err;
	302	}
	303
	304	static void __exit idletimer_tg_exit(void)
	305	{
	306	xt_unregister_target(&idletimer_tg);
	307
	308	device_destroy(idletimer_tg_class, MKDEV(0, 0));
	309	class_destroy(idletimer_tg_class);
	310	}
	311
	312	module_init(idletimer_tg_init);
	313	module_exit(idletimer_tg_exit);
	314
	315	MODULE_AUTHOR("Timo Teras <ext-timo.teras@nokia.com>");
	316	MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
	317	MODULE_DESCRIPTION("Xtables: idle time monitor");
	318	MODULE_LICENSE("GPL v2");
f1e231a3 JE	319	MODULE_ALIAS("ipt_IDLETIMER");
f1e231a3 JE	320	MODULE_ALIAS("ip6t_IDLETIMER");