xref: /openbmc/linux/net/netfilter/xt_LED.c (revision 997f67d8)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * xt_LED.c - netfilter target to make LEDs blink upon packet matches
4  *
5  * Copyright (C) 2008 Adam Nielsen <a.nielsen@shikadi.net>
6  */
7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
8 #include <linux/module.h>
9 #include <linux/skbuff.h>
10 #include <linux/netfilter/x_tables.h>
11 #include <linux/slab.h>
12 #include <linux/leds.h>
13 #include <linux/mutex.h>
14 
15 #include <linux/netfilter/xt_LED.h>
16 
17 MODULE_LICENSE("GPL");
18 MODULE_AUTHOR("Adam Nielsen <a.nielsen@shikadi.net>");
19 MODULE_DESCRIPTION("Xtables: trigger LED devices on packet match");
20 MODULE_ALIAS("ipt_LED");
21 MODULE_ALIAS("ip6t_LED");
22 
23 static LIST_HEAD(xt_led_triggers);
24 static DEFINE_MUTEX(xt_led_mutex);
25 
26 /*
27  * This is declared in here (the kernel module) only, to avoid having these
28  * dependencies in userspace code.  This is what xt_led_info.internal_data
29  * points to.
30  */
31 struct xt_led_info_internal {
32 	struct list_head list;
33 	int refcnt;
34 	char *trigger_id;
35 	struct led_trigger netfilter_led_trigger;
36 	struct timer_list timer;
37 };
38 
39 #define XT_LED_BLINK_DELAY 50 /* ms */
40 
41 static unsigned int
led_tg(struct sk_buff * skb,const struct xt_action_param * par)42 led_tg(struct sk_buff *skb, const struct xt_action_param *par)
43 {
44 	const struct xt_led_info *ledinfo = par->targinfo;
45 	struct xt_led_info_internal *ledinternal = ledinfo->internal_data;
46 
47 	/*
48 	 * If "always blink" is enabled, and there's still some time until the
49 	 * LED will switch off, briefly switch it off now.
50 	 */
51 	if ((ledinfo->delay > 0) && ledinfo->always_blink &&
52 	    timer_pending(&ledinternal->timer))
53 		led_trigger_blink_oneshot(&ledinternal->netfilter_led_trigger,
54 					  XT_LED_BLINK_DELAY, XT_LED_BLINK_DELAY, 1);
55 	else
56 		led_trigger_event(&ledinternal->netfilter_led_trigger, LED_FULL);
57 
58 	/* If there's a positive delay, start/update the timer */
59 	if (ledinfo->delay > 0) {
60 		mod_timer(&ledinternal->timer,
61 			  jiffies + msecs_to_jiffies(ledinfo->delay));
62 
63 	/* Otherwise if there was no delay given, blink as fast as possible */
64 	} else if (ledinfo->delay == 0) {
65 		led_trigger_event(&ledinternal->netfilter_led_trigger, LED_OFF);
66 	}
67 
68 	/* else the delay is negative, which means switch on and stay on */
69 
70 	return XT_CONTINUE;
71 }
72 
led_timeout_callback(struct timer_list * t)73 static void led_timeout_callback(struct timer_list *t)
74 {
75 	struct xt_led_info_internal *ledinternal = from_timer(ledinternal, t,
76 							      timer);
77 
78 	led_trigger_event(&ledinternal->netfilter_led_trigger, LED_OFF);
79 }
80 
led_trigger_lookup(const char * name)81 static struct xt_led_info_internal *led_trigger_lookup(const char *name)
82 {
83 	struct xt_led_info_internal *ledinternal;
84 
85 	list_for_each_entry(ledinternal, &xt_led_triggers, list) {
86 		if (!strcmp(name, ledinternal->netfilter_led_trigger.name)) {
87 			return ledinternal;
88 		}
89 	}
90 	return NULL;
91 }
92 
led_tg_check(const struct xt_tgchk_param * par)93 static int led_tg_check(const struct xt_tgchk_param *par)
94 {
95 	struct xt_led_info *ledinfo = par->targinfo;
96 	struct xt_led_info_internal *ledinternal;
97 	int err;
98 
99 	if (ledinfo->id[0] == '\0')
100 		return -EINVAL;
101 
102 	mutex_lock(&xt_led_mutex);
103 
104 	ledinternal = led_trigger_lookup(ledinfo->id);
105 	if (ledinternal) {
106 		ledinternal->refcnt++;
107 		goto out;
108 	}
109 
110 	err = -ENOMEM;
111 	ledinternal = kzalloc(sizeof(struct xt_led_info_internal), GFP_KERNEL);
112 	if (!ledinternal)
113 		goto exit_mutex_only;
114 
115 	ledinternal->trigger_id = kstrdup(ledinfo->id, GFP_KERNEL);
116 	if (!ledinternal->trigger_id)
117 		goto exit_internal_alloc;
118 
119 	ledinternal->refcnt = 1;
120 	ledinternal->netfilter_led_trigger.name = ledinternal->trigger_id;
121 
122 	err = led_trigger_register(&ledinternal->netfilter_led_trigger);
123 	if (err) {
124 		pr_info_ratelimited("Trigger name is already in use.\n");
125 		goto exit_alloc;
126 	}
127 
128 	/* Since the letinternal timer can be shared between multiple targets,
129 	 * always set it up, even if the current target does not need it
130 	 */
131 	timer_setup(&ledinternal->timer, led_timeout_callback, 0);
132 
133 	list_add_tail(&ledinternal->list, &xt_led_triggers);
134 
135 out:
136 	mutex_unlock(&xt_led_mutex);
137 
138 	ledinfo->internal_data = ledinternal;
139 
140 	return 0;
141 
142 exit_alloc:
143 	kfree(ledinternal->trigger_id);
144 
145 exit_internal_alloc:
146 	kfree(ledinternal);
147 
148 exit_mutex_only:
149 	mutex_unlock(&xt_led_mutex);
150 
151 	return err;
152 }
153 
led_tg_destroy(const struct xt_tgdtor_param * par)154 static void led_tg_destroy(const struct xt_tgdtor_param *par)
155 {
156 	const struct xt_led_info *ledinfo = par->targinfo;
157 	struct xt_led_info_internal *ledinternal = ledinfo->internal_data;
158 
159 	mutex_lock(&xt_led_mutex);
160 
161 	if (--ledinternal->refcnt) {
162 		mutex_unlock(&xt_led_mutex);
163 		return;
164 	}
165 
166 	list_del(&ledinternal->list);
167 
168 	timer_shutdown_sync(&ledinternal->timer);
169 
170 	led_trigger_unregister(&ledinternal->netfilter_led_trigger);
171 
172 	mutex_unlock(&xt_led_mutex);
173 
174 	kfree(ledinternal->trigger_id);
175 	kfree(ledinternal);
176 }
177 
178 static struct xt_target led_tg_reg[] __read_mostly = {
179 	{
180 		.name		= "LED",
181 		.revision	= 0,
182 		.family		= NFPROTO_IPV4,
183 		.target		= led_tg,
184 		.targetsize	= sizeof(struct xt_led_info),
185 		.usersize	= offsetof(struct xt_led_info, internal_data),
186 		.checkentry	= led_tg_check,
187 		.destroy	= led_tg_destroy,
188 		.me		= THIS_MODULE,
189 	},
190 #if IS_ENABLED(CONFIG_IP6_NF_IPTABLES)
191 	{
192 		.name		= "LED",
193 		.revision	= 0,
194 		.family		= NFPROTO_IPV6,
195 		.target		= led_tg,
196 		.targetsize	= sizeof(struct xt_led_info),
197 		.usersize	= offsetof(struct xt_led_info, internal_data),
198 		.checkentry	= led_tg_check,
199 		.destroy	= led_tg_destroy,
200 		.me		= THIS_MODULE,
201 	},
202 #endif
203 };
204 
led_tg_init(void)205 static int __init led_tg_init(void)
206 {
207 	return xt_register_targets(led_tg_reg, ARRAY_SIZE(led_tg_reg));
208 }
209 
led_tg_exit(void)210 static void __exit led_tg_exit(void)
211 {
212 	xt_unregister_targets(led_tg_reg, ARRAY_SIZE(led_tg_reg));
213 }
214 
215 module_init(led_tg_init);
216 module_exit(led_tg_exit);
217