Commit | Line | Data |
---|---|---|
f6ebe77f HW |
1 | #include <linux/kernel.h> |
2 | #include <linux/init.h> | |
3 | #include <linux/module.h> | |
4 | #include <linux/proc_fs.h> | |
5 | #include <linux/skbuff.h> | |
6 | #include <linux/netfilter.h> | |
bbd86b9f | 7 | #include <linux/seq_file.h> |
f6ebe77f | 8 | #include <net/protocol.h> |
f01ffbd6 | 9 | #include <net/netfilter/nf_log.h> |
f6ebe77f HW |
10 | |
11 | #include "nf_internals.h" | |
12 | ||
a5d29264 | 13 | /* Internal logging interface, which relies on the real |
f6ebe77f HW |
14 | LOG target modules */ |
15 | ||
16 | #define NF_LOG_PREFIXLEN 128 | |
17625274 | 17 | #define NFLOGGER_NAME_LEN 64 |
f6ebe77f | 18 | |
7e9c6eeb | 19 | static const struct nf_logger *nf_loggers[NFPROTO_NUMPROTO] __read_mostly; |
ca735b3a | 20 | static struct list_head nf_loggers_l[NFPROTO_NUMPROTO] __read_mostly; |
9b73534d | 21 | static DEFINE_MUTEX(nf_log_mutex); |
f6ebe77f | 22 | |
ca735b3a | 23 | static struct nf_logger *__find_logger(int pf, const char *str_logger) |
f6ebe77f | 24 | { |
ca735b3a | 25 | struct nf_logger *t; |
f6ebe77f | 26 | |
ca735b3a EL |
27 | list_for_each_entry(t, &nf_loggers_l[pf], list[pf]) { |
28 | if (!strnicmp(str_logger, t->name, strlen(t->name))) | |
29 | return t; | |
30 | } | |
d72367b6 | 31 | |
ca735b3a | 32 | return NULL; |
601e68e1 | 33 | } |
f6ebe77f | 34 | |
ca735b3a EL |
35 | /* return EEXIST if the same logger is registred, 0 on success. */ |
36 | int nf_log_register(u_int8_t pf, struct nf_logger *logger) | |
f6ebe77f | 37 | { |
ca735b3a | 38 | const struct nf_logger *llog; |
b6f0a365 | 39 | int i; |
ca735b3a | 40 | |
7e9c6eeb | 41 | if (pf >= ARRAY_SIZE(nf_loggers)) |
ca735b3a EL |
42 | return -EINVAL; |
43 | ||
b6f0a365 ED |
44 | for (i = 0; i < ARRAY_SIZE(logger->list); i++) |
45 | INIT_LIST_HEAD(&logger->list[i]); | |
46 | ||
9b73534d | 47 | mutex_lock(&nf_log_mutex); |
ca735b3a EL |
48 | |
49 | if (pf == NFPROTO_UNSPEC) { | |
ca735b3a EL |
50 | for (i = NFPROTO_UNSPEC; i < NFPROTO_NUMPROTO; i++) |
51 | list_add_tail(&(logger->list[i]), &(nf_loggers_l[i])); | |
52 | } else { | |
53 | /* register at end of list to honor first register win */ | |
54 | list_add_tail(&logger->list[pf], &nf_loggers_l[pf]); | |
55 | llog = rcu_dereference(nf_loggers[pf]); | |
56 | if (llog == NULL) | |
57 | rcu_assign_pointer(nf_loggers[pf], logger); | |
58 | } | |
59 | ||
9b73534d | 60 | mutex_unlock(&nf_log_mutex); |
f6ebe77f | 61 | |
ca735b3a | 62 | return 0; |
f6ebe77f | 63 | } |
ca735b3a | 64 | EXPORT_SYMBOL(nf_log_register); |
f6ebe77f | 65 | |
ca735b3a | 66 | void nf_log_unregister(struct nf_logger *logger) |
f6ebe77f | 67 | { |
ca735b3a | 68 | const struct nf_logger *c_logger; |
f6ebe77f HW |
69 | int i; |
70 | ||
9b73534d | 71 | mutex_lock(&nf_log_mutex); |
7e9c6eeb | 72 | for (i = 0; i < ARRAY_SIZE(nf_loggers); i++) { |
ca735b3a EL |
73 | c_logger = rcu_dereference(nf_loggers[i]); |
74 | if (c_logger == logger) | |
e92ad99c | 75 | rcu_assign_pointer(nf_loggers[i], NULL); |
ca735b3a | 76 | list_del(&logger->list[i]); |
f6ebe77f | 77 | } |
9b73534d | 78 | mutex_unlock(&nf_log_mutex); |
f6ebe77f | 79 | |
a5ea6169 | 80 | synchronize_rcu(); |
f6ebe77f | 81 | } |
e92ad99c | 82 | EXPORT_SYMBOL(nf_log_unregister); |
f6ebe77f | 83 | |
ca735b3a EL |
84 | int nf_log_bind_pf(u_int8_t pf, const struct nf_logger *logger) |
85 | { | |
86 | mutex_lock(&nf_log_mutex); | |
87 | if (__find_logger(pf, logger->name) == NULL) { | |
88 | mutex_unlock(&nf_log_mutex); | |
89 | return -ENOENT; | |
90 | } | |
91 | rcu_assign_pointer(nf_loggers[pf], logger); | |
92 | mutex_unlock(&nf_log_mutex); | |
93 | return 0; | |
94 | } | |
95 | EXPORT_SYMBOL(nf_log_bind_pf); | |
96 | ||
97 | void nf_log_unbind_pf(u_int8_t pf) | |
98 | { | |
99 | mutex_lock(&nf_log_mutex); | |
100 | rcu_assign_pointer(nf_loggers[pf], NULL); | |
101 | mutex_unlock(&nf_log_mutex); | |
102 | } | |
103 | EXPORT_SYMBOL(nf_log_unbind_pf); | |
104 | ||
76108cea | 105 | void nf_log_packet(u_int8_t pf, |
f6ebe77f HW |
106 | unsigned int hooknum, |
107 | const struct sk_buff *skb, | |
108 | const struct net_device *in, | |
109 | const struct net_device *out, | |
7b2f9631 | 110 | const struct nf_loginfo *loginfo, |
f6ebe77f HW |
111 | const char *fmt, ...) |
112 | { | |
113 | va_list args; | |
114 | char prefix[NF_LOG_PREFIXLEN]; | |
7b2f9631 | 115 | const struct nf_logger *logger; |
601e68e1 | 116 | |
f6ebe77f | 117 | rcu_read_lock(); |
e92ad99c | 118 | logger = rcu_dereference(nf_loggers[pf]); |
f6ebe77f HW |
119 | if (logger) { |
120 | va_start(args, fmt); | |
121 | vsnprintf(prefix, sizeof(prefix), fmt, args); | |
122 | va_end(args); | |
f6ebe77f | 123 | logger->logfn(pf, hooknum, skb, in, out, loginfo, prefix); |
f6ebe77f HW |
124 | } |
125 | rcu_read_unlock(); | |
126 | } | |
127 | EXPORT_SYMBOL(nf_log_packet); | |
128 | ||
129 | #ifdef CONFIG_PROC_FS | |
130 | static void *seq_start(struct seq_file *seq, loff_t *pos) | |
ca7c48ca | 131 | __acquires(RCU) |
f6ebe77f HW |
132 | { |
133 | rcu_read_lock(); | |
134 | ||
7e9c6eeb | 135 | if (*pos >= ARRAY_SIZE(nf_loggers)) |
f6ebe77f HW |
136 | return NULL; |
137 | ||
138 | return pos; | |
139 | } | |
140 | ||
141 | static void *seq_next(struct seq_file *s, void *v, loff_t *pos) | |
142 | { | |
143 | (*pos)++; | |
144 | ||
7e9c6eeb | 145 | if (*pos >= ARRAY_SIZE(nf_loggers)) |
f6ebe77f HW |
146 | return NULL; |
147 | ||
148 | return pos; | |
149 | } | |
150 | ||
151 | static void seq_stop(struct seq_file *s, void *v) | |
ca7c48ca | 152 | __releases(RCU) |
f6ebe77f HW |
153 | { |
154 | rcu_read_unlock(); | |
155 | } | |
156 | ||
157 | static int seq_show(struct seq_file *s, void *v) | |
158 | { | |
159 | loff_t *pos = v; | |
160 | const struct nf_logger *logger; | |
c7a913cd EL |
161 | struct nf_logger *t; |
162 | int ret; | |
f6ebe77f | 163 | |
e92ad99c | 164 | logger = rcu_dereference(nf_loggers[*pos]); |
f6ebe77f HW |
165 | |
166 | if (!logger) | |
c7a913cd EL |
167 | ret = seq_printf(s, "%2lld NONE (", *pos); |
168 | else | |
169 | ret = seq_printf(s, "%2lld %s (", *pos, logger->name); | |
170 | ||
171 | if (ret < 0) | |
172 | return ret; | |
173 | ||
174 | mutex_lock(&nf_log_mutex); | |
175 | list_for_each_entry(t, &nf_loggers_l[*pos], list[*pos]) { | |
176 | ret = seq_printf(s, "%s", t->name); | |
177 | if (ret < 0) { | |
178 | mutex_unlock(&nf_log_mutex); | |
179 | return ret; | |
180 | } | |
181 | if (&t->list[*pos] != nf_loggers_l[*pos].prev) { | |
182 | ret = seq_printf(s, ","); | |
183 | if (ret < 0) { | |
184 | mutex_unlock(&nf_log_mutex); | |
185 | return ret; | |
186 | } | |
187 | } | |
188 | } | |
189 | mutex_unlock(&nf_log_mutex); | |
601e68e1 | 190 | |
c7a913cd | 191 | return seq_printf(s, ")\n"); |
f6ebe77f HW |
192 | } |
193 | ||
56b3d975 | 194 | static const struct seq_operations nflog_seq_ops = { |
f6ebe77f HW |
195 | .start = seq_start, |
196 | .next = seq_next, | |
197 | .stop = seq_stop, | |
198 | .show = seq_show, | |
199 | }; | |
200 | ||
201 | static int nflog_open(struct inode *inode, struct file *file) | |
202 | { | |
203 | return seq_open(file, &nflog_seq_ops); | |
204 | } | |
205 | ||
da7071d7 | 206 | static const struct file_operations nflog_file_ops = { |
f6ebe77f HW |
207 | .owner = THIS_MODULE, |
208 | .open = nflog_open, | |
209 | .read = seq_read, | |
210 | .llseek = seq_lseek, | |
211 | .release = seq_release, | |
212 | }; | |
213 | ||
17625274 | 214 | |
f6ebe77f HW |
215 | #endif /* PROC_FS */ |
216 | ||
17625274 | 217 | #ifdef CONFIG_SYSCTL |
24955619 | 218 | static struct ctl_path nf_log_sysctl_path[] = { |
17625274 EL |
219 | { .procname = "net", .ctl_name = CTL_NET, }, |
220 | { .procname = "netfilter", .ctl_name = NET_NETFILTER, }, | |
221 | { .procname = "nf_log", .ctl_name = CTL_UNNUMBERED, }, | |
222 | { } | |
223 | }; | |
224 | ||
225 | static char nf_log_sysctl_fnames[NFPROTO_NUMPROTO-NFPROTO_UNSPEC][3]; | |
226 | static struct ctl_table nf_log_sysctl_table[NFPROTO_NUMPROTO+1]; | |
227 | static struct ctl_table_header *nf_log_dir_header; | |
f6ebe77f | 228 | |
17625274 | 229 | static int nf_log_proc_dostring(ctl_table *table, int write, struct file *filp, |
24955619 | 230 | void __user *buffer, size_t *lenp, loff_t *ppos) |
17625274 EL |
231 | { |
232 | const struct nf_logger *logger; | |
24955619 PM |
233 | char buf[NFLOGGER_NAME_LEN]; |
234 | size_t size = *lenp; | |
17625274 EL |
235 | int r = 0; |
236 | int tindex = (unsigned long)table->extra1; | |
237 | ||
238 | if (write) { | |
24955619 PM |
239 | if (size > sizeof(buf)) |
240 | size = sizeof(buf); | |
241 | if (copy_from_user(buf, buffer, size)) | |
242 | return -EFAULT; | |
243 | ||
244 | if (!strcmp(buf, "NONE")) { | |
17625274 EL |
245 | nf_log_unbind_pf(tindex); |
246 | return 0; | |
247 | } | |
248 | mutex_lock(&nf_log_mutex); | |
24955619 | 249 | logger = __find_logger(tindex, buf); |
17625274 EL |
250 | if (logger == NULL) { |
251 | mutex_unlock(&nf_log_mutex); | |
252 | return -ENOENT; | |
253 | } | |
254 | rcu_assign_pointer(nf_loggers[tindex], logger); | |
255 | mutex_unlock(&nf_log_mutex); | |
256 | } else { | |
266d07cb PM |
257 | mutex_lock(&nf_log_mutex); |
258 | logger = nf_loggers[tindex]; | |
17625274 EL |
259 | if (!logger) |
260 | table->data = "NONE"; | |
261 | else | |
262 | table->data = logger->name; | |
263 | r = proc_dostring(table, write, filp, buffer, lenp, ppos); | |
266d07cb | 264 | mutex_unlock(&nf_log_mutex); |
17625274 EL |
265 | } |
266 | ||
267 | return r; | |
268 | } | |
269 | ||
270 | static __init int netfilter_log_sysctl_init(void) | |
f6ebe77f | 271 | { |
ca735b3a | 272 | int i; |
17625274 EL |
273 | |
274 | for (i = NFPROTO_UNSPEC; i < NFPROTO_NUMPROTO; i++) { | |
275 | snprintf(nf_log_sysctl_fnames[i-NFPROTO_UNSPEC], 3, "%d", i); | |
276 | nf_log_sysctl_table[i].ctl_name = CTL_UNNUMBERED; | |
277 | nf_log_sysctl_table[i].procname = | |
278 | nf_log_sysctl_fnames[i-NFPROTO_UNSPEC]; | |
279 | nf_log_sysctl_table[i].data = NULL; | |
280 | nf_log_sysctl_table[i].maxlen = | |
281 | NFLOGGER_NAME_LEN * sizeof(char); | |
282 | nf_log_sysctl_table[i].mode = 0644; | |
283 | nf_log_sysctl_table[i].proc_handler = nf_log_proc_dostring; | |
284 | nf_log_sysctl_table[i].extra1 = (void *)(unsigned long) i; | |
285 | } | |
286 | ||
287 | nf_log_dir_header = register_sysctl_paths(nf_log_sysctl_path, | |
288 | nf_log_sysctl_table); | |
289 | if (!nf_log_dir_header) | |
290 | return -ENOMEM; | |
291 | ||
292 | return 0; | |
293 | } | |
294 | #else | |
295 | static __init int netfilter_log_sysctl_init(void) | |
296 | { | |
297 | return 0; | |
298 | } | |
299 | #endif /* CONFIG_SYSCTL */ | |
300 | ||
301 | int __init netfilter_log_init(void) | |
302 | { | |
303 | int i, r; | |
f6ebe77f | 304 | #ifdef CONFIG_PROC_FS |
8eeee8b1 DL |
305 | if (!proc_create("nf_log", S_IRUGO, |
306 | proc_net_netfilter, &nflog_file_ops)) | |
f6ebe77f | 307 | return -1; |
62243927 | 308 | #endif |
ca735b3a | 309 | |
17625274 EL |
310 | /* Errors will trigger panic, unroll on error is unnecessary. */ |
311 | r = netfilter_log_sysctl_init(); | |
312 | if (r < 0) | |
313 | return r; | |
314 | ||
ca735b3a EL |
315 | for (i = NFPROTO_UNSPEC; i < NFPROTO_NUMPROTO; i++) |
316 | INIT_LIST_HEAD(&(nf_loggers_l[i])); | |
317 | ||
f6ebe77f HW |
318 | return 0; |
319 | } |