xt_IDLETIMER.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * linux/net/netfilter/xt_IDLETIMER.c
  4 *
  5 * Netfilter module to trigger a timer when packet matches.
  6 * After timer expires a kevent will be sent.
  7 *
  8 * Copyright (C) 2004, 2010 Nokia Corporation
  9 * Written by Timo Teras <ext-timo.teras@nokia.com>
 10 *
 11 * Converted to x_tables and reworked for upstream inclusion
 12 * by Luciano Coelho <luciano.coelho@nokia.com>
 13 *
 14 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
 15 */
 16
 17#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 18
 19#include <linux/module.h>
 20#include <linux/timer.h>
 21#include <linux/alarmtimer.h>
 22#include <linux/list.h>
 23#include <linux/mutex.h>
 24#include <linux/netfilter.h>
 25#include <linux/netfilter/x_tables.h>
 26#include <linux/netfilter/xt_IDLETIMER.h>
 27#include <linux/kdev_t.h>
 28#include <linux/kobject.h>
 29#include <linux/workqueue.h>
 30#include <linux/sysfs.h>
 31
 32struct idletimer_tg {
 33	struct list_head entry;
 34	struct alarm alarm;
 35	struct timer_list timer;
 36	struct work_struct work;
 37
 38	struct kobject *kobj;
 39	struct device_attribute attr;
 40
 41	unsigned int refcnt;
 42	u8 timer_type;
 43};
 44
 45static LIST_HEAD(idletimer_tg_list);
 46static DEFINE_MUTEX(list_mutex);
 47
 48static struct kobject *idletimer_tg_kobj;
 49
 50static
 51struct idletimer_tg *__idletimer_tg_find_by_label(const char *label)
 52{
 53	struct idletimer_tg *entry;
 54
 55	list_for_each_entry(entry, &idletimer_tg_list, entry) {
 56		if (!strcmp(label, entry->attr.attr.name))
 57			return entry;
 58	}
 59
 60	return NULL;
 61}
 62
 63static ssize_t idletimer_tg_show(struct device *dev,
 64				 struct device_attribute *attr, char *buf)
 65{
 66	struct idletimer_tg *timer;
 67	unsigned long expires = 0;
 68	struct timespec64 ktimespec = {};
 69	long time_diff = 0;
 70
 71	mutex_lock(&list_mutex);
 72
 73	timer =	__idletimer_tg_find_by_label(attr->attr.name);
 74	if (timer) {
 75		if (timer->timer_type & XT_IDLETIMER_ALARM) {
 76			ktime_t expires_alarm = alarm_expires_remaining(&timer->alarm);
 77			ktimespec = ktime_to_timespec64(expires_alarm);
 78			time_diff = ktimespec.tv_sec;
 79		} else {
 80			expires = timer->timer.expires;
 81			time_diff = jiffies_to_msecs(expires - jiffies) / 1000;
 82		}
 83	}
 84
 85	mutex_unlock(&list_mutex);
 86
 87	if (time_after(expires, jiffies) || ktimespec.tv_sec > 0)
 88		return sysfs_emit(buf, "%ld\n", time_diff);
 89
 90	return sysfs_emit(buf, "0\n");
 91}
 92
 93static void idletimer_tg_work(struct work_struct *work)
 94{
 95	struct idletimer_tg *timer = container_of(work, struct idletimer_tg,
 96						  work);
 97
 98	sysfs_notify(idletimer_tg_kobj, NULL, timer->attr.attr.name);
 99}
