[linux.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 <[email protected]>
 *
 * Converted to x_tables and reworked for upstream inclusion
 * by Luciano Coelho <[email protected]>
 *
 * Contact: Luciano Coelho <[email protected]>
 *
 * 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(unsigned long data)
{
	struct idletimer_tg *timer = (struct idletimer_tg *) data;

	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) {
		pr_debug("couldn't alloc timer\n");
		ret = -ENOMEM;
		goto out;
	}

	info->timer->attr.attr.name = kstrdup(info->label, GFP_KERNEL);
	if (!info->timer->attr.attr.name) {
		pr_debug("couldn't alloc attribute name\n");
		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);

	setup_timer(&info->timer->timer, idletimer_tg_expired,
		    (unsigned long) info->timer);
	info->timer->refcnt = 1;

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

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

	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->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);
		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),
	.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 <[email protected]>");
MODULE_AUTHOR("Luciano Coelho <[email protected]>");
MODULE_DESCRIPTION("Xtables: idle time monitor");
MODULE_LICENSE("GPL v2");
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 <[email protected]>
	9	*
	10	* Converted to x_tables and reworked for upstream inclusion
	11	* by Luciano Coelho <[email protected]>
	12	*
	13	* Contact: Luciano Coelho <[email protected]>
	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
110	static void idletimer_tg_expired(unsigned long data)
111	{
112	struct idletimer_tg timer = (struct idletimer_tg ) data;
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) {
125	pr_debug("couldn't alloc timer\n");
126	ret = -ENOMEM;
127	goto out;
128	}
129
130	info->timer->attr.attr.name = kstrdup(info->label, GFP_KERNEL);
131	if (!info->timer->attr.attr.name) {
132	pr_debug("couldn't alloc attribute name\n");
133	ret = -ENOMEM;
134	goto out_free_timer;
135	}
136	info->timer->attr.attr.mode = S_IRUGO;
137	info->timer->attr.show = idletimer_tg_show;
138
139	ret = sysfs_create_file(idletimer_tg_kobj, &info->timer->attr.attr);
140	if (ret < 0) {
141	pr_debug("couldn't add file to sysfs");
142	goto out_free_attr;
143	}
144
145	list_add(&info->timer->entry, &idletimer_tg_list);
146
147	setup_timer(&info->timer->timer, idletimer_tg_expired,
148	(unsigned long) info->timer);
149	info->timer->refcnt = 1;
150
151	mod_timer(&info->timer->timer,
152	msecs_to_jiffies(info->timeout * 1000) + jiffies);
153
154	INIT_WORK(&info->timer->work, idletimer_tg_work);
155
156	return 0;
157
158	out_free_attr:
159	kfree(info->timer->attr.attr.name);
160	out_free_timer:
161	kfree(info->timer);
162	out:
163	return ret;
164	}
165
166	/*
167	* The actual xt_tables plugin.
168	*/
169	static unsigned int idletimer_tg_target(struct sk_buff *skb,
170	const struct xt_action_param *par)
171	{
172	const struct idletimer_tg_info *info = par->targinfo;
173
174	pr_debug("resetting timer %s, timeout period %u\n",
175	info->label, info->timeout);
176
177	BUG_ON(!info->timer);
178
179	mod_timer(&info->timer->timer,
180	msecs_to_jiffies(info->timeout * 1000) + jiffies);
181
182	return XT_CONTINUE;
183	}
184
185	static int idletimer_tg_checkentry(const struct xt_tgchk_param *par)
186	{
187	struct idletimer_tg_info *info = par->targinfo;
188	int ret;
189
190	pr_debug("checkentry targinfo%s\n", info->label);
191
192	if (info->timeout == 0) {
193	pr_debug("timeout value is zero\n");
194	return -EINVAL;
195	}
196
197	if (info->label[0] == '\0' \|\|
198	strnlen(info->label,
199	MAX_IDLETIMER_LABEL_SIZE) == MAX_IDLETIMER_LABEL_SIZE) {
200	pr_debug("label is empty or not nul-terminated\n");
201	return -EINVAL;
202	}
203
204	mutex_lock(&list_mutex);
205
206	info->timer = __idletimer_tg_find_by_label(info->label);
207	if (info->timer) {
208	info->timer->refcnt++;
209	mod_timer(&info->timer->timer,
210	msecs_to_jiffies(info->timeout * 1000) + jiffies);
211
212	pr_debug("increased refcnt of timer %s to %u\n",
213	info->label, info->timer->refcnt);
214	} else {
215	ret = idletimer_tg_create(info);
216	if (ret < 0) {
217	pr_debug("failed to create timer\n");
218	mutex_unlock(&list_mutex);
219	return ret;
220	}
221	}
222
223	mutex_unlock(&list_mutex);
224	return 0;
225	}
226
227	static void idletimer_tg_destroy(const struct xt_tgdtor_param *par)
228	{
229	const struct idletimer_tg_info *info = par->targinfo;
230
231	pr_debug("destroy targinfo %s\n", info->label);
232
233	mutex_lock(&list_mutex);
234
235	if (--info->timer->refcnt == 0) {
236	pr_debug("deleting timer %s\n", info->label);
237
238	list_del(&info->timer->entry);
239	del_timer_sync(&info->timer->timer);
240	sysfs_remove_file(idletimer_tg_kobj, &info->timer->attr.attr);
241	kfree(info->timer->attr.attr.name);
242	kfree(info->timer);
243	} else {
244	pr_debug("decreased refcnt of timer %s to %u\n",
245	info->label, info->timer->refcnt);
246	}
247
248	mutex_unlock(&list_mutex);
249	}
250
251	static struct xt_target idletimer_tg __read_mostly = {
252	.name = "IDLETIMER",
253	.family = NFPROTO_UNSPEC,
254	.target = idletimer_tg_target,
255	.targetsize = sizeof(struct idletimer_tg_info),
256	.checkentry = idletimer_tg_checkentry,
257	.destroy = idletimer_tg_destroy,
258	.me = THIS_MODULE,
259	};
260
261	static struct class *idletimer_tg_class;
262
263	static struct device *idletimer_tg_device;
264
265	static int __init idletimer_tg_init(void)
266	{
267	int err;
268
269	idletimer_tg_class = class_create(THIS_MODULE, "xt_idletimer");
270	err = PTR_ERR(idletimer_tg_class);
271	if (IS_ERR(idletimer_tg_class)) {
272	pr_debug("couldn't register device class\n");
273	goto out;
274	}
275
276	idletimer_tg_device = device_create(idletimer_tg_class, NULL,
277	MKDEV(0, 0), NULL, "timers");
278	err = PTR_ERR(idletimer_tg_device);
279	if (IS_ERR(idletimer_tg_device)) {
280	pr_debug("couldn't register system device\n");
281	goto out_class;
282	}
283
284	idletimer_tg_kobj = &idletimer_tg_device->kobj;
285
286	err = xt_register_target(&idletimer_tg);
287	if (err < 0) {
288	pr_debug("couldn't register xt target\n");
289	goto out_dev;
290	}
291
292	return 0;
293	out_dev:
294	device_destroy(idletimer_tg_class, MKDEV(0, 0));
295	out_class:
296	class_destroy(idletimer_tg_class);
297	out:
298	return err;
299	}
300
301	static void __exit idletimer_tg_exit(void)
302	{
303	xt_unregister_target(&idletimer_tg);
304
305	device_destroy(idletimer_tg_class, MKDEV(0, 0));
306	class_destroy(idletimer_tg_class);
307	}
308
309	module_init(idletimer_tg_init);
310	module_exit(idletimer_tg_exit);
311
312	MODULE_AUTHOR("Timo Teras <[email protected]>");
313	MODULE_AUTHOR("Luciano Coelho <[email protected]>");
314	MODULE_DESCRIPTION("Xtables: idle time monitor");
315	MODULE_LICENSE("GPL v2");