5 * Bart De Schuymer <bdschuym@pandora.be>
7 * ebtables.c,v 2.0, July, 2002
9 * This code is strongly inspired by the iptables code which is
10 * Copyright (C) 1999 Paul `Rusty' Russell & Michael J. Neuling
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
18 #include <linux/kmod.h>
19 #include <linux/module.h>
20 #include <linux/vmalloc.h>
21 #include <linux/netfilter/x_tables.h>
22 #include <linux/netfilter_bridge/ebtables.h>
23 #include <linux/spinlock.h>
24 #include <linux/mutex.h>
25 #include <linux/slab.h>
26 #include <linux/uaccess.h>
27 #include <linux/smp.h>
28 #include <linux/cpumask.h>
29 #include <linux/audit.h>
31 /* needed for logical [in,out]-dev filtering */
32 #include "../br_private.h"
34 #define BUGPRINT(format, args...) printk("kernel msg: ebtables bug: please "\
35 "report to author: "format, ## args)
36 /* #define BUGPRINT(format, args...) */
38 /* Each cpu has its own set of counters, so there is no need for write_lock in
40 * For reading or updating the counters, the user context needs to
44 /* The size of each set of counters is altered to get cache alignment */
45 #define SMP_ALIGN(x) (((x) + SMP_CACHE_BYTES-1) & ~(SMP_CACHE_BYTES-1))
46 #define COUNTER_OFFSET(n) (SMP_ALIGN(n * sizeof(struct ebt_counter)))
47 #define COUNTER_BASE(c, n, cpu) ((struct ebt_counter *)(((char *)c) + \
48 COUNTER_OFFSET(n) * cpu))
52 static DEFINE_MUTEX(ebt_mutex
);
55 static void ebt_standard_compat_from_user(void *dst
, const void *src
)
57 int v
= *(compat_int_t
*)src
;
60 v
+= xt_compat_calc_jump(NFPROTO_BRIDGE
, v
);
61 memcpy(dst
, &v
, sizeof(v
));
64 static int ebt_standard_compat_to_user(void __user
*dst
, const void *src
)
66 compat_int_t cv
= *(int *)src
;
69 cv
-= xt_compat_calc_jump(NFPROTO_BRIDGE
, cv
);
70 return copy_to_user(dst
, &cv
, sizeof(cv
)) ? -EFAULT
: 0;
75 static struct xt_target ebt_standard_target
= {
78 .family
= NFPROTO_BRIDGE
,
79 .targetsize
= sizeof(int),
81 .compatsize
= sizeof(compat_int_t
),
82 .compat_from_user
= ebt_standard_compat_from_user
,
83 .compat_to_user
= ebt_standard_compat_to_user
,
88 ebt_do_watcher(const struct ebt_entry_watcher
*w
, struct sk_buff
*skb
,
89 struct xt_action_param
*par
)
91 par
->target
= w
->u
.watcher
;
92 par
->targinfo
= w
->data
;
93 w
->u
.watcher
->target(skb
, par
);
94 /* watchers don't give a verdict */
99 ebt_do_match(struct ebt_entry_match
*m
, const struct sk_buff
*skb
,
100 struct xt_action_param
*par
)
102 par
->match
= m
->u
.match
;
103 par
->matchinfo
= m
->data
;
104 return m
->u
.match
->match(skb
, par
) ? EBT_MATCH
: EBT_NOMATCH
;
108 ebt_dev_check(const char *entry
, const struct net_device
*device
)
117 devname
= device
->name
;
118 /* 1 is the wildcard token */
119 while (entry
[i
] != '\0' && entry
[i
] != 1 && entry
[i
] == devname
[i
])
121 return devname
[i
] != entry
[i
] && entry
[i
] != 1;
124 /* process standard matches */
126 ebt_basic_match(const struct ebt_entry
*e
, const struct sk_buff
*skb
,
127 const struct net_device
*in
, const struct net_device
*out
)
129 const struct ethhdr
*h
= eth_hdr(skb
);
130 const struct net_bridge_port
*p
;
133 if (skb_vlan_tag_present(skb
))
134 ethproto
= htons(ETH_P_8021Q
);
136 ethproto
= h
->h_proto
;
138 if (e
->bitmask
& EBT_802_3
) {
139 if (NF_INVF(e
, EBT_IPROTO
, eth_proto_is_802_3(ethproto
)))
141 } else if (!(e
->bitmask
& EBT_NOPROTO
) &&
142 NF_INVF(e
, EBT_IPROTO
, e
->ethproto
!= ethproto
))
145 if (NF_INVF(e
, EBT_IIN
, ebt_dev_check(e
->in
, in
)))
147 if (NF_INVF(e
, EBT_IOUT
, ebt_dev_check(e
->out
, out
)))
149 /* rcu_read_lock()ed by nf_hook_thresh */
150 if (in
&& (p
= br_port_get_rcu(in
)) != NULL
&&
151 NF_INVF(e
, EBT_ILOGICALIN
,
152 ebt_dev_check(e
->logical_in
, p
->br
->dev
)))
154 if (out
&& (p
= br_port_get_rcu(out
)) != NULL
&&
155 NF_INVF(e
, EBT_ILOGICALOUT
,
156 ebt_dev_check(e
->logical_out
, p
->br
->dev
)))
159 if (e
->bitmask
& EBT_SOURCEMAC
) {
160 if (NF_INVF(e
, EBT_ISOURCE
,
161 !ether_addr_equal_masked(h
->h_source
, e
->sourcemac
,
165 if (e
->bitmask
& EBT_DESTMAC
) {
166 if (NF_INVF(e
, EBT_IDEST
,
167 !ether_addr_equal_masked(h
->h_dest
, e
->destmac
,
175 struct ebt_entry
*ebt_next_entry(const struct ebt_entry
*entry
)
177 return (void *)entry
+ entry
->next_offset
;
180 /* Do some firewalling */
181 unsigned int ebt_do_table(struct sk_buff
*skb
,
182 const struct nf_hook_state
*state
,
183 struct ebt_table
*table
)
185 unsigned int hook
= state
->hook
;
187 struct ebt_entry
*point
;
188 struct ebt_counter
*counter_base
, *cb_base
;
189 const struct ebt_entry_target
*t
;
191 struct ebt_chainstack
*cs
;
192 struct ebt_entries
*chaininfo
;
194 const struct ebt_table_info
*private;
195 struct xt_action_param acpar
;
198 acpar
.hotdrop
= false;
200 read_lock_bh(&table
->lock
);
201 private = table
->private;
202 cb_base
= COUNTER_BASE(private->counters
, private->nentries
,
204 if (private->chainstack
)
205 cs
= private->chainstack
[smp_processor_id()];
208 chaininfo
= private->hook_entry
[hook
];
209 nentries
= private->hook_entry
[hook
]->nentries
;
210 point
= (struct ebt_entry
*)(private->hook_entry
[hook
]->data
);
211 counter_base
= cb_base
+ private->hook_entry
[hook
]->counter_offset
;
212 /* base for chain jumps */
213 base
= private->entries
;
215 while (i
< nentries
) {
216 if (ebt_basic_match(point
, skb
, state
->in
, state
->out
))
219 if (EBT_MATCH_ITERATE(point
, ebt_do_match
, skb
, &acpar
) != 0)
222 read_unlock_bh(&table
->lock
);
226 /* increase counter */
227 (*(counter_base
+ i
)).pcnt
++;
228 (*(counter_base
+ i
)).bcnt
+= skb
->len
;
230 /* these should only watch: not modify, nor tell us
231 * what to do with the packet
233 EBT_WATCHER_ITERATE(point
, ebt_do_watcher
, skb
, &acpar
);
235 t
= (struct ebt_entry_target
*)
236 (((char *)point
) + point
->target_offset
);
237 /* standard target */
238 if (!t
->u
.target
->target
)
239 verdict
= ((struct ebt_standard_target
*)t
)->verdict
;
241 acpar
.target
= t
->u
.target
;
242 acpar
.targinfo
= t
->data
;
243 verdict
= t
->u
.target
->target(skb
, &acpar
);
245 if (verdict
== EBT_ACCEPT
) {
246 read_unlock_bh(&table
->lock
);
249 if (verdict
== EBT_DROP
) {
250 read_unlock_bh(&table
->lock
);
253 if (verdict
== EBT_RETURN
) {
255 #ifdef CONFIG_NETFILTER_DEBUG
257 BUGPRINT("RETURN on base chain");
258 /* act like this is EBT_CONTINUE */
263 /* put all the local variables right */
265 chaininfo
= cs
[sp
].chaininfo
;
266 nentries
= chaininfo
->nentries
;
268 counter_base
= cb_base
+
269 chaininfo
->counter_offset
;
272 if (verdict
== EBT_CONTINUE
)
274 #ifdef CONFIG_NETFILTER_DEBUG
276 BUGPRINT("bogus standard verdict\n");
277 read_unlock_bh(&table
->lock
);
283 cs
[sp
].chaininfo
= chaininfo
;
284 cs
[sp
].e
= ebt_next_entry(point
);
286 chaininfo
= (struct ebt_entries
*) (base
+ verdict
);
287 #ifdef CONFIG_NETFILTER_DEBUG
288 if (chaininfo
->distinguisher
) {
289 BUGPRINT("jump to non-chain\n");
290 read_unlock_bh(&table
->lock
);
294 nentries
= chaininfo
->nentries
;
295 point
= (struct ebt_entry
*)chaininfo
->data
;
296 counter_base
= cb_base
+ chaininfo
->counter_offset
;
300 point
= ebt_next_entry(point
);
304 /* I actually like this :) */
305 if (chaininfo
->policy
== EBT_RETURN
)
307 if (chaininfo
->policy
== EBT_ACCEPT
) {
308 read_unlock_bh(&table
->lock
);
311 read_unlock_bh(&table
->lock
);
315 /* If it succeeds, returns element and locks mutex */
317 find_inlist_lock_noload(struct list_head
*head
, const char *name
, int *error
,
321 struct list_head list
;
322 char name
[EBT_FUNCTION_MAXNAMELEN
];
326 list_for_each_entry(e
, head
, list
) {
327 if (strcmp(e
->name
, name
) == 0)
336 find_inlist_lock(struct list_head
*head
, const char *name
, const char *prefix
,
337 int *error
, struct mutex
*mutex
)
339 return try_then_request_module(
340 find_inlist_lock_noload(head
, name
, error
, mutex
),
341 "%s%s", prefix
, name
);
344 static inline struct ebt_table
*
345 find_table_lock(struct net
*net
, const char *name
, int *error
,
348 return find_inlist_lock(&net
->xt
.tables
[NFPROTO_BRIDGE
], name
,
349 "ebtable_", error
, mutex
);
353 ebt_check_match(struct ebt_entry_match
*m
, struct xt_mtchk_param
*par
,
356 const struct ebt_entry
*e
= par
->entryinfo
;
357 struct xt_match
*match
;
358 size_t left
= ((char *)e
+ e
->watchers_offset
) - (char *)m
;
361 if (left
< sizeof(struct ebt_entry_match
) ||
362 left
- sizeof(struct ebt_entry_match
) < m
->match_size
)
365 match
= xt_find_match(NFPROTO_BRIDGE
, m
->u
.name
, 0);
366 if (IS_ERR(match
) || match
->family
!= NFPROTO_BRIDGE
) {
368 module_put(match
->me
);
369 request_module("ebt_%s", m
->u
.name
);
370 match
= xt_find_match(NFPROTO_BRIDGE
, m
->u
.name
, 0);
373 return PTR_ERR(match
);
377 par
->matchinfo
= m
->data
;
378 ret
= xt_check_match(par
, m
->match_size
,
379 e
->ethproto
, e
->invflags
& EBT_IPROTO
);
381 module_put(match
->me
);
390 ebt_check_watcher(struct ebt_entry_watcher
*w
, struct xt_tgchk_param
*par
,
393 const struct ebt_entry
*e
= par
->entryinfo
;
394 struct xt_target
*watcher
;
395 size_t left
= ((char *)e
+ e
->target_offset
) - (char *)w
;
398 if (left
< sizeof(struct ebt_entry_watcher
) ||
399 left
- sizeof(struct ebt_entry_watcher
) < w
->watcher_size
)
402 watcher
= xt_request_find_target(NFPROTO_BRIDGE
, w
->u
.name
, 0);
404 return PTR_ERR(watcher
);
405 w
->u
.watcher
= watcher
;
407 par
->target
= watcher
;
408 par
->targinfo
= w
->data
;
409 ret
= xt_check_target(par
, w
->watcher_size
,
410 e
->ethproto
, e
->invflags
& EBT_IPROTO
);
412 module_put(watcher
->me
);
420 static int ebt_verify_pointers(const struct ebt_replace
*repl
,
421 struct ebt_table_info
*newinfo
)
423 unsigned int limit
= repl
->entries_size
;
424 unsigned int valid_hooks
= repl
->valid_hooks
;
425 unsigned int offset
= 0;
428 for (i
= 0; i
< NF_BR_NUMHOOKS
; i
++)
429 newinfo
->hook_entry
[i
] = NULL
;
431 newinfo
->entries_size
= repl
->entries_size
;
432 newinfo
->nentries
= repl
->nentries
;
434 while (offset
< limit
) {
435 size_t left
= limit
- offset
;
436 struct ebt_entry
*e
= (void *)newinfo
->entries
+ offset
;
438 if (left
< sizeof(unsigned int))
441 for (i
= 0; i
< NF_BR_NUMHOOKS
; i
++) {
442 if ((valid_hooks
& (1 << i
)) == 0)
444 if ((char __user
*)repl
->hook_entry
[i
] ==
445 repl
->entries
+ offset
)
449 if (i
!= NF_BR_NUMHOOKS
|| !(e
->bitmask
& EBT_ENTRY_OR_ENTRIES
)) {
450 if (e
->bitmask
!= 0) {
451 /* we make userspace set this right,
452 * so there is no misunderstanding
454 BUGPRINT("EBT_ENTRY_OR_ENTRIES shouldn't be set "
455 "in distinguisher\n");
458 if (i
!= NF_BR_NUMHOOKS
)
459 newinfo
->hook_entry
[i
] = (struct ebt_entries
*)e
;
460 if (left
< sizeof(struct ebt_entries
))
462 offset
+= sizeof(struct ebt_entries
);
464 if (left
< sizeof(struct ebt_entry
))
466 if (left
< e
->next_offset
)
468 if (e
->next_offset
< sizeof(struct ebt_entry
))
470 offset
+= e
->next_offset
;
473 if (offset
!= limit
) {
474 BUGPRINT("entries_size too small\n");
478 /* check if all valid hooks have a chain */
479 for (i
= 0; i
< NF_BR_NUMHOOKS
; i
++) {
480 if (!newinfo
->hook_entry
[i
] &&
481 (valid_hooks
& (1 << i
))) {
482 BUGPRINT("Valid hook without chain\n");
489 /* this one is very careful, as it is the first function
490 * to parse the userspace data
493 ebt_check_entry_size_and_hooks(const struct ebt_entry
*e
,
494 const struct ebt_table_info
*newinfo
,
495 unsigned int *n
, unsigned int *cnt
,
496 unsigned int *totalcnt
, unsigned int *udc_cnt
)
500 for (i
= 0; i
< NF_BR_NUMHOOKS
; i
++) {
501 if ((void *)e
== (void *)newinfo
->hook_entry
[i
])
504 /* beginning of a new chain
505 * if i == NF_BR_NUMHOOKS it must be a user defined chain
507 if (i
!= NF_BR_NUMHOOKS
|| !e
->bitmask
) {
508 /* this checks if the previous chain has as many entries
512 BUGPRINT("nentries does not equal the nr of entries "
516 if (((struct ebt_entries
*)e
)->policy
!= EBT_DROP
&&
517 ((struct ebt_entries
*)e
)->policy
!= EBT_ACCEPT
) {
518 /* only RETURN from udc */
519 if (i
!= NF_BR_NUMHOOKS
||
520 ((struct ebt_entries
*)e
)->policy
!= EBT_RETURN
) {
521 BUGPRINT("bad policy\n");
525 if (i
== NF_BR_NUMHOOKS
) /* it's a user defined chain */
527 if (((struct ebt_entries
*)e
)->counter_offset
!= *totalcnt
) {
528 BUGPRINT("counter_offset != totalcnt");
531 *n
= ((struct ebt_entries
*)e
)->nentries
;
535 /* a plain old entry, heh */
536 if (sizeof(struct ebt_entry
) > e
->watchers_offset
||
537 e
->watchers_offset
> e
->target_offset
||
538 e
->target_offset
>= e
->next_offset
) {
539 BUGPRINT("entry offsets not in right order\n");
542 /* this is not checked anywhere else */
543 if (e
->next_offset
- e
->target_offset
< sizeof(struct ebt_entry_target
)) {
544 BUGPRINT("target size too small\n");
552 struct ebt_cl_stack
{
553 struct ebt_chainstack cs
;
555 unsigned int hookmask
;
558 /* We need these positions to check that the jumps to a different part of the
559 * entries is a jump to the beginning of a new chain.
562 ebt_get_udc_positions(struct ebt_entry
*e
, struct ebt_table_info
*newinfo
,
563 unsigned int *n
, struct ebt_cl_stack
*udc
)
567 /* we're only interested in chain starts */
570 for (i
= 0; i
< NF_BR_NUMHOOKS
; i
++) {
571 if (newinfo
->hook_entry
[i
] == (struct ebt_entries
*)e
)
574 /* only care about udc */
575 if (i
!= NF_BR_NUMHOOKS
)
578 udc
[*n
].cs
.chaininfo
= (struct ebt_entries
*)e
;
579 /* these initialisations are depended on later in check_chainloops() */
581 udc
[*n
].hookmask
= 0;
588 ebt_cleanup_match(struct ebt_entry_match
*m
, struct net
*net
, unsigned int *i
)
590 struct xt_mtdtor_param par
;
592 if (i
&& (*i
)-- == 0)
596 par
.match
= m
->u
.match
;
597 par
.matchinfo
= m
->data
;
598 par
.family
= NFPROTO_BRIDGE
;
599 if (par
.match
->destroy
!= NULL
)
600 par
.match
->destroy(&par
);
601 module_put(par
.match
->me
);
606 ebt_cleanup_watcher(struct ebt_entry_watcher
*w
, struct net
*net
, unsigned int *i
)
608 struct xt_tgdtor_param par
;
610 if (i
&& (*i
)-- == 0)
614 par
.target
= w
->u
.watcher
;
615 par
.targinfo
= w
->data
;
616 par
.family
= NFPROTO_BRIDGE
;
617 if (par
.target
->destroy
!= NULL
)
618 par
.target
->destroy(&par
);
619 module_put(par
.target
->me
);
624 ebt_cleanup_entry(struct ebt_entry
*e
, struct net
*net
, unsigned int *cnt
)
626 struct xt_tgdtor_param par
;
627 struct ebt_entry_target
*t
;
632 if (cnt
&& (*cnt
)-- == 0)
634 EBT_WATCHER_ITERATE(e
, ebt_cleanup_watcher
, net
, NULL
);
635 EBT_MATCH_ITERATE(e
, ebt_cleanup_match
, net
, NULL
);
636 t
= (struct ebt_entry_target
*)(((char *)e
) + e
->target_offset
);
639 par
.target
= t
->u
.target
;
640 par
.targinfo
= t
->data
;
641 par
.family
= NFPROTO_BRIDGE
;
642 if (par
.target
->destroy
!= NULL
)
643 par
.target
->destroy(&par
);
644 module_put(par
.target
->me
);
649 ebt_check_entry(struct ebt_entry
*e
, struct net
*net
,
650 const struct ebt_table_info
*newinfo
,
651 const char *name
, unsigned int *cnt
,
652 struct ebt_cl_stack
*cl_s
, unsigned int udc_cnt
)
654 struct ebt_entry_target
*t
;
655 struct xt_target
*target
;
656 unsigned int i
, j
, hook
= 0, hookmask
= 0;
659 struct xt_mtchk_param mtpar
;
660 struct xt_tgchk_param tgpar
;
662 /* don't mess with the struct ebt_entries */
666 if (e
->bitmask
& ~EBT_F_MASK
) {
667 BUGPRINT("Unknown flag for bitmask\n");
670 if (e
->invflags
& ~EBT_INV_MASK
) {
671 BUGPRINT("Unknown flag for inv bitmask\n");
674 if ((e
->bitmask
& EBT_NOPROTO
) && (e
->bitmask
& EBT_802_3
)) {
675 BUGPRINT("NOPROTO & 802_3 not allowed\n");
678 /* what hook do we belong to? */
679 for (i
= 0; i
< NF_BR_NUMHOOKS
; i
++) {
680 if (!newinfo
->hook_entry
[i
])
682 if ((char *)newinfo
->hook_entry
[i
] < (char *)e
)
687 /* (1 << NF_BR_NUMHOOKS) tells the check functions the rule is on
690 if (i
< NF_BR_NUMHOOKS
)
691 hookmask
= (1 << hook
) | (1 << NF_BR_NUMHOOKS
);
693 for (i
= 0; i
< udc_cnt
; i
++)
694 if ((char *)(cl_s
[i
].cs
.chaininfo
) > (char *)e
)
697 hookmask
= (1 << hook
) | (1 << NF_BR_NUMHOOKS
);
699 hookmask
= cl_s
[i
- 1].hookmask
;
703 mtpar
.net
= tgpar
.net
= net
;
704 mtpar
.table
= tgpar
.table
= name
;
705 mtpar
.entryinfo
= tgpar
.entryinfo
= e
;
706 mtpar
.hook_mask
= tgpar
.hook_mask
= hookmask
;
707 mtpar
.family
= tgpar
.family
= NFPROTO_BRIDGE
;
708 ret
= EBT_MATCH_ITERATE(e
, ebt_check_match
, &mtpar
, &i
);
710 goto cleanup_matches
;
712 ret
= EBT_WATCHER_ITERATE(e
, ebt_check_watcher
, &tgpar
, &j
);
714 goto cleanup_watchers
;
715 t
= (struct ebt_entry_target
*)(((char *)e
) + e
->target_offset
);
716 gap
= e
->next_offset
- e
->target_offset
;
718 target
= xt_request_find_target(NFPROTO_BRIDGE
, t
->u
.name
, 0);
719 if (IS_ERR(target
)) {
720 ret
= PTR_ERR(target
);
721 goto cleanup_watchers
;
724 t
->u
.target
= target
;
725 if (t
->u
.target
== &ebt_standard_target
) {
726 if (gap
< sizeof(struct ebt_standard_target
)) {
727 BUGPRINT("Standard target size too big\n");
729 goto cleanup_watchers
;
731 if (((struct ebt_standard_target
*)t
)->verdict
<
732 -NUM_STANDARD_TARGETS
) {
733 BUGPRINT("Invalid standard target\n");
735 goto cleanup_watchers
;
737 } else if (t
->target_size
> gap
- sizeof(struct ebt_entry_target
)) {
738 module_put(t
->u
.target
->me
);
740 goto cleanup_watchers
;
743 tgpar
.target
= target
;
744 tgpar
.targinfo
= t
->data
;
745 ret
= xt_check_target(&tgpar
, t
->target_size
,
746 e
->ethproto
, e
->invflags
& EBT_IPROTO
);
748 module_put(target
->me
);
749 goto cleanup_watchers
;
754 EBT_WATCHER_ITERATE(e
, ebt_cleanup_watcher
, net
, &j
);
756 EBT_MATCH_ITERATE(e
, ebt_cleanup_match
, net
, &i
);
760 /* checks for loops and sets the hook mask for udc
761 * the hook mask for udc tells us from which base chains the udc can be
762 * accessed. This mask is a parameter to the check() functions of the extensions
764 static int check_chainloops(const struct ebt_entries
*chain
, struct ebt_cl_stack
*cl_s
,
765 unsigned int udc_cnt
, unsigned int hooknr
, char *base
)
767 int i
, chain_nr
= -1, pos
= 0, nentries
= chain
->nentries
, verdict
;
768 const struct ebt_entry
*e
= (struct ebt_entry
*)chain
->data
;
769 const struct ebt_entry_target
*t
;
771 while (pos
< nentries
|| chain_nr
!= -1) {
772 /* end of udc, go back one 'recursion' step */
773 if (pos
== nentries
) {
774 /* put back values of the time when this chain was called */
775 e
= cl_s
[chain_nr
].cs
.e
;
776 if (cl_s
[chain_nr
].from
!= -1)
778 cl_s
[cl_s
[chain_nr
].from
].cs
.chaininfo
->nentries
;
780 nentries
= chain
->nentries
;
781 pos
= cl_s
[chain_nr
].cs
.n
;
782 /* make sure we won't see a loop that isn't one */
783 cl_s
[chain_nr
].cs
.n
= 0;
784 chain_nr
= cl_s
[chain_nr
].from
;
788 t
= (struct ebt_entry_target
*)
789 (((char *)e
) + e
->target_offset
);
790 if (strcmp(t
->u
.name
, EBT_STANDARD_TARGET
))
792 if (e
->target_offset
+ sizeof(struct ebt_standard_target
) >
794 BUGPRINT("Standard target size too big\n");
797 verdict
= ((struct ebt_standard_target
*)t
)->verdict
;
798 if (verdict
>= 0) { /* jump to another chain */
799 struct ebt_entries
*hlp2
=
800 (struct ebt_entries
*)(base
+ verdict
);
801 for (i
= 0; i
< udc_cnt
; i
++)
802 if (hlp2
== cl_s
[i
].cs
.chaininfo
)
804 /* bad destination or loop */
806 BUGPRINT("bad destination\n");
813 if (cl_s
[i
].hookmask
& (1 << hooknr
))
815 /* this can't be 0, so the loop test is correct */
816 cl_s
[i
].cs
.n
= pos
+ 1;
818 cl_s
[i
].cs
.e
= ebt_next_entry(e
);
819 e
= (struct ebt_entry
*)(hlp2
->data
);
820 nentries
= hlp2
->nentries
;
821 cl_s
[i
].from
= chain_nr
;
823 /* this udc is accessible from the base chain for hooknr */
824 cl_s
[i
].hookmask
|= (1 << hooknr
);
828 e
= ebt_next_entry(e
);
834 /* do the parsing of the table/chains/entries/matches/watchers/targets, heh */
835 static int translate_table(struct net
*net
, const char *name
,
836 struct ebt_table_info
*newinfo
)
838 unsigned int i
, j
, k
, udc_cnt
;
840 struct ebt_cl_stack
*cl_s
= NULL
; /* used in the checking for chain loops */
843 while (i
< NF_BR_NUMHOOKS
&& !newinfo
->hook_entry
[i
])
845 if (i
== NF_BR_NUMHOOKS
) {
846 BUGPRINT("No valid hooks specified\n");
849 if (newinfo
->hook_entry
[i
] != (struct ebt_entries
*)newinfo
->entries
) {
850 BUGPRINT("Chains don't start at beginning\n");
853 /* make sure chains are ordered after each other in same order
854 * as their corresponding hooks
856 for (j
= i
+ 1; j
< NF_BR_NUMHOOKS
; j
++) {
857 if (!newinfo
->hook_entry
[j
])
859 if (newinfo
->hook_entry
[j
] <= newinfo
->hook_entry
[i
]) {
860 BUGPRINT("Hook order must be followed\n");
866 /* do some early checkings and initialize some things */
867 i
= 0; /* holds the expected nr. of entries for the chain */
868 j
= 0; /* holds the up to now counted entries for the chain */
869 k
= 0; /* holds the total nr. of entries, should equal
870 * newinfo->nentries afterwards
872 udc_cnt
= 0; /* will hold the nr. of user defined chains (udc) */
873 ret
= EBT_ENTRY_ITERATE(newinfo
->entries
, newinfo
->entries_size
,
874 ebt_check_entry_size_and_hooks
, newinfo
,
875 &i
, &j
, &k
, &udc_cnt
);
881 BUGPRINT("nentries does not equal the nr of entries in the "
885 if (k
!= newinfo
->nentries
) {
886 BUGPRINT("Total nentries is wrong\n");
890 /* get the location of the udc, put them in an array
891 * while we're at it, allocate the chainstack
894 /* this will get free'd in do_replace()/ebt_register_table()
897 newinfo
->chainstack
=
898 vmalloc(nr_cpu_ids
* sizeof(*(newinfo
->chainstack
)));
899 if (!newinfo
->chainstack
)
901 for_each_possible_cpu(i
) {
902 newinfo
->chainstack
[i
] =
903 vmalloc(udc_cnt
* sizeof(*(newinfo
->chainstack
[0])));
904 if (!newinfo
->chainstack
[i
]) {
906 vfree(newinfo
->chainstack
[--i
]);
907 vfree(newinfo
->chainstack
);
908 newinfo
->chainstack
= NULL
;
913 cl_s
= vmalloc(udc_cnt
* sizeof(*cl_s
));
916 i
= 0; /* the i'th udc */
917 EBT_ENTRY_ITERATE(newinfo
->entries
, newinfo
->entries_size
,
918 ebt_get_udc_positions
, newinfo
, &i
, cl_s
);
921 BUGPRINT("i != udc_cnt\n");
927 /* Check for loops */
928 for (i
= 0; i
< NF_BR_NUMHOOKS
; i
++)
929 if (newinfo
->hook_entry
[i
])
930 if (check_chainloops(newinfo
->hook_entry
[i
],
931 cl_s
, udc_cnt
, i
, newinfo
->entries
)) {
936 /* we now know the following (along with E=mc²):
937 * - the nr of entries in each chain is right
938 * - the size of the allocated space is right
939 * - all valid hooks have a corresponding chain
940 * - there are no loops
941 * - wrong data can still be on the level of a single entry
942 * - could be there are jumps to places that are not the
943 * beginning of a chain. This can only occur in chains that
944 * are not accessible from any base chains, so we don't care.
947 /* used to know what we need to clean up if something goes wrong */
949 ret
= EBT_ENTRY_ITERATE(newinfo
->entries
, newinfo
->entries_size
,
950 ebt_check_entry
, net
, newinfo
, name
, &i
, cl_s
, udc_cnt
);
952 EBT_ENTRY_ITERATE(newinfo
->entries
, newinfo
->entries_size
,
953 ebt_cleanup_entry
, net
, &i
);
959 /* called under write_lock */
960 static void get_counters(const struct ebt_counter
*oldcounters
,
961 struct ebt_counter
*counters
, unsigned int nentries
)
964 struct ebt_counter
*counter_base
;
966 /* counters of cpu 0 */
967 memcpy(counters
, oldcounters
,
968 sizeof(struct ebt_counter
) * nentries
);
970 /* add other counters to those of cpu 0 */
971 for_each_possible_cpu(cpu
) {
974 counter_base
= COUNTER_BASE(oldcounters
, nentries
, cpu
);
975 for (i
= 0; i
< nentries
; i
++) {
976 counters
[i
].pcnt
+= counter_base
[i
].pcnt
;
977 counters
[i
].bcnt
+= counter_base
[i
].bcnt
;
982 static int do_replace_finish(struct net
*net
, struct ebt_replace
*repl
,
983 struct ebt_table_info
*newinfo
)
986 struct ebt_counter
*counterstmp
= NULL
;
987 /* used to be able to unlock earlier */
988 struct ebt_table_info
*table
;
991 /* the user wants counters back
992 * the check on the size is done later, when we have the lock
994 if (repl
->num_counters
) {
995 unsigned long size
= repl
->num_counters
* sizeof(*counterstmp
);
996 counterstmp
= vmalloc(size
);
1001 newinfo
->chainstack
= NULL
;
1002 ret
= ebt_verify_pointers(repl
, newinfo
);
1004 goto free_counterstmp
;
1006 ret
= translate_table(net
, repl
->name
, newinfo
);
1009 goto free_counterstmp
;
1011 t
= find_table_lock(net
, repl
->name
, &ret
, &ebt_mutex
);
1017 /* the table doesn't like it */
1018 if (t
->check
&& (ret
= t
->check(newinfo
, repl
->valid_hooks
)))
1021 if (repl
->num_counters
&& repl
->num_counters
!= t
->private->nentries
) {
1022 BUGPRINT("Wrong nr. of counters requested\n");
1027 /* we have the mutex lock, so no danger in reading this pointer */
1029 /* make sure the table can only be rmmod'ed if it contains no rules */
1030 if (!table
->nentries
&& newinfo
->nentries
&& !try_module_get(t
->me
)) {
1033 } else if (table
->nentries
&& !newinfo
->nentries
)
1035 /* we need an atomic snapshot of the counters */
1036 write_lock_bh(&t
->lock
);
1037 if (repl
->num_counters
)
1038 get_counters(t
->private->counters
, counterstmp
,
1039 t
->private->nentries
);
1041 t
->private = newinfo
;
1042 write_unlock_bh(&t
->lock
);
1043 mutex_unlock(&ebt_mutex
);
1044 /* so, a user can change the chains while having messed up her counter
1045 * allocation. Only reason why this is done is because this way the lock
1046 * is held only once, while this doesn't bring the kernel into a
1049 if (repl
->num_counters
&&
1050 copy_to_user(repl
->counters
, counterstmp
,
1051 repl
->num_counters
* sizeof(struct ebt_counter
))) {
1052 /* Silent error, can't fail, new table is already in place */
1053 net_warn_ratelimited("ebtables: counters copy to user failed while replacing table\n");
1056 /* decrease module count and free resources */
1057 EBT_ENTRY_ITERATE(table
->entries
, table
->entries_size
,
1058 ebt_cleanup_entry
, net
, NULL
);
1060 vfree(table
->entries
);
1061 if (table
->chainstack
) {
1062 for_each_possible_cpu(i
)
1063 vfree(table
->chainstack
[i
]);
1064 vfree(table
->chainstack
);
1071 if (audit_enabled
) {
1072 struct audit_buffer
*ab
;
1074 ab
= audit_log_start(current
->audit_context
, GFP_KERNEL
,
1075 AUDIT_NETFILTER_CFG
);
1077 audit_log_format(ab
, "table=%s family=%u entries=%u",
1078 repl
->name
, AF_BRIDGE
, repl
->nentries
);
1086 mutex_unlock(&ebt_mutex
);
1088 EBT_ENTRY_ITERATE(newinfo
->entries
, newinfo
->entries_size
,
1089 ebt_cleanup_entry
, net
, NULL
);
1092 /* can be initialized in translate_table() */
1093 if (newinfo
->chainstack
) {
1094 for_each_possible_cpu(i
)
1095 vfree(newinfo
->chainstack
[i
]);
1096 vfree(newinfo
->chainstack
);
1101 /* replace the table */
1102 static int do_replace(struct net
*net
, const void __user
*user
,
1105 int ret
, countersize
;
1106 struct ebt_table_info
*newinfo
;
1107 struct ebt_replace tmp
;
1109 if (copy_from_user(&tmp
, user
, sizeof(tmp
)) != 0)
1112 if (len
!= sizeof(tmp
) + tmp
.entries_size
) {
1113 BUGPRINT("Wrong len argument\n");
1117 if (tmp
.entries_size
== 0) {
1118 BUGPRINT("Entries_size never zero\n");
1121 /* overflow check */
1122 if (tmp
.nentries
>= ((INT_MAX
- sizeof(struct ebt_table_info
)) /
1123 NR_CPUS
- SMP_CACHE_BYTES
) / sizeof(struct ebt_counter
))
1125 if (tmp
.num_counters
>= INT_MAX
/ sizeof(struct ebt_counter
))
1128 tmp
.name
[sizeof(tmp
.name
) - 1] = 0;
1130 countersize
= COUNTER_OFFSET(tmp
.nentries
) * nr_cpu_ids
;
1131 newinfo
= vmalloc(sizeof(*newinfo
) + countersize
);
1136 memset(newinfo
->counters
, 0, countersize
);
1138 newinfo
->entries
= vmalloc(tmp
.entries_size
);
1139 if (!newinfo
->entries
) {
1144 newinfo
->entries
, tmp
.entries
, tmp
.entries_size
) != 0) {
1145 BUGPRINT("Couldn't copy entries from userspace\n");
1150 ret
= do_replace_finish(net
, &tmp
, newinfo
);
1154 vfree(newinfo
->entries
);
1161 ebt_register_table(struct net
*net
, const struct ebt_table
*input_table
)
1163 struct ebt_table_info
*newinfo
;
1164 struct ebt_table
*t
, *table
;
1165 struct ebt_replace_kernel
*repl
;
1166 int ret
, i
, countersize
;
1169 if (input_table
== NULL
|| (repl
= input_table
->table
) == NULL
||
1170 repl
->entries
== NULL
|| repl
->entries_size
== 0 ||
1171 repl
->counters
!= NULL
|| input_table
->private != NULL
) {
1172 BUGPRINT("Bad table data for ebt_register_table!!!\n");
1173 return ERR_PTR(-EINVAL
);
1176 /* Don't add one table to multiple lists. */
1177 table
= kmemdup(input_table
, sizeof(struct ebt_table
), GFP_KERNEL
);
1183 countersize
= COUNTER_OFFSET(repl
->nentries
) * nr_cpu_ids
;
1184 newinfo
= vmalloc(sizeof(*newinfo
) + countersize
);
1189 p
= vmalloc(repl
->entries_size
);
1193 memcpy(p
, repl
->entries
, repl
->entries_size
);
1194 newinfo
->entries
= p
;
1196 newinfo
->entries_size
= repl
->entries_size
;
1197 newinfo
->nentries
= repl
->nentries
;
1200 memset(newinfo
->counters
, 0, countersize
);
1202 /* fill in newinfo and parse the entries */
1203 newinfo
->chainstack
= NULL
;
1204 for (i
= 0; i
< NF_BR_NUMHOOKS
; i
++) {
1205 if ((repl
->valid_hooks
& (1 << i
)) == 0)
1206 newinfo
->hook_entry
[i
] = NULL
;
1208 newinfo
->hook_entry
[i
] = p
+
1209 ((char *)repl
->hook_entry
[i
] - repl
->entries
);
1211 ret
= translate_table(net
, repl
->name
, newinfo
);
1213 BUGPRINT("Translate_table failed\n");
1214 goto free_chainstack
;
1217 if (table
->check
&& table
->check(newinfo
, table
->valid_hooks
)) {
1218 BUGPRINT("The table doesn't like its own initial data, lol\n");
1220 goto free_chainstack
;
1223 table
->private = newinfo
;
1224 rwlock_init(&table
->lock
);
1225 mutex_lock(&ebt_mutex
);
1226 list_for_each_entry(t
, &net
->xt
.tables
[NFPROTO_BRIDGE
], list
) {
1227 if (strcmp(t
->name
, table
->name
) == 0) {
1229 BUGPRINT("Table name already exists\n");
1234 /* Hold a reference count if the chains aren't empty */
1235 if (newinfo
->nentries
&& !try_module_get(table
->me
)) {
1239 list_add(&table
->list
, &net
->xt
.tables
[NFPROTO_BRIDGE
]);
1240 mutex_unlock(&ebt_mutex
);
1243 mutex_unlock(&ebt_mutex
);
1245 if (newinfo
->chainstack
) {
1246 for_each_possible_cpu(i
)
1247 vfree(newinfo
->chainstack
[i
]);
1248 vfree(newinfo
->chainstack
);
1250 vfree(newinfo
->entries
);
1256 return ERR_PTR(ret
);
1259 void ebt_unregister_table(struct net
*net
, struct ebt_table
*table
)
1264 BUGPRINT("Request to unregister NULL table!!!\n");
1267 mutex_lock(&ebt_mutex
);
1268 list_del(&table
->list
);
1269 mutex_unlock(&ebt_mutex
);
1270 EBT_ENTRY_ITERATE(table
->private->entries
, table
->private->entries_size
,
1271 ebt_cleanup_entry
, net
, NULL
);
1272 if (table
->private->nentries
)
1273 module_put(table
->me
);
1274 vfree(table
->private->entries
);
1275 if (table
->private->chainstack
) {
1276 for_each_possible_cpu(i
)
1277 vfree(table
->private->chainstack
[i
]);
1278 vfree(table
->private->chainstack
);
1280 vfree(table
->private);
1284 /* userspace just supplied us with counters */
1285 static int do_update_counters(struct net
*net
, const char *name
,
1286 struct ebt_counter __user
*counters
,
1287 unsigned int num_counters
,
1288 const void __user
*user
, unsigned int len
)
1291 struct ebt_counter
*tmp
;
1292 struct ebt_table
*t
;
1294 if (num_counters
== 0)
1297 tmp
= vmalloc(num_counters
* sizeof(*tmp
));
1301 t
= find_table_lock(net
, name
, &ret
, &ebt_mutex
);
1305 if (num_counters
!= t
->private->nentries
) {
1306 BUGPRINT("Wrong nr of counters\n");
1311 if (copy_from_user(tmp
, counters
, num_counters
* sizeof(*counters
))) {
1316 /* we want an atomic add of the counters */
1317 write_lock_bh(&t
->lock
);
1319 /* we add to the counters of the first cpu */
1320 for (i
= 0; i
< num_counters
; i
++) {
1321 t
->private->counters
[i
].pcnt
+= tmp
[i
].pcnt
;
1322 t
->private->counters
[i
].bcnt
+= tmp
[i
].bcnt
;
1325 write_unlock_bh(&t
->lock
);
1328 mutex_unlock(&ebt_mutex
);
1334 static int update_counters(struct net
*net
, const void __user
*user
,
1337 struct ebt_replace hlp
;
1339 if (copy_from_user(&hlp
, user
, sizeof(hlp
)))
1342 if (len
!= sizeof(hlp
) + hlp
.num_counters
* sizeof(struct ebt_counter
))
1345 return do_update_counters(net
, hlp
.name
, hlp
.counters
,
1346 hlp
.num_counters
, user
, len
);
1349 static inline int ebt_make_matchname(const struct ebt_entry_match
*m
,
1350 const char *base
, char __user
*ubase
)
1352 char __user
*hlp
= ubase
+ ((char *)m
- base
);
1353 char name
[EBT_FUNCTION_MAXNAMELEN
] = {};
1355 /* ebtables expects 32 bytes long names but xt_match names are 29 bytes
1356 * long. Copy 29 bytes and fill remaining bytes with zeroes.
1358 strlcpy(name
, m
->u
.match
->name
, sizeof(name
));
1359 if (copy_to_user(hlp
, name
, EBT_FUNCTION_MAXNAMELEN
))
1364 static inline int ebt_make_watchername(const struct ebt_entry_watcher
*w
,
1365 const char *base
, char __user
*ubase
)
1367 char __user
*hlp
= ubase
+ ((char *)w
- base
);
1368 char name
[EBT_FUNCTION_MAXNAMELEN
] = {};
1370 strlcpy(name
, w
->u
.watcher
->name
, sizeof(name
));
1371 if (copy_to_user(hlp
, name
, EBT_FUNCTION_MAXNAMELEN
))
1376 static inline int ebt_make_names(struct ebt_entry
*e
, const char *base
,
1381 const struct ebt_entry_target
*t
;
1382 char name
[EBT_FUNCTION_MAXNAMELEN
] = {};
1384 if (e
->bitmask
== 0)
1387 hlp
= ubase
+ (((char *)e
+ e
->target_offset
) - base
);
1388 t
= (struct ebt_entry_target
*)(((char *)e
) + e
->target_offset
);
1390 ret
= EBT_MATCH_ITERATE(e
, ebt_make_matchname
, base
, ubase
);
1393 ret
= EBT_WATCHER_ITERATE(e
, ebt_make_watchername
, base
, ubase
);
1396 strlcpy(name
, t
->u
.target
->name
, sizeof(name
));
1397 if (copy_to_user(hlp
, name
, EBT_FUNCTION_MAXNAMELEN
))
1402 static int copy_counters_to_user(struct ebt_table
*t
,
1403 const struct ebt_counter
*oldcounters
,
1404 void __user
*user
, unsigned int num_counters
,
1405 unsigned int nentries
)
1407 struct ebt_counter
*counterstmp
;
1410 /* userspace might not need the counters */
1411 if (num_counters
== 0)
1414 if (num_counters
!= nentries
) {
1415 BUGPRINT("Num_counters wrong\n");
1419 counterstmp
= vmalloc(nentries
* sizeof(*counterstmp
));
1423 write_lock_bh(&t
->lock
);
1424 get_counters(oldcounters
, counterstmp
, nentries
);
1425 write_unlock_bh(&t
->lock
);
1427 if (copy_to_user(user
, counterstmp
,
1428 nentries
* sizeof(struct ebt_counter
)))
1434 /* called with ebt_mutex locked */
1435 static int copy_everything_to_user(struct ebt_table
*t
, void __user
*user
,
1436 const int *len
, int cmd
)
1438 struct ebt_replace tmp
;
1439 const struct ebt_counter
*oldcounters
;
1440 unsigned int entries_size
, nentries
;
1444 if (cmd
== EBT_SO_GET_ENTRIES
) {
1445 entries_size
= t
->private->entries_size
;
1446 nentries
= t
->private->nentries
;
1447 entries
= t
->private->entries
;
1448 oldcounters
= t
->private->counters
;
1450 entries_size
= t
->table
->entries_size
;
1451 nentries
= t
->table
->nentries
;
1452 entries
= t
->table
->entries
;
1453 oldcounters
= t
->table
->counters
;
1456 if (copy_from_user(&tmp
, user
, sizeof(tmp
)))
1459 if (*len
!= sizeof(struct ebt_replace
) + entries_size
+
1460 (tmp
.num_counters
? nentries
* sizeof(struct ebt_counter
) : 0))
1463 if (tmp
.nentries
!= nentries
) {
1464 BUGPRINT("Nentries wrong\n");
1468 if (tmp
.entries_size
!= entries_size
) {
1469 BUGPRINT("Wrong size\n");
1473 ret
= copy_counters_to_user(t
, oldcounters
, tmp
.counters
,
1474 tmp
.num_counters
, nentries
);
1478 if (copy_to_user(tmp
.entries
, entries
, entries_size
)) {
1479 BUGPRINT("Couldn't copy entries to userspace\n");
1482 /* set the match/watcher/target names right */
1483 return EBT_ENTRY_ITERATE(entries
, entries_size
,
1484 ebt_make_names
, entries
, tmp
.entries
);
1487 static int do_ebt_set_ctl(struct sock
*sk
,
1488 int cmd
, void __user
*user
, unsigned int len
)
1491 struct net
*net
= sock_net(sk
);
1493 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
1497 case EBT_SO_SET_ENTRIES
:
1498 ret
= do_replace(net
, user
, len
);
1500 case EBT_SO_SET_COUNTERS
:
1501 ret
= update_counters(net
, user
, len
);
1509 static int do_ebt_get_ctl(struct sock
*sk
, int cmd
, void __user
*user
, int *len
)
1512 struct ebt_replace tmp
;
1513 struct ebt_table
*t
;
1514 struct net
*net
= sock_net(sk
);
1516 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
1519 if (copy_from_user(&tmp
, user
, sizeof(tmp
)))
1522 tmp
.name
[sizeof(tmp
.name
) - 1] = '\0';
1524 t
= find_table_lock(net
, tmp
.name
, &ret
, &ebt_mutex
);
1529 case EBT_SO_GET_INFO
:
1530 case EBT_SO_GET_INIT_INFO
:
1531 if (*len
!= sizeof(struct ebt_replace
)) {
1533 mutex_unlock(&ebt_mutex
);
1536 if (cmd
== EBT_SO_GET_INFO
) {
1537 tmp
.nentries
= t
->private->nentries
;
1538 tmp
.entries_size
= t
->private->entries_size
;
1539 tmp
.valid_hooks
= t
->valid_hooks
;
1541 tmp
.nentries
= t
->table
->nentries
;
1542 tmp
.entries_size
= t
->table
->entries_size
;
1543 tmp
.valid_hooks
= t
->table
->valid_hooks
;
1545 mutex_unlock(&ebt_mutex
);
1546 if (copy_to_user(user
, &tmp
, *len
) != 0) {
1547 BUGPRINT("c2u Didn't work\n");
1554 case EBT_SO_GET_ENTRIES
:
1555 case EBT_SO_GET_INIT_ENTRIES
:
1556 ret
= copy_everything_to_user(t
, user
, len
, cmd
);
1557 mutex_unlock(&ebt_mutex
);
1561 mutex_unlock(&ebt_mutex
);
1568 #ifdef CONFIG_COMPAT
1569 /* 32 bit-userspace compatibility definitions. */
1570 struct compat_ebt_replace
{
1571 char name
[EBT_TABLE_MAXNAMELEN
];
1572 compat_uint_t valid_hooks
;
1573 compat_uint_t nentries
;
1574 compat_uint_t entries_size
;
1575 /* start of the chains */
1576 compat_uptr_t hook_entry
[NF_BR_NUMHOOKS
];
1577 /* nr of counters userspace expects back */
1578 compat_uint_t num_counters
;
1579 /* where the kernel will put the old counters. */
1580 compat_uptr_t counters
;
1581 compat_uptr_t entries
;
1584 /* struct ebt_entry_match, _target and _watcher have same layout */
1585 struct compat_ebt_entry_mwt
{
1587 char name
[EBT_FUNCTION_MAXNAMELEN
];
1590 compat_uint_t match_size
;
1591 compat_uint_t data
[0];
1594 /* account for possible padding between match_size and ->data */
1595 static int ebt_compat_entry_padsize(void)
1597 BUILD_BUG_ON(XT_ALIGN(sizeof(struct ebt_entry_match
)) <
1598 COMPAT_XT_ALIGN(sizeof(struct compat_ebt_entry_mwt
)));
1599 return (int) XT_ALIGN(sizeof(struct ebt_entry_match
)) -
1600 COMPAT_XT_ALIGN(sizeof(struct compat_ebt_entry_mwt
));
1603 static int ebt_compat_match_offset(const struct xt_match
*match
,
1604 unsigned int userlen
)
1606 /* ebt_among needs special handling. The kernel .matchsize is
1607 * set to -1 at registration time; at runtime an EBT_ALIGN()ed
1608 * value is expected.
1609 * Example: userspace sends 4500, ebt_among.c wants 4504.
1611 if (unlikely(match
->matchsize
== -1))
1612 return XT_ALIGN(userlen
) - COMPAT_XT_ALIGN(userlen
);
1613 return xt_compat_match_offset(match
);
1616 static int compat_match_to_user(struct ebt_entry_match
*m
, void __user
**dstptr
,
1619 const struct xt_match
*match
= m
->u
.match
;
1620 struct compat_ebt_entry_mwt __user
*cm
= *dstptr
;
1621 int off
= ebt_compat_match_offset(match
, m
->match_size
);
1622 compat_uint_t msize
= m
->match_size
- off
;
1624 BUG_ON(off
>= m
->match_size
);
1626 if (copy_to_user(cm
->u
.name
, match
->name
,
1627 strlen(match
->name
) + 1) || put_user(msize
, &cm
->match_size
))
1630 if (match
->compat_to_user
) {
1631 if (match
->compat_to_user(cm
->data
, m
->data
))
1633 } else if (copy_to_user(cm
->data
, m
->data
, msize
))
1636 *size
-= ebt_compat_entry_padsize() + off
;
1642 static int compat_target_to_user(struct ebt_entry_target
*t
,
1643 void __user
**dstptr
,
1646 const struct xt_target
*target
= t
->u
.target
;
1647 struct compat_ebt_entry_mwt __user
*cm
= *dstptr
;
1648 int off
= xt_compat_target_offset(target
);
1649 compat_uint_t tsize
= t
->target_size
- off
;
1651 BUG_ON(off
>= t
->target_size
);
1653 if (copy_to_user(cm
->u
.name
, target
->name
,
1654 strlen(target
->name
) + 1) || put_user(tsize
, &cm
->match_size
))
1657 if (target
->compat_to_user
) {
1658 if (target
->compat_to_user(cm
->data
, t
->data
))
1660 } else if (copy_to_user(cm
->data
, t
->data
, tsize
))
1663 *size
-= ebt_compat_entry_padsize() + off
;
1669 static int compat_watcher_to_user(struct ebt_entry_watcher
*w
,
1670 void __user
**dstptr
,
1673 return compat_target_to_user((struct ebt_entry_target
*)w
,
1677 static int compat_copy_entry_to_user(struct ebt_entry
*e
, void __user
**dstptr
,
1680 struct ebt_entry_target
*t
;
1681 struct ebt_entry __user
*ce
;
1682 u32 watchers_offset
, target_offset
, next_offset
;
1683 compat_uint_t origsize
;
1686 if (e
->bitmask
== 0) {
1687 if (*size
< sizeof(struct ebt_entries
))
1689 if (copy_to_user(*dstptr
, e
, sizeof(struct ebt_entries
)))
1692 *dstptr
+= sizeof(struct ebt_entries
);
1693 *size
-= sizeof(struct ebt_entries
);
1697 if (*size
< sizeof(*ce
))
1700 ce
= (struct ebt_entry __user
*)*dstptr
;
1701 if (copy_to_user(ce
, e
, sizeof(*ce
)))
1705 *dstptr
+= sizeof(*ce
);
1707 ret
= EBT_MATCH_ITERATE(e
, compat_match_to_user
, dstptr
, size
);
1710 watchers_offset
= e
->watchers_offset
- (origsize
- *size
);
1712 ret
= EBT_WATCHER_ITERATE(e
, compat_watcher_to_user
, dstptr
, size
);
1715 target_offset
= e
->target_offset
- (origsize
- *size
);
1717 t
= (struct ebt_entry_target
*) ((char *) e
+ e
->target_offset
);
1719 ret
= compat_target_to_user(t
, dstptr
, size
);
1722 next_offset
= e
->next_offset
- (origsize
- *size
);
1724 if (put_user(watchers_offset
, &ce
->watchers_offset
) ||
1725 put_user(target_offset
, &ce
->target_offset
) ||
1726 put_user(next_offset
, &ce
->next_offset
))
1729 *size
-= sizeof(*ce
);
1733 static int compat_calc_match(struct ebt_entry_match
*m
, int *off
)
1735 *off
+= ebt_compat_match_offset(m
->u
.match
, m
->match_size
);
1736 *off
+= ebt_compat_entry_padsize();
1740 static int compat_calc_watcher(struct ebt_entry_watcher
*w
, int *off
)
1742 *off
+= xt_compat_target_offset(w
->u
.watcher
);
1743 *off
+= ebt_compat_entry_padsize();
1747 static int compat_calc_entry(const struct ebt_entry
*e
,
1748 const struct ebt_table_info
*info
,
1750 struct compat_ebt_replace
*newinfo
)
1752 const struct ebt_entry_target
*t
;
1753 unsigned int entry_offset
;
1756 if (e
->bitmask
== 0)
1760 entry_offset
= (void *)e
- base
;
1762 EBT_MATCH_ITERATE(e
, compat_calc_match
, &off
);
1763 EBT_WATCHER_ITERATE(e
, compat_calc_watcher
, &off
);
1765 t
= (const struct ebt_entry_target
*) ((char *) e
+ e
->target_offset
);
1767 off
+= xt_compat_target_offset(t
->u
.target
);
1768 off
+= ebt_compat_entry_padsize();
1770 newinfo
->entries_size
-= off
;
1772 ret
= xt_compat_add_offset(NFPROTO_BRIDGE
, entry_offset
, off
);
1776 for (i
= 0; i
< NF_BR_NUMHOOKS
; i
++) {
1777 const void *hookptr
= info
->hook_entry
[i
];
1778 if (info
->hook_entry
[i
] &&
1779 (e
< (struct ebt_entry
*)(base
- hookptr
))) {
1780 newinfo
->hook_entry
[i
] -= off
;
1781 pr_debug("0x%08X -> 0x%08X\n",
1782 newinfo
->hook_entry
[i
] + off
,
1783 newinfo
->hook_entry
[i
]);
1791 static int compat_table_info(const struct ebt_table_info
*info
,
1792 struct compat_ebt_replace
*newinfo
)
1794 unsigned int size
= info
->entries_size
;
1795 const void *entries
= info
->entries
;
1797 newinfo
->entries_size
= size
;
1799 xt_compat_init_offsets(NFPROTO_BRIDGE
, info
->nentries
);
1800 return EBT_ENTRY_ITERATE(entries
, size
, compat_calc_entry
, info
,
1804 static int compat_copy_everything_to_user(struct ebt_table
*t
,
1805 void __user
*user
, int *len
, int cmd
)
1807 struct compat_ebt_replace repl
, tmp
;
1808 struct ebt_counter
*oldcounters
;
1809 struct ebt_table_info tinfo
;
1813 memset(&tinfo
, 0, sizeof(tinfo
));
1815 if (cmd
== EBT_SO_GET_ENTRIES
) {
1816 tinfo
.entries_size
= t
->private->entries_size
;
1817 tinfo
.nentries
= t
->private->nentries
;
1818 tinfo
.entries
= t
->private->entries
;
1819 oldcounters
= t
->private->counters
;
1821 tinfo
.entries_size
= t
->table
->entries_size
;
1822 tinfo
.nentries
= t
->table
->nentries
;
1823 tinfo
.entries
= t
->table
->entries
;
1824 oldcounters
= t
->table
->counters
;
1827 if (copy_from_user(&tmp
, user
, sizeof(tmp
)))
1830 if (tmp
.nentries
!= tinfo
.nentries
||
1831 (tmp
.num_counters
&& tmp
.num_counters
!= tinfo
.nentries
))
1834 memcpy(&repl
, &tmp
, sizeof(repl
));
1835 if (cmd
== EBT_SO_GET_ENTRIES
)
1836 ret
= compat_table_info(t
->private, &repl
);
1838 ret
= compat_table_info(&tinfo
, &repl
);
1842 if (*len
!= sizeof(tmp
) + repl
.entries_size
+
1843 (tmp
.num_counters
? tinfo
.nentries
* sizeof(struct ebt_counter
): 0)) {
1844 pr_err("wrong size: *len %d, entries_size %u, replsz %d\n",
1845 *len
, tinfo
.entries_size
, repl
.entries_size
);
1849 /* userspace might not need the counters */
1850 ret
= copy_counters_to_user(t
, oldcounters
, compat_ptr(tmp
.counters
),
1851 tmp
.num_counters
, tinfo
.nentries
);
1855 pos
= compat_ptr(tmp
.entries
);
1856 return EBT_ENTRY_ITERATE(tinfo
.entries
, tinfo
.entries_size
,
1857 compat_copy_entry_to_user
, &pos
, &tmp
.entries_size
);
1860 struct ebt_entries_buf_state
{
1861 char *buf_kern_start
; /* kernel buffer to copy (translated) data to */
1862 u32 buf_kern_len
; /* total size of kernel buffer */
1863 u32 buf_kern_offset
; /* amount of data copied so far */
1864 u32 buf_user_offset
; /* read position in userspace buffer */
1867 static int ebt_buf_count(struct ebt_entries_buf_state
*state
, unsigned int sz
)
1869 state
->buf_kern_offset
+= sz
;
1870 return state
->buf_kern_offset
>= sz
? 0 : -EINVAL
;
1873 static int ebt_buf_add(struct ebt_entries_buf_state
*state
,
1874 void *data
, unsigned int sz
)
1876 if (state
->buf_kern_start
== NULL
)
1879 BUG_ON(state
->buf_kern_offset
+ sz
> state
->buf_kern_len
);
1881 memcpy(state
->buf_kern_start
+ state
->buf_kern_offset
, data
, sz
);
1884 state
->buf_user_offset
+= sz
;
1885 return ebt_buf_count(state
, sz
);
1888 static int ebt_buf_add_pad(struct ebt_entries_buf_state
*state
, unsigned int sz
)
1890 char *b
= state
->buf_kern_start
;
1892 BUG_ON(b
&& state
->buf_kern_offset
> state
->buf_kern_len
);
1894 if (b
!= NULL
&& sz
> 0)
1895 memset(b
+ state
->buf_kern_offset
, 0, sz
);
1896 /* do not adjust ->buf_user_offset here, we added kernel-side padding */
1897 return ebt_buf_count(state
, sz
);
1906 static int compat_mtw_from_user(struct compat_ebt_entry_mwt
*mwt
,
1907 enum compat_mwt compat_mwt
,
1908 struct ebt_entries_buf_state
*state
,
1909 const unsigned char *base
)
1911 char name
[EBT_FUNCTION_MAXNAMELEN
];
1912 struct xt_match
*match
;
1913 struct xt_target
*wt
;
1916 unsigned int size_kern
, match_size
= mwt
->match_size
;
1918 strlcpy(name
, mwt
->u
.name
, sizeof(name
));
1920 if (state
->buf_kern_start
)
1921 dst
= state
->buf_kern_start
+ state
->buf_kern_offset
;
1923 switch (compat_mwt
) {
1924 case EBT_COMPAT_MATCH
:
1925 match
= xt_request_find_match(NFPROTO_BRIDGE
, name
, 0);
1927 return PTR_ERR(match
);
1929 off
= ebt_compat_match_offset(match
, match_size
);
1931 if (match
->compat_from_user
)
1932 match
->compat_from_user(dst
, mwt
->data
);
1934 memcpy(dst
, mwt
->data
, match_size
);
1937 size_kern
= match
->matchsize
;
1938 if (unlikely(size_kern
== -1))
1939 size_kern
= match_size
;
1940 module_put(match
->me
);
1942 case EBT_COMPAT_WATCHER
: /* fallthrough */
1943 case EBT_COMPAT_TARGET
:
1944 wt
= xt_request_find_target(NFPROTO_BRIDGE
, name
, 0);
1947 off
= xt_compat_target_offset(wt
);
1950 if (wt
->compat_from_user
)
1951 wt
->compat_from_user(dst
, mwt
->data
);
1953 memcpy(dst
, mwt
->data
, match_size
);
1956 size_kern
= wt
->targetsize
;
1964 state
->buf_kern_offset
+= match_size
+ off
;
1965 state
->buf_user_offset
+= match_size
;
1966 pad
= XT_ALIGN(size_kern
) - size_kern
;
1968 if (pad
> 0 && dst
) {
1969 BUG_ON(state
->buf_kern_len
<= pad
);
1970 BUG_ON(state
->buf_kern_offset
- (match_size
+ off
) + size_kern
> state
->buf_kern_len
- pad
);
1971 memset(dst
+ size_kern
, 0, pad
);
1973 return off
+ match_size
;
1976 /* return size of all matches, watchers or target, including necessary
1977 * alignment and padding.
1979 static int ebt_size_mwt(struct compat_ebt_entry_mwt
*match32
,
1980 unsigned int size_left
, enum compat_mwt type
,
1981 struct ebt_entries_buf_state
*state
, const void *base
)
1989 buf
= (char *) match32
;
1991 while (size_left
>= sizeof(*match32
)) {
1992 struct ebt_entry_match
*match_kern
;
1995 match_kern
= (struct ebt_entry_match
*) state
->buf_kern_start
;
1998 tmp
= state
->buf_kern_start
+ state
->buf_kern_offset
;
1999 match_kern
= (struct ebt_entry_match
*) tmp
;
2001 ret
= ebt_buf_add(state
, buf
, sizeof(*match32
));
2004 size_left
-= sizeof(*match32
);
2006 /* add padding before match->data (if any) */
2007 ret
= ebt_buf_add_pad(state
, ebt_compat_entry_padsize());
2011 if (match32
->match_size
> size_left
)
2014 size_left
-= match32
->match_size
;
2016 ret
= compat_mtw_from_user(match32
, type
, state
, base
);
2020 BUG_ON(ret
< match32
->match_size
);
2021 growth
+= ret
- match32
->match_size
;
2022 growth
+= ebt_compat_entry_padsize();
2024 buf
+= sizeof(*match32
);
2025 buf
+= match32
->match_size
;
2028 match_kern
->match_size
= ret
;
2030 WARN_ON(type
== EBT_COMPAT_TARGET
&& size_left
);
2031 match32
= (struct compat_ebt_entry_mwt
*) buf
;
2037 /* called for all ebt_entry structures. */
2038 static int size_entry_mwt(struct ebt_entry
*entry
, const unsigned char *base
,
2039 unsigned int *total
,
2040 struct ebt_entries_buf_state
*state
)
2042 unsigned int i
, j
, startoff
, new_offset
= 0;
2043 /* stores match/watchers/targets & offset of next struct ebt_entry: */
2044 unsigned int offsets
[4];
2045 unsigned int *offsets_update
= NULL
;
2049 if (*total
< sizeof(struct ebt_entries
))
2052 if (!entry
->bitmask
) {
2053 *total
-= sizeof(struct ebt_entries
);
2054 return ebt_buf_add(state
, entry
, sizeof(struct ebt_entries
));
2056 if (*total
< sizeof(*entry
) || entry
->next_offset
< sizeof(*entry
))
2059 startoff
= state
->buf_user_offset
;
2060 /* pull in most part of ebt_entry, it does not need to be changed. */
2061 ret
= ebt_buf_add(state
, entry
,
2062 offsetof(struct ebt_entry
, watchers_offset
));
2066 offsets
[0] = sizeof(struct ebt_entry
); /* matches come first */
2067 memcpy(&offsets
[1], &entry
->watchers_offset
,
2068 sizeof(offsets
) - sizeof(offsets
[0]));
2070 if (state
->buf_kern_start
) {
2071 buf_start
= state
->buf_kern_start
+ state
->buf_kern_offset
;
2072 offsets_update
= (unsigned int *) buf_start
;
2074 ret
= ebt_buf_add(state
, &offsets
[1],
2075 sizeof(offsets
) - sizeof(offsets
[0]));
2078 buf_start
= (char *) entry
;
2079 /* 0: matches offset, always follows ebt_entry.
2080 * 1: watchers offset, from ebt_entry structure
2081 * 2: target offset, from ebt_entry structure
2082 * 3: next ebt_entry offset, from ebt_entry structure
2084 * offsets are relative to beginning of struct ebt_entry (i.e., 0).
2086 for (i
= 0, j
= 1 ; j
< 4 ; j
++, i
++) {
2087 struct compat_ebt_entry_mwt
*match32
;
2089 char *buf
= buf_start
;
2091 buf
= buf_start
+ offsets
[i
];
2092 if (offsets
[i
] > offsets
[j
])
2095 match32
= (struct compat_ebt_entry_mwt
*) buf
;
2096 size
= offsets
[j
] - offsets
[i
];
2097 ret
= ebt_size_mwt(match32
, size
, i
, state
, base
);
2101 if (offsets_update
&& new_offset
) {
2102 pr_debug("change offset %d to %d\n",
2103 offsets_update
[i
], offsets
[j
] + new_offset
);
2104 offsets_update
[i
] = offsets
[j
] + new_offset
;
2108 if (state
->buf_kern_start
== NULL
) {
2109 unsigned int offset
= buf_start
- (char *) base
;
2111 ret
= xt_compat_add_offset(NFPROTO_BRIDGE
, offset
, new_offset
);
2116 startoff
= state
->buf_user_offset
- startoff
;
2118 BUG_ON(*total
< startoff
);
2123 /* repl->entries_size is the size of the ebt_entry blob in userspace.
2124 * It might need more memory when copied to a 64 bit kernel in case
2125 * userspace is 32-bit. So, first task: find out how much memory is needed.
2127 * Called before validation is performed.
2129 static int compat_copy_entries(unsigned char *data
, unsigned int size_user
,
2130 struct ebt_entries_buf_state
*state
)
2132 unsigned int size_remaining
= size_user
;
2135 ret
= EBT_ENTRY_ITERATE(data
, size_user
, size_entry_mwt
, data
,
2136 &size_remaining
, state
);
2140 WARN_ON(size_remaining
);
2141 return state
->buf_kern_offset
;
2145 static int compat_copy_ebt_replace_from_user(struct ebt_replace
*repl
,
2146 void __user
*user
, unsigned int len
)
2148 struct compat_ebt_replace tmp
;
2151 if (len
< sizeof(tmp
))
2154 if (copy_from_user(&tmp
, user
, sizeof(tmp
)))
2157 if (len
!= sizeof(tmp
) + tmp
.entries_size
)
2160 if (tmp
.entries_size
== 0)
2163 if (tmp
.nentries
>= ((INT_MAX
- sizeof(struct ebt_table_info
)) /
2164 NR_CPUS
- SMP_CACHE_BYTES
) / sizeof(struct ebt_counter
))
2166 if (tmp
.num_counters
>= INT_MAX
/ sizeof(struct ebt_counter
))
2169 memcpy(repl
, &tmp
, offsetof(struct ebt_replace
, hook_entry
));
2171 /* starting with hook_entry, 32 vs. 64 bit structures are different */
2172 for (i
= 0; i
< NF_BR_NUMHOOKS
; i
++)
2173 repl
->hook_entry
[i
] = compat_ptr(tmp
.hook_entry
[i
]);
2175 repl
->num_counters
= tmp
.num_counters
;
2176 repl
->counters
= compat_ptr(tmp
.counters
);
2177 repl
->entries
= compat_ptr(tmp
.entries
);
2181 static int compat_do_replace(struct net
*net
, void __user
*user
,
2184 int ret
, i
, countersize
, size64
;
2185 struct ebt_table_info
*newinfo
;
2186 struct ebt_replace tmp
;
2187 struct ebt_entries_buf_state state
;
2190 ret
= compat_copy_ebt_replace_from_user(&tmp
, user
, len
);
2192 /* try real handler in case userland supplied needed padding */
2193 if (ret
== -EINVAL
&& do_replace(net
, user
, len
) == 0)
2198 countersize
= COUNTER_OFFSET(tmp
.nentries
) * nr_cpu_ids
;
2199 newinfo
= vmalloc(sizeof(*newinfo
) + countersize
);
2204 memset(newinfo
->counters
, 0, countersize
);
2206 memset(&state
, 0, sizeof(state
));
2208 newinfo
->entries
= vmalloc(tmp
.entries_size
);
2209 if (!newinfo
->entries
) {
2214 newinfo
->entries
, tmp
.entries
, tmp
.entries_size
) != 0) {
2219 entries_tmp
= newinfo
->entries
;
2221 xt_compat_lock(NFPROTO_BRIDGE
);
2223 xt_compat_init_offsets(NFPROTO_BRIDGE
, tmp
.nentries
);
2224 ret
= compat_copy_entries(entries_tmp
, tmp
.entries_size
, &state
);
2228 pr_debug("tmp.entries_size %d, kern off %d, user off %d delta %d\n",
2229 tmp
.entries_size
, state
.buf_kern_offset
, state
.buf_user_offset
,
2230 xt_compat_calc_jump(NFPROTO_BRIDGE
, tmp
.entries_size
));
2233 newinfo
->entries
= vmalloc(size64
);
2234 if (!newinfo
->entries
) {
2240 memset(&state
, 0, sizeof(state
));
2241 state
.buf_kern_start
= newinfo
->entries
;
2242 state
.buf_kern_len
= size64
;
2244 ret
= compat_copy_entries(entries_tmp
, tmp
.entries_size
, &state
);
2245 BUG_ON(ret
< 0); /* parses same data again */
2248 tmp
.entries_size
= size64
;
2250 for (i
= 0; i
< NF_BR_NUMHOOKS
; i
++) {
2251 char __user
*usrptr
;
2252 if (tmp
.hook_entry
[i
]) {
2254 usrptr
= (char __user
*) tmp
.hook_entry
[i
];
2255 delta
= usrptr
- tmp
.entries
;
2256 usrptr
+= xt_compat_calc_jump(NFPROTO_BRIDGE
, delta
);
2257 tmp
.hook_entry
[i
] = (struct ebt_entries __user
*)usrptr
;
2261 xt_compat_flush_offsets(NFPROTO_BRIDGE
);
2262 xt_compat_unlock(NFPROTO_BRIDGE
);
2264 ret
= do_replace_finish(net
, &tmp
, newinfo
);
2268 vfree(newinfo
->entries
);
2273 xt_compat_flush_offsets(NFPROTO_BRIDGE
);
2274 xt_compat_unlock(NFPROTO_BRIDGE
);
2278 static int compat_update_counters(struct net
*net
, void __user
*user
,
2281 struct compat_ebt_replace hlp
;
2283 if (copy_from_user(&hlp
, user
, sizeof(hlp
)))
2286 /* try real handler in case userland supplied needed padding */
2287 if (len
!= sizeof(hlp
) + hlp
.num_counters
* sizeof(struct ebt_counter
))
2288 return update_counters(net
, user
, len
);
2290 return do_update_counters(net
, hlp
.name
, compat_ptr(hlp
.counters
),
2291 hlp
.num_counters
, user
, len
);
2294 static int compat_do_ebt_set_ctl(struct sock
*sk
,
2295 int cmd
, void __user
*user
, unsigned int len
)
2298 struct net
*net
= sock_net(sk
);
2300 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
2304 case EBT_SO_SET_ENTRIES
:
2305 ret
= compat_do_replace(net
, user
, len
);
2307 case EBT_SO_SET_COUNTERS
:
2308 ret
= compat_update_counters(net
, user
, len
);
2316 static int compat_do_ebt_get_ctl(struct sock
*sk
, int cmd
,
2317 void __user
*user
, int *len
)
2320 struct compat_ebt_replace tmp
;
2321 struct ebt_table
*t
;
2322 struct net
*net
= sock_net(sk
);
2324 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
2327 /* try real handler in case userland supplied needed padding */
2328 if ((cmd
== EBT_SO_GET_INFO
||
2329 cmd
== EBT_SO_GET_INIT_INFO
) && *len
!= sizeof(tmp
))
2330 return do_ebt_get_ctl(sk
, cmd
, user
, len
);
2332 if (copy_from_user(&tmp
, user
, sizeof(tmp
)))
2335 tmp
.name
[sizeof(tmp
.name
) - 1] = '\0';
2337 t
= find_table_lock(net
, tmp
.name
, &ret
, &ebt_mutex
);
2341 xt_compat_lock(NFPROTO_BRIDGE
);
2343 case EBT_SO_GET_INFO
:
2344 tmp
.nentries
= t
->private->nentries
;
2345 ret
= compat_table_info(t
->private, &tmp
);
2348 tmp
.valid_hooks
= t
->valid_hooks
;
2350 if (copy_to_user(user
, &tmp
, *len
) != 0) {
2356 case EBT_SO_GET_INIT_INFO
:
2357 tmp
.nentries
= t
->table
->nentries
;
2358 tmp
.entries_size
= t
->table
->entries_size
;
2359 tmp
.valid_hooks
= t
->table
->valid_hooks
;
2361 if (copy_to_user(user
, &tmp
, *len
) != 0) {
2367 case EBT_SO_GET_ENTRIES
:
2368 case EBT_SO_GET_INIT_ENTRIES
:
2369 /* try real handler first in case of userland-side padding.
2370 * in case we are dealing with an 'ordinary' 32 bit binary
2371 * without 64bit compatibility padding, this will fail right
2372 * after copy_from_user when the *len argument is validated.
2374 * the compat_ variant needs to do one pass over the kernel
2375 * data set to adjust for size differences before it the check.
2377 if (copy_everything_to_user(t
, user
, len
, cmd
) == 0)
2380 ret
= compat_copy_everything_to_user(t
, user
, len
, cmd
);
2386 xt_compat_flush_offsets(NFPROTO_BRIDGE
);
2387 xt_compat_unlock(NFPROTO_BRIDGE
);
2388 mutex_unlock(&ebt_mutex
);
2393 static struct nf_sockopt_ops ebt_sockopts
= {
2395 .set_optmin
= EBT_BASE_CTL
,
2396 .set_optmax
= EBT_SO_SET_MAX
+ 1,
2397 .set
= do_ebt_set_ctl
,
2398 #ifdef CONFIG_COMPAT
2399 .compat_set
= compat_do_ebt_set_ctl
,
2401 .get_optmin
= EBT_BASE_CTL
,
2402 .get_optmax
= EBT_SO_GET_MAX
+ 1,
2403 .get
= do_ebt_get_ctl
,
2404 #ifdef CONFIG_COMPAT
2405 .compat_get
= compat_do_ebt_get_ctl
,
2407 .owner
= THIS_MODULE
,
2410 static int __init
ebtables_init(void)
2414 ret
= xt_register_target(&ebt_standard_target
);
2417 ret
= nf_register_sockopt(&ebt_sockopts
);
2419 xt_unregister_target(&ebt_standard_target
);
2423 printk(KERN_INFO
"Ebtables v2.0 registered\n");
2427 static void __exit
ebtables_fini(void)
2429 nf_unregister_sockopt(&ebt_sockopts
);
2430 xt_unregister_target(&ebt_standard_target
);
2431 printk(KERN_INFO
"Ebtables v2.0 unregistered\n");
2434 EXPORT_SYMBOL(ebt_register_table
);
2435 EXPORT_SYMBOL(ebt_unregister_table
);
2436 EXPORT_SYMBOL(ebt_do_table
);
2437 module_init(ebtables_init
);
2438 module_exit(ebtables_fini
);
2439 MODULE_LICENSE("GPL");