]>
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) | |
131 | { | |
6440fe05 | 132 | mutex_lock(&nf_log_mutex); |
f6ebe77f | 133 | |
7e9c6eeb | 134 | if (*pos >= ARRAY_SIZE(nf_loggers)) |
f6ebe77f HW |
135 | return NULL; |
136 | ||
137 | return pos; | |
138 | } | |
139 | ||
140 | static void *seq_next(struct seq_file *s, void *v, loff_t *pos) | |
141 | { | |
142 | (*pos)++; | |
143 | ||
7e9c6eeb | 144 | if (*pos >= ARRAY_SIZE(nf_loggers)) |
f6ebe77f HW |
145 | return NULL; |
146 | ||
147 | return pos; | |
148 | } | |
149 | ||
150 | static void seq_stop(struct seq_file *s, void *v) | |
151 | { | |
6440fe05 | 152 | mutex_unlock(&nf_log_mutex); |
f6ebe77f HW |
153 | } |
154 | ||
155 | static int seq_show(struct seq_file *s, void *v) | |
156 | { | |
157 | loff_t *pos = v; | |
158 | const struct nf_logger *logger; | |
c7a913cd EL |
159 | struct nf_logger *t; |
160 | int ret; | |
f6ebe77f | 161 | |
6440fe05 | 162 | logger = nf_loggers[*pos]; |
f6ebe77f HW |
163 | |
164 | if (!logger) | |
c7a913cd EL |
165 | ret = seq_printf(s, "%2lld NONE (", *pos); |
166 | else | |
167 | ret = seq_printf(s, "%2lld %s (", *pos, logger->name); | |
168 | ||
169 | if (ret < 0) | |
170 | return ret; | |
171 | ||
c7a913cd EL |
172 | list_for_each_entry(t, &nf_loggers_l[*pos], list[*pos]) { |
173 | ret = seq_printf(s, "%s", t->name); | |
6440fe05 | 174 | if (ret < 0) |
c7a913cd | 175 | return ret; |
c7a913cd EL |
176 | if (&t->list[*pos] != nf_loggers_l[*pos].prev) { |
177 | ret = seq_printf(s, ","); | |
6440fe05 | 178 | if (ret < 0) |
c7a913cd | 179 | return ret; |
c7a913cd EL |
180 | } |
181 | } | |
601e68e1 | 182 | |
c7a913cd | 183 | return seq_printf(s, ")\n"); |
f6ebe77f HW |
184 | } |
185 | ||
56b3d975 | 186 | static const struct seq_operations nflog_seq_ops = { |
f6ebe77f HW |
187 | .start = seq_start, |
188 | .next = seq_next, | |
189 | .stop = seq_stop, | |
190 | .show = seq_show, | |
191 | }; | |
192 | ||
193 | static int nflog_open(struct inode *inode, struct file *file) | |
194 | { | |
195 | return seq_open(file, &nflog_seq_ops); | |
196 | } | |
197 | ||
da7071d7 | 198 | static const struct file_operations nflog_file_ops = { |
f6ebe77f HW |
199 | .owner = THIS_MODULE, |
200 | .open = nflog_open, | |
201 | .read = seq_read, | |
202 | .llseek = seq_lseek, | |
203 | .release = seq_release, | |
204 | }; | |
205 | ||
17625274 | 206 | |
f6ebe77f HW |
207 | #endif /* PROC_FS */ |
208 | ||
17625274 | 209 | #ifdef CONFIG_SYSCTL |
24955619 | 210 | static struct ctl_path nf_log_sysctl_path[] = { |
f8572d8f EB |
211 | { .procname = "net", }, |
212 | { .procname = "netfilter", }, | |
213 | { .procname = "nf_log", }, | |
17625274 EL |
214 | { } |
215 | }; | |
216 | ||
217 | static char nf_log_sysctl_fnames[NFPROTO_NUMPROTO-NFPROTO_UNSPEC][3]; | |
218 | static struct ctl_table nf_log_sysctl_table[NFPROTO_NUMPROTO+1]; | |
219 | static struct ctl_table_header *nf_log_dir_header; | |
f6ebe77f | 220 | |
8d65af78 | 221 | static int nf_log_proc_dostring(ctl_table *table, int write, |
24955619 | 222 | void __user *buffer, size_t *lenp, loff_t *ppos) |
17625274 EL |
223 | { |
224 | const struct nf_logger *logger; | |
24955619 PM |
225 | char buf[NFLOGGER_NAME_LEN]; |
226 | size_t size = *lenp; | |
17625274 EL |
227 | int r = 0; |
228 | int tindex = (unsigned long)table->extra1; | |
229 | ||
230 | if (write) { | |
24955619 PM |
231 | if (size > sizeof(buf)) |
232 | size = sizeof(buf); | |
233 | if (copy_from_user(buf, buffer, size)) | |
234 | return -EFAULT; | |
235 | ||
236 | if (!strcmp(buf, "NONE")) { | |
17625274 EL |
237 | nf_log_unbind_pf(tindex); |
238 | return 0; | |
239 | } | |
240 | mutex_lock(&nf_log_mutex); | |
24955619 | 241 | logger = __find_logger(tindex, buf); |
17625274 EL |
242 | if (logger == NULL) { |
243 | mutex_unlock(&nf_log_mutex); | |
244 | return -ENOENT; | |
245 | } | |
246 | rcu_assign_pointer(nf_loggers[tindex], logger); | |
247 | mutex_unlock(&nf_log_mutex); | |
248 | } else { | |
266d07cb PM |
249 | mutex_lock(&nf_log_mutex); |
250 | logger = nf_loggers[tindex]; | |
17625274 EL |
251 | if (!logger) |
252 | table->data = "NONE"; | |
253 | else | |
254 | table->data = logger->name; | |
8d65af78 | 255 | r = proc_dostring(table, write, buffer, lenp, ppos); |
266d07cb | 256 | mutex_unlock(&nf_log_mutex); |
17625274 EL |
257 | } |
258 | ||
259 | return r; | |
260 | } | |
261 | ||
262 | static __init int netfilter_log_sysctl_init(void) | |
f6ebe77f | 263 | { |
ca735b3a | 264 | int i; |
17625274 EL |
265 | |
266 | for (i = NFPROTO_UNSPEC; i < NFPROTO_NUMPROTO; i++) { | |
267 | snprintf(nf_log_sysctl_fnames[i-NFPROTO_UNSPEC], 3, "%d", i); | |
17625274 EL |
268 | nf_log_sysctl_table[i].procname = |
269 | nf_log_sysctl_fnames[i-NFPROTO_UNSPEC]; | |
270 | nf_log_sysctl_table[i].data = NULL; | |
271 | nf_log_sysctl_table[i].maxlen = | |
272 | NFLOGGER_NAME_LEN * sizeof(char); | |
273 | nf_log_sysctl_table[i].mode = 0644; | |
274 | nf_log_sysctl_table[i].proc_handler = nf_log_proc_dostring; | |
275 | nf_log_sysctl_table[i].extra1 = (void *)(unsigned long) i; | |
276 | } | |
277 | ||
278 | nf_log_dir_header = register_sysctl_paths(nf_log_sysctl_path, | |
279 | nf_log_sysctl_table); | |
280 | if (!nf_log_dir_header) | |
281 | return -ENOMEM; | |
282 | ||
283 | return 0; | |
284 | } | |
285 | #else | |
286 | static __init int netfilter_log_sysctl_init(void) | |
287 | { | |
288 | return 0; | |
289 | } | |
290 | #endif /* CONFIG_SYSCTL */ | |
291 | ||
292 | int __init netfilter_log_init(void) | |
293 | { | |
294 | int i, r; | |
f6ebe77f | 295 | #ifdef CONFIG_PROC_FS |
8eeee8b1 DL |
296 | if (!proc_create("nf_log", S_IRUGO, |
297 | proc_net_netfilter, &nflog_file_ops)) | |
f6ebe77f | 298 | return -1; |
62243927 | 299 | #endif |
ca735b3a | 300 | |
17625274 EL |
301 | /* Errors will trigger panic, unroll on error is unnecessary. */ |
302 | r = netfilter_log_sysctl_init(); | |
303 | if (r < 0) | |
304 | return r; | |
305 | ||
ca735b3a EL |
306 | for (i = NFPROTO_UNSPEC; i < NFPROTO_NUMPROTO; i++) |
307 | INIT_LIST_HEAD(&(nf_loggers_l[i])); | |
308 | ||
f6ebe77f HW |
309 | return 0; |
310 | } |