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