100
101static void idletimer_tg_expired(struct timer_list *t)
102{
103	struct idletimer_tg *timer = timer_container_of(timer, t, timer);
104
105	pr_debug("timer %s expired\n", timer->attr.attr.name);
106
107	schedule_work(&timer->work);
108}
109
110static void idletimer_tg_alarmproc(struct alarm *alarm, ktime_t now)
111{
112	struct idletimer_tg *timer = alarm->data;
113
114	pr_debug("alarm %s expired\n", timer->attr.attr.name);
115	schedule_work(&timer->work);
116}
117
118static int idletimer_check_sysfs_name(const char *name, unsigned int size)
119{
120	int ret;
121
122	ret = xt_check_proc_name(name, size);
123	if (ret < 0)
124		return ret;
125
126	if (!strcmp(name, "power") ||
127	    !strcmp(name, "subsystem") ||
128	    !strcmp(name, "uevent"))
129		return -EINVAL;
130
131	return 0;
132}
133
134static int idletimer_tg_create(struct idletimer_tg_info *info)
135{
136	int ret;
137
138	info->timer = kzalloc(sizeof(*info->timer), GFP_KERNEL);
139	if (!info->timer) {
140		ret = -ENOMEM;
141		goto out;
142	}
143
144	ret = idletimer_check_sysfs_name(info->label, sizeof(info->label));
145	if (ret < 0)
146		goto out_free_timer;
147
148	sysfs_attr_init(&info->timer->attr.attr);
149	info->timer->attr.attr.name = kstrdup(info->label, GFP_KERNEL);
150	if (!info->timer->attr.attr.name) {
151		ret = -ENOMEM;
152		goto out_free_timer;
153	}
154	info->timer->attr.attr.mode = 0444;
155	info->timer->attr.show = idletimer_tg_show;
156
157	ret = sysfs_create_file(idletimer_tg_kobj, &info->timer->attr.attr);
158	if (ret < 0) {
159		pr_debug("couldn't add file to sysfs");
160		goto out_free_attr;
161	}
162
163	list_add(&info->timer->entry, &idletimer_tg_list);
164
165	timer_setup(&info->timer->timer, idletimer_tg_expired, 0);
166	info->timer->refcnt = 1;
167
168	INIT_WORK(&info->timer->work, idletimer_tg_work);
169
170	mod_timer(&info->timer->timer,
171		  secs_to_jiffies(info->timeout) + jiffies);
172
173	return 0;
174
175out_free_attr:
176	kfree(info->timer->attr.attr.name);
177out_free_timer:
178	kfree(info->timer);
179out:
180	return ret;
181}
182
183static int idletimer_tg_create_v1(struct idletimer_tg_info_v1 *info)
184{
185	int ret;
186
187	info->timer = kmalloc(sizeof(*info->timer), GFP_KERNEL);
188	if (!info->timer) {
189		ret = -ENOMEM;
190		goto out;
191	}
192
193	ret = idletimer_check_sysfs_name(info->label, sizeof(info->label));
194	if (ret < 0)
195		goto out_free_timer;
196
197	sysfs_attr_init(&info->timer->attr.attr);
198	info->timer->attr.attr.name = kstrdup(info->label, GFP_KERNEL);
199	if (!info->timer->attr.attr.name) {
200		ret = -ENOMEM;
201		goto out_free_timer;
202	}
203	info->timer->attr.attr.mode = 0444;
204	info->timer->attr.show = idletimer_tg_show;
205
206	ret = sysfs_create_file(idletimer_tg_kobj, &info->timer->attr.attr);
207	if (ret < 0) {
208		pr_debug("couldn't add file to sysfs");
209		goto out_free_attr;
210	}
211
212	/*  notify userspace  */
213	kobject_uevent(idletimer_tg_kobj,KOBJ_ADD);
214
215	list_add(&info->timer->entry, &idletimer_tg_list);
216	pr_debug("timer type value is %u", info->timer_type);
217	info->timer->timer_type = info->timer_type;
218	info->timer->refcnt = 1;
219
220	INIT_WORK(&info->timer->work, idletimer_tg_work);
221
222	if (info->timer->timer_type & XT_IDLETIMER_ALARM) {
223		ktime_t tout;
224		alarm_init(&info->timer->alarm, ALARM_BOOTTIME,
225			   idletimer_tg_alarmproc);
226		info->timer->alarm.data = info->timer;
227		tout = ktime_set(info->timeout, 0);
228		alarm_start_relative(&info->timer->alarm, tout);
229	} else {
230		timer_setup(&info->timer->timer, idletimer_tg_expired, 0);
231		mod_timer(&info->timer->timer,
232				secs_to_jiffies(info->timeout) + jiffies);
233	}
234
235	return 0;
236
237out_free_attr:
238	kfree(info->timer->attr.attr.name);
239out_free_timer:
240	kfree(info->timer);
241out:
242	return ret;
243}
244
245/*
246 * The actual xt_tables plugin.
247 */
248static unsigned int idletimer_tg_target(struct sk_buff *skb,
249					 const struct xt_action_param *par)
250{
251	const struct idletimer_tg_info *info = par->targinfo;
252
253	pr_debug("resetting timer %s, timeout period %u\n",
254		 info->label, info->timeout);
255
256	mod_timer(&info->timer->timer,
257		  secs_to_jiffies(info->timeout) + jiffies);
258
259	return XT_CONTINUE;
260}
261
262/*
263 * The actual xt_tables plugin.
264 */
265static unsigned int idletimer_tg_target_v1(struct sk_buff *skb,
266					 const struct xt_action_param *par)
267{
268	const struct idletimer_tg_info_v1 *info = par->targinfo;
269
270	pr_debug("resetting timer %s, timeout period %u\n",
271		 info->label, info->timeout);
272
273	if (info->timer->timer_type & XT_IDLETIMER_ALARM) {
274		ktime_t tout = ktime_set(info->timeout, 0);
275		alarm_start_relative(&info->timer->alarm, tout);
276	} else {
277		mod_timer(&info->timer->timer,
278				secs_to_jiffies(info->timeout) + jiffies);
279	}
280
281	return XT_CONTINUE;
282}
283
284static int idletimer_tg_helper(struct idletimer_tg_info *info)
285{
286	if (info->timeout == 0) {
287		pr_debug("timeout value is zero\n");
288		return -EINVAL;
289	}
290	if (info->timeout >= INT_MAX / 1000) {
291		pr_debug("timeout value is too big\n");
292		return -EINVAL;
293	}
294	if (info->label[0] == '\0' ||
295	    strnlen(info->label,
296		    MAX_IDLETIMER_LABEL_SIZE) == MAX_IDLETIMER_LABEL_SIZE) {
297		pr_debug("label is empty or not nul-terminated\n");
298		return -EINVAL;
299	}
300	return 0;
301}
302
303
304static int idletimer_tg_checkentry(const struct xt_tgchk_param *par)
305{
306	struct idletimer_tg_info *info = par->targinfo;
307	int ret;
308
309	pr_debug("checkentry targinfo%s\n", info->label);
310
311	ret = idletimer_tg_helper(info);
312	if(ret < 0)
313	{
314		pr_debug("checkentry helper return invalid\n");
315		return -EINVAL;
316	}
317	mutex_lock(&list_mutex);
318
319	info->timer = __idletimer_tg_find_by_label(info->label);
320	if (info->timer) {
321		if (info->timer->timer_type & XT_IDLETIMER_ALARM) {
322			pr_debug("Adding/Replacing rule with same label and different timer type is not allowed\n");
323			mutex_unlock(&list_mutex);
324			return -EINVAL;
325		}
326
327		info->timer->refcnt++;
328		mod_timer(&info->timer->timer,
329			  secs_to_jiffies(info->timeout) + jiffies);
330
331		pr_debug("increased refcnt of timer %s to %u\n",
332			 info->label, info->timer->refcnt);
333	} else {
334		ret = idletimer_tg_create(info);
335		if (ret < 0) {
336			pr_debug("failed to create timer\n");
337			mutex_unlock(&list_mutex);
338			return ret;
339		}
340	}
341
342	mutex_unlock(&list_mutex);
343	return 0;
344}
345
346static int idletimer_tg_checkentry_v1(const struct xt_tgchk_param *par)
347{
348	struct idletimer_tg_info_v1 *info = par->targinfo;
349	int ret;
350
351	pr_debug("checkentry targinfo%s\n", info->label);
352
353	if (info->send_nl_msg)
354		return -EOPNOTSUPP;
355
356	ret = idletimer_tg_helper((struct idletimer_tg_info *)info);
357	if(ret < 0)
358	{
359		pr_debug("checkentry helper return invalid\n");
360		return -EINVAL;
361	}
362
363	if (info->timer_type > XT_IDLETIMER_ALARM) {
364		pr_debug("invalid value for timer type\n");
365		return -EINVAL;
366	}
367
368	mutex_lock(&list_mutex);
369
370	info->timer = __idletimer_tg_find_by_label(info->label);
371	if (info->timer) {
372		if (info->timer->timer_type != info->timer_type) {
373			pr_debug("Adding/Replacing rule with same label and different timer type is not allowed\n");
374			mutex_unlock(&list_mutex);
375			return -EINVAL;
376		}
377
378		info->timer->refcnt++;
379		if (info->timer_type & XT_IDLETIMER_ALARM) {
380			/* calculate remaining expiry time */
381			ktime_t tout = alarm_expires_remaining(&info->timer->alarm);
382			struct timespec64 ktimespec = ktime_to_timespec64(tout);
383
384			if (ktimespec.tv_sec > 0) {
385				pr_debug("time_expiry_remaining %lld\n",
386					 ktimespec.tv_sec);
387				alarm_start_relative(&info->timer->alarm, tout);
388			}
389		} else {
390				mod_timer(&info->timer->timer,
391					secs_to_jiffies(info->timeout) + jiffies);
392		}
393		pr_debug("increased refcnt of timer %s to %u\n",
394			 info->label, info->timer->refcnt);
395	} else {
396		ret = idletimer_tg_create_v1(info);
397		if (ret < 0) {
398			pr_debug("failed to create timer\n");
399			mutex_unlock(&list_mutex);
400			return ret;
401		}
402	}
403
404	mutex_unlock(&list_mutex);
405	return 0;
406}
407
408static void idletimer_tg_destroy(const struct xt_tgdtor_param *par)
409{
410	const struct idletimer_tg_info *info = par->targinfo;
411
412	pr_debug("destroy targinfo %s\n", info->label);
413
414	mutex_lock(&list_mutex);
415
416	if (--info->timer->refcnt > 0) {
417		pr_debug("decreased refcnt of timer %s to %u\n",
418			 info->label, info->timer->refcnt);
419		mutex_unlock(&list_mutex);
420		return;
421	}
422
423	pr_debug("deleting timer %s\n", info->label);
424
425	list_del(&info->timer->entry);
426	mutex_unlock(&list_mutex);
427
428	timer_shutdown_sync(&info->timer->timer);
429	cancel_work_sync(&info->timer->work);
430	sysfs_remove_file(idletimer_tg_kobj, &info->timer->attr.attr);
431	kfree(info->timer->attr.attr.name);
432	kfree(info->timer);
433}
434
435static void idletimer_tg_destroy_v1(const struct xt_tgdtor_param *par)
436{
437	const struct idletimer_tg_info_v1 *info = par->targinfo;
438
439	pr_debug("destroy targinfo %s\n", info->label);
440
441	mutex_lock(&list_mutex);
442
443	if (--info->timer->refcnt > 0) {
444		pr_debug("decreased refcnt of timer %s to %u\n",
445			 info->label, info->timer->refcnt);
446		mutex_unlock(&list_mutex);
447		return;
448	}
449
450	pr_debug("deleting timer %s\n", info->label);
451
452	list_del(&info->timer->entry);
453	mutex_unlock(&list_mutex);
454
455	if (info->timer->timer_type & XT_IDLETIMER_ALARM) {
456		alarm_cancel(&info->timer->alarm);
457	} else {
458		timer_shutdown_sync(&info->timer->timer);
459	}
460	cancel_work_sync(&info->timer->work);
461	sysfs_remove_file(idletimer_tg_kobj, &info->timer->attr.attr);
462	kfree(info->timer->attr.attr.name);
463	kfree(info->timer);
464}
465
466
467static struct xt_target idletimer_tg[] __read_mostly = {
468	{
469		.name		= "IDLETIMER",
470		.family		= NFPROTO_IPV4,
471		.target		= idletimer_tg_target,
472		.targetsize     = sizeof(struct idletimer_tg_info),
473		.usersize	= offsetof(struct idletimer_tg_info, timer),
474		.checkentry	= idletimer_tg_checkentry,
475		.destroy        = idletimer_tg_destroy,
476		.me		= THIS_MODULE,
477	},
478	{
479		.name		= "IDLETIMER",
480		.family		= NFPROTO_IPV4,
481		.revision	= 1,
482		.target		= idletimer_tg_target_v1,
483		.targetsize     = sizeof(struct idletimer_tg_info_v1),
484		.usersize	= offsetof(struct idletimer_tg_info_v1, timer),
485		.checkentry	= idletimer_tg_checkentry_v1,
486		.destroy        = idletimer_tg_destroy_v1,
487		.me		= THIS_MODULE,
488	},
489#if IS_ENABLED(CONFIG_IP6_NF_IPTABLES)
490	{
491		.name		= "IDLETIMER",
492		.family		= NFPROTO_IPV6,
493		.target		= idletimer_tg_target,
494		.targetsize     = sizeof(struct idletimer_tg_info),
495		.usersize	= offsetof(struct idletimer_tg_info, timer),
496		.checkentry	= idletimer_tg_checkentry,
497		.destroy        = idletimer_tg_destroy,
498		.me		= THIS_MODULE,
499	},
500	{
501		.name		= "IDLETIMER",
502		.family		= NFPROTO_IPV6,
503		.revision	= 1,
504		.target		= idletimer_tg_target_v1,
505		.targetsize     = sizeof(struct idletimer_tg_info_v1),
506		.usersize	= offsetof(struct idletimer_tg_info_v1, timer),
507		.checkentry	= idletimer_tg_checkentry_v1,
508		.destroy        = idletimer_tg_destroy_v1,
509		.me		= THIS_MODULE,
510	},
511#endif
512};
513
514static struct class *idletimer_tg_class;
515
516static struct device *idletimer_tg_device;
517
518static int __init idletimer_tg_init(void)
519{
520	int err;
521
522	idletimer_tg_class = class_create("xt_idletimer");
523	err = PTR_ERR(idletimer_tg_class);
524	if (IS_ERR(idletimer_tg_class)) {
525		pr_debug("couldn't register device class\n");
526		goto out;
527	}
528
529	idletimer_tg_device = device_create(idletimer_tg_class, NULL,
530					    MKDEV(0, 0), NULL, "timers");
531	err = PTR_ERR(idletimer_tg_device);
532	if (IS_ERR(idletimer_tg_device)) {
533		pr_debug("couldn't register system device\n");
534		goto out_class;
535	}
536
537	idletimer_tg_kobj = &idletimer_tg_device->kobj;
538
539	err = xt_register_targets(idletimer_tg, ARRAY_SIZE(idletimer_tg));
540
541	if (err < 0) {
542		pr_debug("couldn't register xt target\n");
543		goto out_dev;
544	}
545
546	return 0;
547out_dev:
548	device_destroy(idletimer_tg_class, MKDEV(0, 0));
549out_class:
550	class_destroy(idletimer_tg_class);
551out:
552	return err;
553}
554
555static void __exit idletimer_tg_exit(void)
556{
557	xt_unregister_targets(idletimer_tg, ARRAY_SIZE(idletimer_tg));
558
559	device_destroy(idletimer_tg_class, MKDEV(0, 0));
560	class_destroy(idletimer_tg_class);
561}
562
563module_init(idletimer_tg_init);
564module_exit(idletimer_tg_exit);
565
566MODULE_AUTHOR("Timo Teras <ext-timo.teras@nokia.com>");
567MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
568MODULE_DESCRIPTION("Xtables: idle time monitor");
569MODULE_LICENSE("GPL v2");
570MODULE_ALIAS("ipt_IDLETIMER");
571MODULE_ALIAS("ip6t_IDLETIMER");