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 | { |
b56f2d55 | 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]); | |
b56f2d55 PM |
55 | llog = rcu_dereference_protected(nf_loggers[pf], |
56 | lockdep_is_held(&nf_log_mutex)); | |
57 | if (llog == NULL) | |
ca735b3a EL |
58 | rcu_assign_pointer(nf_loggers[pf], logger); |
59 | } | |
60 | ||
9b73534d | 61 | mutex_unlock(&nf_log_mutex); |
f6ebe77f | 62 | |
ca735b3a | 63 | return 0; |
f6ebe77f | 64 | } |
ca735b3a | 65 | EXPORT_SYMBOL(nf_log_register); |
f6ebe77f | 66 | |
ca735b3a | 67 | void nf_log_unregister(struct nf_logger *logger) |
f6ebe77f | 68 | { |
b56f2d55 | 69 | const struct nf_logger *c_logger; |
f6ebe77f HW |
70 | int i; |
71 | ||
9b73534d | 72 | mutex_lock(&nf_log_mutex); |
7e9c6eeb | 73 | for (i = 0; i < ARRAY_SIZE(nf_loggers); i++) { |
b56f2d55 PM |
74 | c_logger = rcu_dereference_protected(nf_loggers[i], |
75 | lockdep_is_held(&nf_log_mutex)); | |
76 | if (c_logger == logger) | |
e92ad99c | 77 | rcu_assign_pointer(nf_loggers[i], NULL); |
ca735b3a | 78 | list_del(&logger->list[i]); |
f6ebe77f | 79 | } |
9b73534d | 80 | mutex_unlock(&nf_log_mutex); |
f6ebe77f | 81 | |
a5ea6169 | 82 | synchronize_rcu(); |
f6ebe77f | 83 | } |
e92ad99c | 84 | EXPORT_SYMBOL(nf_log_unregister); |
f6ebe77f | 85 | |
ca735b3a EL |
86 | int nf_log_bind_pf(u_int8_t pf, const struct nf_logger *logger) |
87 | { | |
88 | mutex_lock(&nf_log_mutex); | |
89 | if (__find_logger(pf, logger->name) == NULL) { | |
90 | mutex_unlock(&nf_log_mutex); | |
91 | return -ENOENT; | |
92 | } | |
93 | rcu_assign_pointer(nf_loggers[pf], logger); | |
94 | mutex_unlock(&nf_log_mutex); | |
95 | return 0; | |
96 | } | |
97 | EXPORT_SYMBOL(nf_log_bind_pf); | |
98 | ||
99 | void nf_log_unbind_pf(u_int8_t pf) | |
100 | { | |
101 | mutex_lock(&nf_log_mutex); | |
102 | rcu_assign_pointer(nf_loggers[pf], NULL); | |
103 | mutex_unlock(&nf_log_mutex); | |
104 | } | |
105 | EXPORT_SYMBOL(nf_log_unbind_pf); | |
106 | ||
76108cea | 107 | void nf_log_packet(u_int8_t pf, |
f6ebe77f HW |
108 | unsigned int hooknum, |
109 | const struct sk_buff *skb, | |
110 | const struct net_device *in, | |
111 | const struct net_device *out, | |
7b2f9631 | 112 | const struct nf_loginfo *loginfo, |
f6ebe77f HW |
113 | const char *fmt, ...) |
114 | { | |
115 | va_list args; | |
116 | char prefix[NF_LOG_PREFIXLEN]; | |
7b2f9631 | 117 | const struct nf_logger *logger; |
601e68e1 | 118 | |
f6ebe77f | 119 | rcu_read_lock(); |
e92ad99c | 120 | logger = rcu_dereference(nf_loggers[pf]); |
f6ebe77f HW |
121 | if (logger) { |
122 | va_start(args, fmt); | |
123 | vsnprintf(prefix, sizeof(prefix), fmt, args); | |
124 | va_end(args); | |
f6ebe77f | 125 | logger->logfn(pf, hooknum, skb, in, out, loginfo, prefix); |
f6ebe77f HW |
126 | } |
127 | rcu_read_unlock(); | |
128 | } | |
129 | EXPORT_SYMBOL(nf_log_packet); | |
130 | ||
131 | #ifdef CONFIG_PROC_FS | |
132 | static void *seq_start(struct seq_file *seq, loff_t *pos) | |
133 | { | |
6440fe05 | 134 | mutex_lock(&nf_log_mutex); |
f6ebe77f | 135 | |
7e9c6eeb | 136 | if (*pos >= ARRAY_SIZE(nf_loggers)) |
f6ebe77f HW |
137 | return NULL; |
138 | ||
139 | return pos; | |
140 | } | |
141 | ||
142 | static void *seq_next(struct seq_file *s, void *v, loff_t *pos) | |
143 | { | |
144 | (*pos)++; | |
145 | ||
7e9c6eeb | 146 | if (*pos >= ARRAY_SIZE(nf_loggers)) |
f6ebe77f HW |
147 | return NULL; |
148 | ||
149 | return pos; | |
150 | } | |
151 | ||
152 | static void seq_stop(struct seq_file *s, void *v) | |
153 | { | |
6440fe05 | 154 | mutex_unlock(&nf_log_mutex); |
f6ebe77f HW |
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 | |
6440fe05 | 164 | logger = 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 | ||
c7a913cd EL |
174 | list_for_each_entry(t, &nf_loggers_l[*pos], list[*pos]) { |
175 | ret = seq_printf(s, "%s", t->name); | |
6440fe05 | 176 | if (ret < 0) |
c7a913cd | 177 | return ret; |
c7a913cd EL |
178 | if (&t->list[*pos] != nf_loggers_l[*pos].prev) { |
179 | ret = seq_printf(s, ","); | |
6440fe05 | 180 | if (ret < 0) |
c7a913cd | 181 | return ret; |
c7a913cd EL |
182 | } |
183 | } | |
601e68e1 | 184 | |
c7a913cd | 185 | return seq_printf(s, ")\n"); |
f6ebe77f HW |
186 | } |
187 | ||
56b3d975 | 188 | static const struct seq_operations nflog_seq_ops = { |
f6ebe77f HW |
189 | .start = seq_start, |
190 | .next = seq_next, | |
191 | .stop = seq_stop, | |
192 | .show = seq_show, | |
193 | }; | |
194 | ||
195 | static int nflog_open(struct inode *inode, struct file *file) | |
196 | { | |
197 | return seq_open(file, &nflog_seq_ops); | |
198 | } | |
199 | ||
da7071d7 | 200 | static const struct file_operations nflog_file_ops = { |
f6ebe77f HW |
201 | .owner = THIS_MODULE, |
202 | .open = nflog_open, | |
203 | .read = seq_read, | |
204 | .llseek = seq_lseek, | |
205 | .release = seq_release, | |
206 | }; | |
207 | ||
17625274 | 208 | |
f6ebe77f HW |
209 | #endif /* PROC_FS */ |
210 | ||
17625274 | 211 | #ifdef CONFIG_SYSCTL |
24955619 | 212 | static struct ctl_path nf_log_sysctl_path[] = { |
f8572d8f EB |
213 | { .procname = "net", }, |
214 | { .procname = "netfilter", }, | |
215 | { .procname = "nf_log", }, | |
17625274 EL |
216 | { } |
217 | }; | |
218 | ||
219 | static char nf_log_sysctl_fnames[NFPROTO_NUMPROTO-NFPROTO_UNSPEC][3]; | |
220 | static struct ctl_table nf_log_sysctl_table[NFPROTO_NUMPROTO+1]; | |
221 | static struct ctl_table_header *nf_log_dir_header; | |
f6ebe77f | 222 | |
8d65af78 | 223 | static int nf_log_proc_dostring(ctl_table *table, int write, |
24955619 | 224 | void __user *buffer, size_t *lenp, loff_t *ppos) |
17625274 EL |
225 | { |
226 | const struct nf_logger *logger; | |
24955619 PM |
227 | char buf[NFLOGGER_NAME_LEN]; |
228 | size_t size = *lenp; | |
17625274 EL |
229 | int r = 0; |
230 | int tindex = (unsigned long)table->extra1; | |
231 | ||
232 | if (write) { | |
24955619 PM |
233 | if (size > sizeof(buf)) |
234 | size = sizeof(buf); | |
235 | if (copy_from_user(buf, buffer, size)) | |
236 | return -EFAULT; | |
237 | ||
238 | if (!strcmp(buf, "NONE")) { | |
17625274 EL |
239 | nf_log_unbind_pf(tindex); |
240 | return 0; | |
241 | } | |
242 | mutex_lock(&nf_log_mutex); | |
24955619 | 243 | logger = __find_logger(tindex, buf); |
17625274 EL |
244 | if (logger == NULL) { |
245 | mutex_unlock(&nf_log_mutex); | |
246 | return -ENOENT; | |
247 | } | |
248 | rcu_assign_pointer(nf_loggers[tindex], logger); | |
249 | mutex_unlock(&nf_log_mutex); | |
250 | } else { | |
266d07cb PM |
251 | mutex_lock(&nf_log_mutex); |
252 | logger = nf_loggers[tindex]; | |
17625274 EL |
253 | if (!logger) |
254 | table->data = "NONE"; | |
255 | else | |
256 | table->data = logger->name; | |
8d65af78 | 257 | r = proc_dostring(table, write, buffer, lenp, ppos); |
266d07cb | 258 | mutex_unlock(&nf_log_mutex); |
17625274 EL |
259 | } |
260 | ||
261 | return r; | |
262 | } | |
263 | ||
264 | static __init int netfilter_log_sysctl_init(void) | |
f6ebe77f | 265 | { |
ca735b3a | 266 | int i; |
17625274 EL |
267 | |
268 | for (i = NFPROTO_UNSPEC; i < NFPROTO_NUMPROTO; i++) { | |
269 | snprintf(nf_log_sysctl_fnames[i-NFPROTO_UNSPEC], 3, "%d", i); | |
17625274 EL |
270 | nf_log_sysctl_table[i].procname = |
271 | nf_log_sysctl_fnames[i-NFPROTO_UNSPEC]; | |
272 | nf_log_sysctl_table[i].data = NULL; | |
273 | nf_log_sysctl_table[i].maxlen = | |
274 | NFLOGGER_NAME_LEN * sizeof(char); | |
275 | nf_log_sysctl_table[i].mode = 0644; | |
276 | nf_log_sysctl_table[i].proc_handler = nf_log_proc_dostring; | |
277 | nf_log_sysctl_table[i].extra1 = (void *)(unsigned long) i; | |
278 | } | |
279 | ||
280 | nf_log_dir_header = register_sysctl_paths(nf_log_sysctl_path, | |
281 | nf_log_sysctl_table); | |
282 | if (!nf_log_dir_header) | |
283 | return -ENOMEM; | |
284 | ||
285 | return 0; | |
286 | } | |
287 | #else | |
288 | static __init int netfilter_log_sysctl_init(void) | |
289 | { | |
290 | return 0; | |
291 | } | |
292 | #endif /* CONFIG_SYSCTL */ | |
293 | ||
294 | int __init netfilter_log_init(void) | |
295 | { | |
296 | int i, r; | |
f6ebe77f | 297 | #ifdef CONFIG_PROC_FS |
8eeee8b1 DL |
298 | if (!proc_create("nf_log", S_IRUGO, |
299 | proc_net_netfilter, &nflog_file_ops)) | |
f6ebe77f | 300 | return -1; |
62243927 | 301 | #endif |
ca735b3a | 302 | |
17625274 EL |
303 | /* Errors will trigger panic, unroll on error is unnecessary. */ |
304 | r = netfilter_log_sysctl_init(); | |
305 | if (r < 0) | |
306 | return r; | |
307 | ||
ca735b3a EL |
308 | for (i = NFPROTO_UNSPEC; i < NFPROTO_NUMPROTO; i++) |
309 | INIT_LIST_HEAD(&(nf_loggers_l[i])); | |
310 | ||
f6ebe77f HW |
311 | return 0; |
312 | } |