509a95621f9f5e68a93916414717beae2b69a60f
[linux-2.6.git] / net / netfilter / x_tables.c
1 /*
2  * x_tables core - Backend for {ip,ip6,arp}_tables
3  *
4  * Copyright (C) 2006-2006 Harald Welte <laforge@netfilter.org>
5  *
6  * Based on existing ip_tables code which is
7  *   Copyright (C) 1999 Paul `Rusty' Russell & Michael J. Neuling
8  *   Copyright (C) 2000-2005 Netfilter Core Team <coreteam@netfilter.org>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License version 2 as
12  * published by the Free Software Foundation.
13  *
14  */
15
16 #include <linux/kernel.h>
17 #include <linux/socket.h>
18 #include <linux/net.h>
19 #include <linux/proc_fs.h>
20 #include <linux/seq_file.h>
21 #include <linux/string.h>
22 #include <linux/vmalloc.h>
23 #include <linux/mutex.h>
24 #include <linux/mm.h>
25 #include <net/net_namespace.h>
26
27 #include <linux/netfilter/x_tables.h>
28 #include <linux/netfilter_arp.h>
29
30
31 MODULE_LICENSE("GPL");
32 MODULE_AUTHOR("Harald Welte <laforge@netfilter.org>");
33 MODULE_DESCRIPTION("{ip,ip6,arp,eb}_tables backend module");
34
35 #define SMP_ALIGN(x) (((x) + SMP_CACHE_BYTES-1) & ~(SMP_CACHE_BYTES-1))
36
37 struct compat_delta {
38         struct compat_delta *next;
39         unsigned int offset;
40         short delta;
41 };
42
43 struct xt_af {
44         struct mutex mutex;
45         struct list_head match;
46         struct list_head target;
47 #ifdef CONFIG_COMPAT
48         struct mutex compat_mutex;
49         struct compat_delta *compat_offsets;
50 #endif
51 };
52
53 static struct xt_af *xt;
54
55 #ifdef DEBUG_IP_FIREWALL_USER
56 #define duprintf(format, args...) printk(format , ## args)
57 #else
58 #define duprintf(format, args...)
59 #endif
60
61 static const char *const xt_prefix[NFPROTO_NUMPROTO] = {
62         [NFPROTO_UNSPEC] = "x",
63         [NFPROTO_IPV4]   = "ip",
64         [NFPROTO_ARP]    = "arp",
65         [NFPROTO_BRIDGE] = "eb",
66         [NFPROTO_IPV6]   = "ip6",
67 };
68
69 /* Registration hooks for targets. */
70 int
71 xt_register_target(struct xt_target *target)
72 {
73         u_int8_t af = target->family;
74         int ret;
75
76         ret = mutex_lock_interruptible(&xt[af].mutex);
77         if (ret != 0)
78                 return ret;
79         list_add(&target->list, &xt[af].target);
80         mutex_unlock(&xt[af].mutex);
81         return ret;
82 }
83 EXPORT_SYMBOL(xt_register_target);
84
85 void
86 xt_unregister_target(struct xt_target *target)
87 {
88         u_int8_t af = target->family;
89
90         mutex_lock(&xt[af].mutex);
91         list_del(&target->list);
92         mutex_unlock(&xt[af].mutex);
93 }
94 EXPORT_SYMBOL(xt_unregister_target);
95
96 int
97 xt_register_targets(struct xt_target *target, unsigned int n)
98 {
99         unsigned int i;
100         int err = 0;
101
102         for (i = 0; i < n; i++) {
103                 err = xt_register_target(&target[i]);
104                 if (err)
105                         goto err;
106         }
107         return err;
108
109 err:
110         if (i > 0)
111                 xt_unregister_targets(target, i);
112         return err;
113 }
114 EXPORT_SYMBOL(xt_register_targets);
115
116 void
117 xt_unregister_targets(struct xt_target *target, unsigned int n)
118 {
119         unsigned int i;
120
121         for (i = 0; i < n; i++)
122                 xt_unregister_target(&target[i]);
123 }
124 EXPORT_SYMBOL(xt_unregister_targets);
125
126 int
127 xt_register_match(struct xt_match *match)
128 {
129         u_int8_t af = match->family;
130         int ret;
131
132         ret = mutex_lock_interruptible(&xt[af].mutex);
133         if (ret != 0)
134                 return ret;
135
136         list_add(&match->list, &xt[af].match);
137         mutex_unlock(&xt[af].mutex);
138
139         return ret;
140 }
141 EXPORT_SYMBOL(xt_register_match);
142
143 void
144 xt_unregister_match(struct xt_match *match)
145 {
146         u_int8_t af = match->family;
147
148         mutex_lock(&xt[af].mutex);
149         list_del(&match->list);
150         mutex_unlock(&xt[af].mutex);
151 }
152 EXPORT_SYMBOL(xt_unregister_match);
153
154 int
155 xt_register_matches(struct xt_match *match, unsigned int n)
156 {
157         unsigned int i;
158         int err = 0;
159
160         for (i = 0; i < n; i++) {
161                 err = xt_register_match(&match[i]);
162                 if (err)
163                         goto err;
164         }
165         return err;
166
167 err:
168         if (i > 0)
169                 xt_unregister_matches(match, i);
170         return err;
171 }
172 EXPORT_SYMBOL(xt_register_matches);
173
174 void
175 xt_unregister_matches(struct xt_match *match, unsigned int n)
176 {
177         unsigned int i;
178
179         for (i = 0; i < n; i++)
180                 xt_unregister_match(&match[i]);
181 }
182 EXPORT_SYMBOL(xt_unregister_matches);
183
184
185 /*
186  * These are weird, but module loading must not be done with mutex
187  * held (since they will register), and we have to have a single
188  * function to use try_then_request_module().
189  */
190
191 /* Find match, grabs ref.  Returns ERR_PTR() on error. */
192 struct xt_match *xt_find_match(u8 af, const char *name, u8 revision)
193 {
194         struct xt_match *m;
195         int err = 0;
196
197         if (mutex_lock_interruptible(&xt[af].mutex) != 0)
198                 return ERR_PTR(-EINTR);
199
200         list_for_each_entry(m, &xt[af].match, list) {
201                 if (strcmp(m->name, name) == 0) {
202                         if (m->revision == revision) {
203                                 if (try_module_get(m->me)) {
204                                         mutex_unlock(&xt[af].mutex);
205                                         return m;
206                                 }
207                         } else
208                                 err = -EPROTOTYPE; /* Found something. */
209                 }
210         }
211         mutex_unlock(&xt[af].mutex);
212
213         if (af != NFPROTO_UNSPEC)
214                 /* Try searching again in the family-independent list */
215                 return xt_find_match(NFPROTO_UNSPEC, name, revision);
216
217         return ERR_PTR(err);
218 }
219 EXPORT_SYMBOL(xt_find_match);
220
221 /* Find target, grabs ref.  Returns ERR_PTR() on error. */
222 struct xt_target *xt_find_target(u8 af, const char *name, u8 revision)
223 {
224         struct xt_target *t;
225         int err = 0;
226
227         if (mutex_lock_interruptible(&xt[af].mutex) != 0)
228                 return ERR_PTR(-EINTR);
229
230         list_for_each_entry(t, &xt[af].target, list) {
231                 if (strcmp(t->name, name) == 0) {
232                         if (t->revision == revision) {
233                                 if (try_module_get(t->me)) {
234                                         mutex_unlock(&xt[af].mutex);
235                                         return t;
236                                 }
237                         } else
238                                 err = -EPROTOTYPE; /* Found something. */
239                 }
240         }
241         mutex_unlock(&xt[af].mutex);
242
243         if (af != NFPROTO_UNSPEC)
244                 /* Try searching again in the family-independent list */
245                 return xt_find_target(NFPROTO_UNSPEC, name, revision);
246
247         return ERR_PTR(err);
248 }
249 EXPORT_SYMBOL(xt_find_target);
250
251 struct xt_target *xt_request_find_target(u8 af, const char *name, u8 revision)
252 {
253         struct xt_target *target;
254
255         target = try_then_request_module(xt_find_target(af, name, revision),
256                                          "%st_%s", xt_prefix[af], name);
257         if (IS_ERR(target) || !target)
258                 return NULL;
259         return target;
260 }
261 EXPORT_SYMBOL_GPL(xt_request_find_target);
262
263 static int match_revfn(u8 af, const char *name, u8 revision, int *bestp)
264 {
265         const struct xt_match *m;
266         int have_rev = 0;
267
268         list_for_each_entry(m, &xt[af].match, list) {
269                 if (strcmp(m->name, name) == 0) {
270                         if (m->revision > *bestp)
271                                 *bestp = m->revision;
272                         if (m->revision == revision)
273                                 have_rev = 1;
274                 }
275         }
276
277         if (af != NFPROTO_UNSPEC && !have_rev)
278                 return match_revfn(NFPROTO_UNSPEC, name, revision, bestp);
279
280         return have_rev;
281 }
282
283 static int target_revfn(u8 af, const char *name, u8 revision, int *bestp)
284 {
285         const struct xt_target *t;
286         int have_rev = 0;
287
288         list_for_each_entry(t, &xt[af].target, list) {
289                 if (strcmp(t->name, name) == 0) {
290                         if (t->revision > *bestp)
291                                 *bestp = t->revision;
292                         if (t->revision == revision)
293                                 have_rev = 1;
294                 }
295         }
296
297         if (af != NFPROTO_UNSPEC && !have_rev)
298                 return target_revfn(NFPROTO_UNSPEC, name, revision, bestp);
299
300         return have_rev;
301 }
302
303 /* Returns true or false (if no such extension at all) */
304 int xt_find_revision(u8 af, const char *name, u8 revision, int target,
305                      int *err)
306 {
307         int have_rev, best = -1;
308
309         if (mutex_lock_interruptible(&xt[af].mutex) != 0) {
310                 *err = -EINTR;
311                 return 1;
312         }
313         if (target == 1)
314                 have_rev = target_revfn(af, name, revision, &best);
315         else
316                 have_rev = match_revfn(af, name, revision, &best);
317         mutex_unlock(&xt[af].mutex);
318
319         /* Nothing at all?  Return 0 to try loading module. */
320         if (best == -1) {
321                 *err = -ENOENT;
322                 return 0;
323         }
324
325         *err = best;
326         if (!have_rev)
327                 *err = -EPROTONOSUPPORT;
328         return 1;
329 }
330 EXPORT_SYMBOL_GPL(xt_find_revision);
331
332 int xt_check_match(struct xt_mtchk_param *par,
333                    unsigned int size, u_int8_t proto, bool inv_proto)
334 {
335         if (XT_ALIGN(par->match->matchsize) != size &&
336             par->match->matchsize != -1) {
337                 /*
338                  * ebt_among is exempt from centralized matchsize checking
339                  * because it uses a dynamic-size data set.
340                  */
341                 printk("%s_tables: %s match: invalid size %Zu != %u\n",
342                        xt_prefix[par->family], par->match->name,
343                        XT_ALIGN(par->match->matchsize), size);
344                 return -EINVAL;
345         }
346         if (par->match->table != NULL &&
347             strcmp(par->match->table, par->table) != 0) {
348                 printk("%s_tables: %s match: only valid in %s table, not %s\n",
349                        xt_prefix[par->family], par->match->name,
350                        par->match->table, par->table);
351                 return -EINVAL;
352         }
353         if (par->match->hooks && (par->hook_mask & ~par->match->hooks) != 0) {
354                 printk("%s_tables: %s match: bad hook_mask %#x/%#x\n",
355                        xt_prefix[par->family], par->match->name,
356                        par->hook_mask, par->match->hooks);
357                 return -EINVAL;
358         }
359         if (par->match->proto && (par->match->proto != proto || inv_proto)) {
360                 printk("%s_tables: %s match: only valid for protocol %u\n",
361                        xt_prefix[par->family], par->match->name,
362                        par->match->proto);
363                 return -EINVAL;
364         }
365         if (par->match->checkentry != NULL && !par->match->checkentry(par))
366                 return -EINVAL;
367         return 0;
368 }
369 EXPORT_SYMBOL_GPL(xt_check_match);
370
371 #ifdef CONFIG_COMPAT
372 int xt_compat_add_offset(u_int8_t af, unsigned int offset, short delta)
373 {
374         struct compat_delta *tmp;
375
376         tmp = kmalloc(sizeof(struct compat_delta), GFP_KERNEL);
377         if (!tmp)
378                 return -ENOMEM;
379
380         tmp->offset = offset;
381         tmp->delta = delta;
382
383         if (xt[af].compat_offsets) {
384                 tmp->next = xt[af].compat_offsets->next;
385                 xt[af].compat_offsets->next = tmp;
386         } else {
387                 xt[af].compat_offsets = tmp;
388                 tmp->next = NULL;
389         }
390         return 0;
391 }
392 EXPORT_SYMBOL_GPL(xt_compat_add_offset);
393
394 void xt_compat_flush_offsets(u_int8_t af)
395 {
396         struct compat_delta *tmp, *next;
397
398         if (xt[af].compat_offsets) {
399                 for (tmp = xt[af].compat_offsets; tmp; tmp = next) {
400                         next = tmp->next;
401                         kfree(tmp);
402                 }
403                 xt[af].compat_offsets = NULL;
404         }
405 }
406 EXPORT_SYMBOL_GPL(xt_compat_flush_offsets);
407
408 short xt_compat_calc_jump(u_int8_t af, unsigned int offset)
409 {
410         struct compat_delta *tmp;
411         short delta;
412
413         for (tmp = xt[af].compat_offsets, delta = 0; tmp; tmp = tmp->next)
414                 if (tmp->offset < offset)
415                         delta += tmp->delta;
416         return delta;
417 }
418 EXPORT_SYMBOL_GPL(xt_compat_calc_jump);
419
420 int xt_compat_match_offset(const struct xt_match *match)
421 {
422         u_int16_t csize = match->compatsize ? : match->matchsize;
423         return XT_ALIGN(match->matchsize) - COMPAT_XT_ALIGN(csize);
424 }
425 EXPORT_SYMBOL_GPL(xt_compat_match_offset);
426
427 int xt_compat_match_from_user(struct xt_entry_match *m, void **dstptr,
428                               unsigned int *size)
429 {
430         const struct xt_match *match = m->u.kernel.match;
431         struct compat_xt_entry_match *cm = (struct compat_xt_entry_match *)m;
432         int pad, off = xt_compat_match_offset(match);
433         u_int16_t msize = cm->u.user.match_size;
434
435         m = *dstptr;
436         memcpy(m, cm, sizeof(*cm));
437         if (match->compat_from_user)
438                 match->compat_from_user(m->data, cm->data);
439         else
440                 memcpy(m->data, cm->data, msize - sizeof(*cm));
441         pad = XT_ALIGN(match->matchsize) - match->matchsize;
442         if (pad > 0)
443                 memset(m->data + match->matchsize, 0, pad);
444
445         msize += off;
446         m->u.user.match_size = msize;
447
448         *size += off;
449         *dstptr += msize;
450         return 0;
451 }
452 EXPORT_SYMBOL_GPL(xt_compat_match_from_user);
453
454 int xt_compat_match_to_user(struct xt_entry_match *m, void __user **dstptr,
455                             unsigned int *size)
456 {
457         const struct xt_match *match = m->u.kernel.match;
458         struct compat_xt_entry_match __user *cm = *dstptr;
459         int off = xt_compat_match_offset(match);
460         u_int16_t msize = m->u.user.match_size - off;
461
462         if (copy_to_user(cm, m, sizeof(*cm)) ||
463             put_user(msize, &cm->u.user.match_size) ||
464             copy_to_user(cm->u.user.name, m->u.kernel.match->name,
465                          strlen(m->u.kernel.match->name) + 1))
466                 return -EFAULT;
467
468         if (match->compat_to_user) {
469                 if (match->compat_to_user((void __user *)cm->data, m->data))
470                         return -EFAULT;
471         } else {
472                 if (copy_to_user(cm->data, m->data, msize - sizeof(*cm)))
473                         return -EFAULT;
474         }
475
476         *size -= off;
477         *dstptr += msize;
478         return 0;
479 }
480 EXPORT_SYMBOL_GPL(xt_compat_match_to_user);
481 #endif /* CONFIG_COMPAT */
482
483 int xt_check_target(struct xt_tgchk_param *par,
484                     unsigned int size, u_int8_t proto, bool inv_proto)
485 {
486         if (XT_ALIGN(par->target->targetsize) != size) {
487                 printk("%s_tables: %s target: invalid size %Zu != %u\n",
488                        xt_prefix[par->family], par->target->name,
489                        XT_ALIGN(par->target->targetsize), size);
490                 return -EINVAL;
491         }
492         if (par->target->table != NULL &&
493             strcmp(par->target->table, par->table) != 0) {
494                 printk("%s_tables: %s target: only valid in %s table, not %s\n",
495                        xt_prefix[par->family], par->target->name,
496                        par->target->table, par->table);
497                 return -EINVAL;
498         }
499         if (par->target->hooks && (par->hook_mask & ~par->target->hooks) != 0) {
500                 printk("%s_tables: %s target: bad hook_mask %#x/%#x\n",
501                        xt_prefix[par->family], par->target->name,
502                        par->hook_mask, par->target->hooks);
503                 return -EINVAL;
504         }
505         if (par->target->proto && (par->target->proto != proto || inv_proto)) {
506                 printk("%s_tables: %s target: only valid for protocol %u\n",
507                        xt_prefix[par->family], par->target->name,
508                        par->target->proto);
509                 return -EINVAL;
510         }
511         if (par->target->checkentry != NULL && !par->target->checkentry(par))
512                 return -EINVAL;
513         return 0;
514 }
515 EXPORT_SYMBOL_GPL(xt_check_target);
516
517 #ifdef CONFIG_COMPAT
518 int xt_compat_target_offset(const struct xt_target *target)
519 {
520         u_int16_t csize = target->compatsize ? : target->targetsize;
521         return XT_ALIGN(target->targetsize) - COMPAT_XT_ALIGN(csize);
522 }
523 EXPORT_SYMBOL_GPL(xt_compat_target_offset);
524
525 void xt_compat_target_from_user(struct xt_entry_target *t, void **dstptr,
526                                 unsigned int *size)
527 {
528         const struct xt_target *target = t->u.kernel.target;
529         struct compat_xt_entry_target *ct = (struct compat_xt_entry_target *)t;
530         int pad, off = xt_compat_target_offset(target);
531         u_int16_t tsize = ct->u.user.target_size;
532
533         t = *dstptr;
534         memcpy(t, ct, sizeof(*ct));
535         if (target->compat_from_user)
536                 target->compat_from_user(t->data, ct->data);
537         else
538                 memcpy(t->data, ct->data, tsize - sizeof(*ct));
539         pad = XT_ALIGN(target->targetsize) - target->targetsize;
540         if (pad > 0)
541                 memset(t->data + target->targetsize, 0, pad);
542
543         tsize += off;
544         t->u.user.target_size = tsize;
545
546         *size += off;
547         *dstptr += tsize;
548 }
549 EXPORT_SYMBOL_GPL(xt_compat_target_from_user);
550
551 int xt_compat_target_to_user(struct xt_entry_target *t, void __user **dstptr,
552                              unsigned int *size)
553 {
554         const struct xt_target *target = t->u.kernel.target;
555         struct compat_xt_entry_target __user *ct = *dstptr;
556         int off = xt_compat_target_offset(target);
557         u_int16_t tsize = t->u.user.target_size - off;
558
559         if (copy_to_user(ct, t, sizeof(*ct)) ||
560             put_user(tsize, &ct->u.user.target_size) ||
561             copy_to_user(ct->u.user.name, t->u.kernel.target->name,
562                          strlen(t->u.kernel.target->name) + 1))
563                 return -EFAULT;
564
565         if (target->compat_to_user) {
566                 if (target->compat_to_user((void __user *)ct->data, t->data))
567                         return -EFAULT;
568         } else {
569                 if (copy_to_user(ct->data, t->data, tsize - sizeof(*ct)))
570                         return -EFAULT;
571         }
572
573         *size -= off;
574         *dstptr += tsize;
575         return 0;
576 }
577 EXPORT_SYMBOL_GPL(xt_compat_target_to_user);
578 #endif
579
580 struct xt_table_info *xt_alloc_table_info(unsigned int size)
581 {
582         struct xt_table_info *newinfo;
583         int cpu;
584
585         /* Pedantry: prevent them from hitting BUG() in vmalloc.c --RR */
586         if ((SMP_ALIGN(size) >> PAGE_SHIFT) + 2 > num_physpages)
587                 return NULL;
588
589         newinfo = kzalloc(XT_TABLE_INFO_SZ, GFP_KERNEL);
590         if (!newinfo)
591                 return NULL;
592
593         newinfo->size = size;
594
595         for_each_possible_cpu(cpu) {
596                 if (size <= PAGE_SIZE)
597                         newinfo->entries[cpu] = kmalloc_node(size,
598                                                         GFP_KERNEL,
599                                                         cpu_to_node(cpu));
600                 else
601                         newinfo->entries[cpu] = vmalloc_node(size,
602                                                         cpu_to_node(cpu));
603
604                 if (newinfo->entries[cpu] == NULL) {
605                         xt_free_table_info(newinfo);
606                         return NULL;
607                 }
608         }
609
610         return newinfo;
611 }
612 EXPORT_SYMBOL(xt_alloc_table_info);
613
614 void xt_free_table_info(struct xt_table_info *info)
615 {
616         int cpu;
617
618         for_each_possible_cpu(cpu) {
619                 if (info->size <= PAGE_SIZE)
620                         kfree(info->entries[cpu]);
621                 else
622                         vfree(info->entries[cpu]);
623         }
624         kfree(info);
625 }
626 EXPORT_SYMBOL(xt_free_table_info);
627
628 void xt_table_entry_swap_rcu(struct xt_table_info *oldinfo,
629                              struct xt_table_info *newinfo)
630 {
631         unsigned int cpu;
632
633         for_each_possible_cpu(cpu) {
634                 void *p = oldinfo->entries[cpu];
635                 rcu_assign_pointer(oldinfo->entries[cpu], newinfo->entries[cpu]);
636                 newinfo->entries[cpu] = p;
637         }
638
639 }
640 EXPORT_SYMBOL_GPL(xt_table_entry_swap_rcu);
641
642 /* Find table by name, grabs mutex & ref.  Returns ERR_PTR() on error. */
643 struct xt_table *xt_find_table_lock(struct net *net, u_int8_t af,
644                                     const char *name)
645 {
646         struct xt_table *t;
647
648         if (mutex_lock_interruptible(&xt[af].mutex) != 0)
649                 return ERR_PTR(-EINTR);
650
651         list_for_each_entry(t, &net->xt.tables[af], list)
652                 if (strcmp(t->name, name) == 0 && try_module_get(t->me))
653                         return t;
654         mutex_unlock(&xt[af].mutex);
655         return NULL;
656 }
657 EXPORT_SYMBOL_GPL(xt_find_table_lock);
658
659 void xt_table_unlock(struct xt_table *table)
660 {
661         mutex_unlock(&xt[table->af].mutex);
662 }
663 EXPORT_SYMBOL_GPL(xt_table_unlock);
664
665 #ifdef CONFIG_COMPAT
666 void xt_compat_lock(u_int8_t af)
667 {
668         mutex_lock(&xt[af].compat_mutex);
669 }
670 EXPORT_SYMBOL_GPL(xt_compat_lock);
671
672 void xt_compat_unlock(u_int8_t af)
673 {
674         mutex_unlock(&xt[af].compat_mutex);
675 }
676 EXPORT_SYMBOL_GPL(xt_compat_unlock);
677 #endif
678
679 struct xt_table_info *
680 xt_replace_table(struct xt_table *table,
681               unsigned int num_counters,
682               struct xt_table_info *newinfo,
683               int *error)
684 {
685         struct xt_table_info *oldinfo, *private;
686
687         /* Do the substitution. */
688         mutex_lock(&table->lock);
689         private = table->private;
690         /* Check inside lock: is the old number correct? */
691         if (num_counters != private->number) {
692                 duprintf("num_counters != table->private->number (%u/%u)\n",
693                          num_counters, private->number);
694                 mutex_unlock(&table->lock);
695                 *error = -EAGAIN;
696                 return NULL;
697         }
698         oldinfo = private;
699         rcu_assign_pointer(table->private, newinfo);
700         newinfo->initial_entries = oldinfo->initial_entries;
701         mutex_unlock(&table->lock);
702
703         synchronize_net();
704         return oldinfo;
705 }
706 EXPORT_SYMBOL_GPL(xt_replace_table);
707
708 struct xt_table *xt_register_table(struct net *net, struct xt_table *table,
709                                    struct xt_table_info *bootstrap,
710                                    struct xt_table_info *newinfo)
711 {
712         int ret;
713         struct xt_table_info *private;
714         struct xt_table *t;
715
716         /* Don't add one object to multiple lists. */
717         table = kmemdup(table, sizeof(struct xt_table), GFP_KERNEL);
718         if (!table) {
719                 ret = -ENOMEM;
720                 goto out;
721         }
722
723         ret = mutex_lock_interruptible(&xt[table->af].mutex);
724         if (ret != 0)
725                 goto out_free;
726
727         /* Don't autoload: we'd eat our tail... */
728         list_for_each_entry(t, &net->xt.tables[table->af], list) {
729                 if (strcmp(t->name, table->name) == 0) {
730                         ret = -EEXIST;
731                         goto unlock;
732                 }
733         }
734
735         /* Simplifies replace_table code. */
736         table->private = bootstrap;
737         mutex_init(&table->lock);
738
739         if (!xt_replace_table(table, 0, newinfo, &ret))
740                 goto unlock;
741
742         private = table->private;
743         duprintf("table->private->number = %u\n", private->number);
744
745         /* save number of initial entries */
746         private->initial_entries = private->number;
747
748         list_add(&table->list, &net->xt.tables[table->af]);
749         mutex_unlock(&xt[table->af].mutex);
750         return table;
751
752  unlock:
753         mutex_unlock(&xt[table->af].mutex);
754 out_free:
755         kfree(table);
756 out:
757         return ERR_PTR(ret);
758 }
759 EXPORT_SYMBOL_GPL(xt_register_table);
760
761 void *xt_unregister_table(struct xt_table *table)
762 {
763         struct xt_table_info *private;
764
765         mutex_lock(&xt[table->af].mutex);
766         private = table->private;
767         list_del(&table->list);
768         mutex_unlock(&xt[table->af].mutex);
769         kfree(table);
770
771         return private;
772 }
773 EXPORT_SYMBOL_GPL(xt_unregister_table);
774
775 #ifdef CONFIG_PROC_FS
776 struct xt_names_priv {
777         struct seq_net_private p;
778         u_int8_t af;
779 };
780 static void *xt_table_seq_start(struct seq_file *seq, loff_t *pos)
781 {
782         struct xt_names_priv *priv = seq->private;
783         struct net *net = seq_file_net(seq);
784         u_int8_t af = priv->af;
785
786         mutex_lock(&xt[af].mutex);
787         return seq_list_start(&net->xt.tables[af], *pos);
788 }
789
790 static void *xt_table_seq_next(struct seq_file *seq, void *v, loff_t *pos)
791 {
792         struct xt_names_priv *priv = seq->private;
793         struct net *net = seq_file_net(seq);
794         u_int8_t af = priv->af;
795
796         return seq_list_next(v, &net->xt.tables[af], pos);
797 }
798
799 static void xt_table_seq_stop(struct seq_file *seq, void *v)
800 {
801         struct xt_names_priv *priv = seq->private;
802         u_int8_t af = priv->af;
803
804         mutex_unlock(&xt[af].mutex);
805 }
806
807 static int xt_table_seq_show(struct seq_file *seq, void *v)
808 {
809         struct xt_table *table = list_entry(v, struct xt_table, list);
810
811         if (strlen(table->name))
812                 return seq_printf(seq, "%s\n", table->name);
813         else
814                 return 0;
815 }
816
817 static const struct seq_operations xt_table_seq_ops = {
818         .start  = xt_table_seq_start,
819         .next   = xt_table_seq_next,
820         .stop   = xt_table_seq_stop,
821         .show   = xt_table_seq_show,
822 };
823
824 static int xt_table_open(struct inode *inode, struct file *file)
825 {
826         int ret;
827         struct xt_names_priv *priv;
828
829         ret = seq_open_net(inode, file, &xt_table_seq_ops,
830                            sizeof(struct xt_names_priv));
831         if (!ret) {
832                 priv = ((struct seq_file *)file->private_data)->private;
833                 priv->af = (unsigned long)PDE(inode)->data;
834         }
835         return ret;
836 }
837
838 static const struct file_operations xt_table_ops = {
839         .owner   = THIS_MODULE,
840         .open    = xt_table_open,
841         .read    = seq_read,
842         .llseek  = seq_lseek,
843         .release = seq_release_net,
844 };
845
846 /*
847  * Traverse state for ip{,6}_{tables,matches} for helping crossing
848  * the multi-AF mutexes.
849  */
850 struct nf_mttg_trav {
851         struct list_head *head, *curr;
852         uint8_t class, nfproto;
853 };
854
855 enum {
856         MTTG_TRAV_INIT,
857         MTTG_TRAV_NFP_UNSPEC,
858         MTTG_TRAV_NFP_SPEC,
859         MTTG_TRAV_DONE,
860 };
861
862 static void *xt_mttg_seq_next(struct seq_file *seq, void *v, loff_t *ppos,
863     bool is_target)
864 {
865         static const uint8_t next_class[] = {
866                 [MTTG_TRAV_NFP_UNSPEC] = MTTG_TRAV_NFP_SPEC,
867                 [MTTG_TRAV_NFP_SPEC]   = MTTG_TRAV_DONE,
868         };
869         struct nf_mttg_trav *trav = seq->private;
870
871         switch (trav->class) {
872         case MTTG_TRAV_INIT:
873                 trav->class = MTTG_TRAV_NFP_UNSPEC;
874                 mutex_lock(&xt[NFPROTO_UNSPEC].mutex);
875                 trav->head = trav->curr = is_target ?
876                         &xt[NFPROTO_UNSPEC].target : &xt[NFPROTO_UNSPEC].match;
877                 break;
878         case MTTG_TRAV_NFP_UNSPEC:
879                 trav->curr = trav->curr->next;
880                 if (trav->curr != trav->head)
881                         break;
882                 mutex_unlock(&xt[NFPROTO_UNSPEC].mutex);
883                 mutex_lock(&xt[trav->nfproto].mutex);
884                 trav->head = trav->curr = is_target ?
885                         &xt[trav->nfproto].target : &xt[trav->nfproto].match;
886                 trav->class = next_class[trav->class];
887                 break;
888         case MTTG_TRAV_NFP_SPEC:
889                 trav->curr = trav->curr->next;
890                 if (trav->curr != trav->head)
891                         break;
892                 /* fallthru, _stop will unlock */
893         default:
894                 return NULL;
895         }
896
897         if (ppos != NULL)
898                 ++*ppos;
899         return trav;
900 }
901
902 static void *xt_mttg_seq_start(struct seq_file *seq, loff_t *pos,
903     bool is_target)
904 {
905         struct nf_mttg_trav *trav = seq->private;
906         unsigned int j;
907
908         trav->class = MTTG_TRAV_INIT;
909         for (j = 0; j < *pos; ++j)
910                 if (xt_mttg_seq_next(seq, NULL, NULL, is_target) == NULL)
911                         return NULL;
912         return trav;
913 }
914
915 static void xt_mttg_seq_stop(struct seq_file *seq, void *v)
916 {
917         struct nf_mttg_trav *trav = seq->private;
918
919         switch (trav->class) {
920         case MTTG_TRAV_NFP_UNSPEC:
921                 mutex_unlock(&xt[NFPROTO_UNSPEC].mutex);
922                 break;
923         case MTTG_TRAV_NFP_SPEC:
924                 mutex_unlock(&xt[trav->nfproto].mutex);
925                 break;
926         }
927 }
928
929 static void *xt_match_seq_start(struct seq_file *seq, loff_t *pos)
930 {
931         return xt_mttg_seq_start(seq, pos, false);
932 }
933
934 static void *xt_match_seq_next(struct seq_file *seq, void *v, loff_t *ppos)
935 {
936         return xt_mttg_seq_next(seq, v, ppos, false);
937 }
938
939 static int xt_match_seq_show(struct seq_file *seq, void *v)
940 {
941         const struct nf_mttg_trav *trav = seq->private;
942         const struct xt_match *match;
943
944         switch (trav->class) {
945         case MTTG_TRAV_NFP_UNSPEC:
946         case MTTG_TRAV_NFP_SPEC:
947                 if (trav->curr == trav->head)
948                         return 0;
949                 match = list_entry(trav->curr, struct xt_match, list);
950                 return (*match->name == '\0') ? 0 :
951                        seq_printf(seq, "%s\n", match->name);
952         }
953         return 0;
954 }
955
956 static const struct seq_operations xt_match_seq_ops = {
957         .start  = xt_match_seq_start,
958         .next   = xt_match_seq_next,
959         .stop   = xt_mttg_seq_stop,
960         .show   = xt_match_seq_show,
961 };
962
963 static int xt_match_open(struct inode *inode, struct file *file)
964 {
965         struct seq_file *seq;
966         struct nf_mttg_trav *trav;
967         int ret;
968
969         trav = kmalloc(sizeof(*trav), GFP_KERNEL);
970         if (trav == NULL)
971                 return -ENOMEM;
972
973         ret = seq_open(file, &xt_match_seq_ops);
974         if (ret < 0) {
975                 kfree(trav);
976                 return ret;
977         }
978
979         seq = file->private_data;
980         seq->private = trav;
981         trav->nfproto = (unsigned long)PDE(inode)->data;
982         return 0;
983 }
984
985 static const struct file_operations xt_match_ops = {
986         .owner   = THIS_MODULE,
987         .open    = xt_match_open,
988         .read    = seq_read,
989         .llseek  = seq_lseek,
990         .release = seq_release_private,
991 };
992
993 static void *xt_target_seq_start(struct seq_file *seq, loff_t *pos)
994 {
995         return xt_mttg_seq_start(seq, pos, true);
996 }
997
998 static void *xt_target_seq_next(struct seq_file *seq, void *v, loff_t *ppos)
999 {
1000         return xt_mttg_seq_next(seq, v, ppos, true);
1001 }
1002
1003 static int xt_target_seq_show(struct seq_file *seq, void *v)
1004 {
1005         const struct nf_mttg_trav *trav = seq->private;
1006         const struct xt_target *target;
1007
1008         switch (trav->class) {
1009         case MTTG_TRAV_NFP_UNSPEC:
1010         case MTTG_TRAV_NFP_SPEC:
1011                 if (trav->curr == trav->head)
1012                         return 0;
1013                 target = list_entry(trav->curr, struct xt_target, list);
1014                 return (*target->name == '\0') ? 0 :
1015                        seq_printf(seq, "%s\n", target->name);
1016         }
1017         return 0;
1018 }
1019
1020 static const struct seq_operations xt_target_seq_ops = {
1021         .start  = xt_target_seq_start,
1022         .next   = xt_target_seq_next,
1023         .stop   = xt_mttg_seq_stop,
1024         .show   = xt_target_seq_show,
1025 };
1026
1027 static int xt_target_open(struct inode *inode, struct file *file)
1028 {
1029         struct seq_file *seq;
1030         struct nf_mttg_trav *trav;
1031         int ret;
1032
1033         trav = kmalloc(sizeof(*trav), GFP_KERNEL);
1034         if (trav == NULL)
1035                 return -ENOMEM;
1036
1037         ret = seq_open(file, &xt_target_seq_ops);
1038         if (ret < 0) {
1039                 kfree(trav);
1040                 return ret;
1041         }
1042
1043         seq = file->private_data;
1044         seq->private = trav;
1045         trav->nfproto = (unsigned long)PDE(inode)->data;
1046         return 0;
1047 }
1048
1049 static const struct file_operations xt_target_ops = {
1050         .owner   = THIS_MODULE,
1051         .open    = xt_target_open,
1052         .read    = seq_read,
1053         .llseek  = seq_lseek,
1054         .release = seq_release_private,
1055 };
1056
1057 #define FORMAT_TABLES   "_tables_names"
1058 #define FORMAT_MATCHES  "_tables_matches"
1059 #define FORMAT_TARGETS  "_tables_targets"
1060
1061 #endif /* CONFIG_PROC_FS */
1062
1063 int xt_proto_init(struct net *net, u_int8_t af)
1064 {
1065 #ifdef CONFIG_PROC_FS
1066         char buf[XT_FUNCTION_MAXNAMELEN];
1067         struct proc_dir_entry *proc;
1068 #endif
1069
1070         if (af >= ARRAY_SIZE(xt_prefix))
1071                 return -EINVAL;
1072
1073
1074 #ifdef CONFIG_PROC_FS
1075         strlcpy(buf, xt_prefix[af], sizeof(buf));
1076         strlcat(buf, FORMAT_TABLES, sizeof(buf));
1077         proc = proc_create_data(buf, 0440, net->proc_net, &xt_table_ops,
1078                                 (void *)(unsigned long)af);
1079         if (!proc)
1080                 goto out;
1081
1082         strlcpy(buf, xt_prefix[af], sizeof(buf));
1083         strlcat(buf, FORMAT_MATCHES, sizeof(buf));
1084         proc = proc_create_data(buf, 0440, net->proc_net, &xt_match_ops,
1085                                 (void *)(unsigned long)af);
1086         if (!proc)
1087                 goto out_remove_tables;
1088
1089         strlcpy(buf, xt_prefix[af], sizeof(buf));
1090         strlcat(buf, FORMAT_TARGETS, sizeof(buf));
1091         proc = proc_create_data(buf, 0440, net->proc_net, &xt_target_ops,
1092                                 (void *)(unsigned long)af);
1093         if (!proc)
1094                 goto out_remove_matches;
1095 #endif
1096
1097         return 0;
1098
1099 #ifdef CONFIG_PROC_FS
1100 out_remove_matches:
1101         strlcpy(buf, xt_prefix[af], sizeof(buf));
1102         strlcat(buf, FORMAT_MATCHES, sizeof(buf));
1103         proc_net_remove(net, buf);
1104
1105 out_remove_tables:
1106         strlcpy(buf, xt_prefix[af], sizeof(buf));
1107         strlcat(buf, FORMAT_TABLES, sizeof(buf));
1108         proc_net_remove(net, buf);
1109 out:
1110         return -1;
1111 #endif
1112 }
1113 EXPORT_SYMBOL_GPL(xt_proto_init);
1114
1115 void xt_proto_fini(struct net *net, u_int8_t af)
1116 {
1117 #ifdef CONFIG_PROC_FS
1118         char buf[XT_FUNCTION_MAXNAMELEN];
1119
1120         strlcpy(buf, xt_prefix[af], sizeof(buf));
1121         strlcat(buf, FORMAT_TABLES, sizeof(buf));
1122         proc_net_remove(net, buf);
1123
1124         strlcpy(buf, xt_prefix[af], sizeof(buf));
1125         strlcat(buf, FORMAT_TARGETS, sizeof(buf));
1126         proc_net_remove(net, buf);
1127
1128         strlcpy(buf, xt_prefix[af], sizeof(buf));
1129         strlcat(buf, FORMAT_MATCHES, sizeof(buf));
1130         proc_net_remove(net, buf);
1131 #endif /*CONFIG_PROC_FS*/
1132 }
1133 EXPORT_SYMBOL_GPL(xt_proto_fini);
1134
1135 static int __net_init xt_net_init(struct net *net)
1136 {
1137         int i;
1138
1139         for (i = 0; i < NFPROTO_NUMPROTO; i++)
1140                 INIT_LIST_HEAD(&net->xt.tables[i]);
1141         return 0;
1142 }
1143
1144 static struct pernet_operations xt_net_ops = {
1145         .init = xt_net_init,
1146 };
1147
1148 static int __init xt_init(void)
1149 {
1150         int i, rv;
1151
1152         xt = kmalloc(sizeof(struct xt_af) * NFPROTO_NUMPROTO, GFP_KERNEL);
1153         if (!xt)
1154                 return -ENOMEM;
1155
1156         for (i = 0; i < NFPROTO_NUMPROTO; i++) {
1157                 mutex_init(&xt[i].mutex);
1158 #ifdef CONFIG_COMPAT
1159                 mutex_init(&xt[i].compat_mutex);
1160                 xt[i].compat_offsets = NULL;
1161 #endif
1162                 INIT_LIST_HEAD(&xt[i].target);
1163                 INIT_LIST_HEAD(&xt[i].match);
1164         }
1165         rv = register_pernet_subsys(&xt_net_ops);
1166         if (rv < 0)
1167                 kfree(xt);
1168         return rv;
1169 }
1170
1171 static void __exit xt_fini(void)
1172 {
1173         unregister_pernet_subsys(&xt_net_ops);
1174         kfree(xt);
1175 }
1176
1177 module_init(xt_init);
1178 module_exit(xt_fini);
1179