blob: f407ebc13481ae5caa0f634db643d034c7af7e6a [file] [log] [blame]
Luciano Coelho0902b462010-06-15 15:04:00 +02001/*
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>
Randy Dunlap600069d2010-06-22 08:13:31 +020039#include <linux/kdev_t.h>
Luciano Coelho0902b462010-06-15 15:04:00 +020040#include <linux/kobject.h>
41#include <linux/workqueue.h>
42#include <linux/sysfs.h>
43
44struct idletimer_tg_attr {
45 struct attribute attr;
46 ssize_t (*show)(struct kobject *kobj,
47 struct attribute *attr, char *buf);
48};
49
50struct 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
61static LIST_HEAD(idletimer_tg_list);
62static DEFINE_MUTEX(list_mutex);
63
64static struct kobject *idletimer_tg_kobj;
65
66static
67struct 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
81static 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
102static 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
110static 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
119static 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) {
Luciano Coelho0902b462010-06-15 15:04:00 +0200125 ret = -ENOMEM;
126 goto out;
127 }
128
129 info->timer->attr.attr.name = kstrdup(info->label, GFP_KERNEL);
130 if (!info->timer->attr.attr.name) {
Luciano Coelho0902b462010-06-15 15:04:00 +0200131 ret = -ENOMEM;
132 goto out_free_timer;
133 }
134 info->timer->attr.attr.mode = S_IRUGO;
135 info->timer->attr.show = idletimer_tg_show;
136
137 ret = sysfs_create_file(idletimer_tg_kobj, &info->timer->attr.attr);
138 if (ret < 0) {
139 pr_debug("couldn't add file to sysfs");
140 goto out_free_attr;
141 }
142
143 list_add(&info->timer->entry, &idletimer_tg_list);
144
145 setup_timer(&info->timer->timer, idletimer_tg_expired,
146 (unsigned long) info->timer);
147 info->timer->refcnt = 1;
148
149 mod_timer(&info->timer->timer,
150 msecs_to_jiffies(info->timeout * 1000) + jiffies);
151
152 INIT_WORK(&info->timer->work, idletimer_tg_work);
153
154 return 0;
155
156out_free_attr:
157 kfree(info->timer->attr.attr.name);
158out_free_timer:
159 kfree(info->timer);
160out:
161 return ret;
162}
163
164/*
165 * The actual xt_tables plugin.
166 */
167static 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
183static 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 }
194
195 if (info->label[0] == '\0' ||
196 strnlen(info->label,
197 MAX_IDLETIMER_LABEL_SIZE) == MAX_IDLETIMER_LABEL_SIZE) {
198 pr_debug("label is empty or not nul-terminated\n");
199 return -EINVAL;
200 }
201
202 mutex_lock(&list_mutex);
203
204 info->timer = __idletimer_tg_find_by_label(info->label);
205 if (info->timer) {
206 info->timer->refcnt++;
207 mod_timer(&info->timer->timer,
208 msecs_to_jiffies(info->timeout * 1000) + jiffies);
209
210 pr_debug("increased refcnt of timer %s to %u\n",
211 info->label, info->timer->refcnt);
212 } else {
213 ret = idletimer_tg_create(info);
214 if (ret < 0) {
215 pr_debug("failed to create timer\n");
216 mutex_unlock(&list_mutex);
217 return ret;
218 }
219 }
220
221 mutex_unlock(&list_mutex);
222 return 0;
223}
224
225static void idletimer_tg_destroy(const struct xt_tgdtor_param *par)
226{
227 const struct idletimer_tg_info *info = par->targinfo;
228
229 pr_debug("destroy targinfo %s\n", info->label);
230
231 mutex_lock(&list_mutex);
232
233 if (--info->timer->refcnt == 0) {
234 pr_debug("deleting timer %s\n", info->label);
235
236 list_del(&info->timer->entry);
237 del_timer_sync(&info->timer->timer);
238 sysfs_remove_file(idletimer_tg_kobj, &info->timer->attr.attr);
239 kfree(info->timer->attr.attr.name);
240 kfree(info->timer);
241 } else {
242 pr_debug("decreased refcnt of timer %s to %u\n",
243 info->label, info->timer->refcnt);
244 }
245
246 mutex_unlock(&list_mutex);
247}
248
249static struct xt_target idletimer_tg __read_mostly = {
250 .name = "IDLETIMER",
251 .family = NFPROTO_UNSPEC,
252 .target = idletimer_tg_target,
253 .targetsize = sizeof(struct idletimer_tg_info),
254 .checkentry = idletimer_tg_checkentry,
255 .destroy = idletimer_tg_destroy,
256 .me = THIS_MODULE,
257};
258
259static struct class *idletimer_tg_class;
260
261static struct device *idletimer_tg_device;
262
263static int __init idletimer_tg_init(void)
264{
265 int err;
266
267 idletimer_tg_class = class_create(THIS_MODULE, "xt_idletimer");
268 err = PTR_ERR(idletimer_tg_class);
269 if (IS_ERR(idletimer_tg_class)) {
270 pr_debug("couldn't register device class\n");
271 goto out;
272 }
273
274 idletimer_tg_device = device_create(idletimer_tg_class, NULL,
275 MKDEV(0, 0), NULL, "timers");
276 err = PTR_ERR(idletimer_tg_device);
277 if (IS_ERR(idletimer_tg_device)) {
278 pr_debug("couldn't register system device\n");
279 goto out_class;
280 }
281
282 idletimer_tg_kobj = &idletimer_tg_device->kobj;
283
284 err = xt_register_target(&idletimer_tg);
285 if (err < 0) {
286 pr_debug("couldn't register xt target\n");
287 goto out_dev;
288 }
289
290 return 0;
291out_dev:
292 device_destroy(idletimer_tg_class, MKDEV(0, 0));
293out_class:
294 class_destroy(idletimer_tg_class);
295out:
296 return err;
297}
298
299static void __exit idletimer_tg_exit(void)
300{
301 xt_unregister_target(&idletimer_tg);
302
303 device_destroy(idletimer_tg_class, MKDEV(0, 0));
304 class_destroy(idletimer_tg_class);
305}
306
307module_init(idletimer_tg_init);
308module_exit(idletimer_tg_exit);
309
310MODULE_AUTHOR("Timo Teras <ext-timo.teras@nokia.com>");
311MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
312MODULE_DESCRIPTION("Xtables: idle time monitor");
313MODULE_LICENSE("GPL v2");
Jan Engelhardtf1e231a2011-01-18 06:30:13 +0100314MODULE_ALIAS("ipt_IDLETIMER");
315MODULE_ALIAS("ip6t_IDLETIMER");