c2ee5d8550cf13bc84ac69fde5733b3ddf631577
[sfrench/cifs-2.6.git] / include / linux / netfilter / x_tables.h
1 #ifndef _X_TABLES_H
2 #define _X_TABLES_H
3 #include <linux/kernel.h>
4 #include <linux/types.h>
5
6 #define XT_FUNCTION_MAXNAMELEN 30
7 #define XT_EXTENSION_MAXNAMELEN 29
8 #define XT_TABLE_MAXNAMELEN 32
9
10 struct xt_entry_match {
11         union {
12                 struct {
13                         __u16 match_size;
14
15                         /* Used by userspace */
16                         char name[XT_EXTENSION_MAXNAMELEN];
17                         __u8 revision;
18                 } user;
19                 struct {
20                         __u16 match_size;
21
22                         /* Used inside the kernel */
23                         struct xt_match *match;
24                 } kernel;
25
26                 /* Total length */
27                 __u16 match_size;
28         } u;
29
30         unsigned char data[0];
31 };
32
33 struct xt_entry_target {
34         union {
35                 struct {
36                         __u16 target_size;
37
38                         /* Used by userspace */
39                         char name[XT_EXTENSION_MAXNAMELEN];
40                         __u8 revision;
41                 } user;
42                 struct {
43                         __u16 target_size;
44
45                         /* Used inside the kernel */
46                         struct xt_target *target;
47                 } kernel;
48
49                 /* Total length */
50                 __u16 target_size;
51         } u;
52
53         unsigned char data[0];
54 };
55
56 #define XT_TARGET_INIT(__name, __size)                                         \
57 {                                                                              \
58         .target.u.user = {                                                     \
59                 .target_size    = XT_ALIGN(__size),                            \
60                 .name           = __name,                                      \
61         },                                                                     \
62 }
63
64 struct xt_standard_target {
65         struct xt_entry_target target;
66         int verdict;
67 };
68
69 /* The argument to IPT_SO_GET_REVISION_*.  Returns highest revision
70  * kernel supports, if >= revision. */
71 struct xt_get_revision {
72         char name[XT_EXTENSION_MAXNAMELEN];
73         __u8 revision;
74 };
75
76 /* CONTINUE verdict for targets */
77 #define XT_CONTINUE 0xFFFFFFFF
78
79 /* For standard target */
80 #define XT_RETURN (-NF_REPEAT - 1)
81
82 /* this is a dummy structure to find out the alignment requirement for a struct
83  * containing all the fundamental data types that are used in ipt_entry,
84  * ip6t_entry and arpt_entry.  This sucks, and it is a hack.  It will be my
85  * personal pleasure to remove it -HW
86  */
87 struct _xt_align {
88         __u8 u8;
89         __u16 u16;
90         __u32 u32;
91         __u64 u64;
92 };
93
94 #define XT_ALIGN(s) __ALIGN_KERNEL((s), __alignof__(struct _xt_align))
95
96 /* Standard return verdict, or do jump. */
97 #define XT_STANDARD_TARGET ""
98 /* Error verdict. */
99 #define XT_ERROR_TARGET "ERROR"
100
101 #define SET_COUNTER(c,b,p) do { (c).bcnt = (b); (c).pcnt = (p); } while(0)
102 #define ADD_COUNTER(c,b,p) do { (c).bcnt += (b); (c).pcnt += (p); } while(0)
103
104 struct xt_counters {
105         __u64 pcnt, bcnt;                       /* Packet and byte counters */
106 };
107
108 /* The argument to IPT_SO_ADD_COUNTERS. */
109 struct xt_counters_info {
110         /* Which table. */
111         char name[XT_TABLE_MAXNAMELEN];
112
113         unsigned int num_counters;
114
115         /* The counters (actually `number' of these). */
116         struct xt_counters counters[0];
117 };
118
119 #define XT_INV_PROTO            0x40    /* Invert the sense of PROTO. */
120
121 #ifndef __KERNEL__
122 /* fn returns 0 to continue iteration */
123 #define XT_MATCH_ITERATE(type, e, fn, args...)                  \
124 ({                                                              \
125         unsigned int __i;                                       \
126         int __ret = 0;                                          \
127         struct xt_entry_match *__m;                             \
128                                                                 \
129         for (__i = sizeof(type);                                \
130              __i < (e)->target_offset;                          \
131              __i += __m->u.match_size) {                        \
132                 __m = (void *)e + __i;                          \
133                                                                 \
134                 __ret = fn(__m , ## args);                      \
135                 if (__ret != 0)                                 \
136                         break;                                  \
137         }                                                       \
138         __ret;                                                  \
139 })
140
141 /* fn returns 0 to continue iteration */
142 #define XT_ENTRY_ITERATE_CONTINUE(type, entries, size, n, fn, args...) \
143 ({                                                              \
144         unsigned int __i, __n;                                  \
145         int __ret = 0;                                          \
146         type *__entry;                                          \
147                                                                 \
148         for (__i = 0, __n = 0; __i < (size);                    \
149              __i += __entry->next_offset, __n++) {              \
150                 __entry = (void *)(entries) + __i;              \
151                 if (__n < n)                                    \
152                         continue;                               \
153                                                                 \
154                 __ret = fn(__entry , ## args);                  \
155                 if (__ret != 0)                                 \
156                         break;                                  \
157         }                                                       \
158         __ret;                                                  \
159 })
160
161 /* fn returns 0 to continue iteration */
162 #define XT_ENTRY_ITERATE(type, entries, size, fn, args...) \
163         XT_ENTRY_ITERATE_CONTINUE(type, entries, size, 0, fn, args)
164
165 #endif /* !__KERNEL__ */
166
167 /* pos is normally a struct ipt_entry/ip6t_entry/etc. */
168 #define xt_entry_foreach(pos, ehead, esize) \
169         for ((pos) = (typeof(pos))(ehead); \
170              (pos) < (typeof(pos))((char *)(ehead) + (esize)); \
171              (pos) = (typeof(pos))((char *)(pos) + (pos)->next_offset))
172
173 /* can only be xt_entry_match, so no use of typeof here */
174 #define xt_ematch_foreach(pos, entry) \
175         for ((pos) = (struct xt_entry_match *)entry->elems; \
176              (pos) < (struct xt_entry_match *)((char *)(entry) + \
177                      (entry)->target_offset); \
178              (pos) = (struct xt_entry_match *)((char *)(pos) + \
179                      (pos)->u.match_size))
180
181 #ifdef __KERNEL__
182
183 #include <linux/netdevice.h>
184
185 /**
186  * struct xt_action_param - parameters for matches/targets
187  *
188  * @match:      the match extension
189  * @target:     the target extension
190  * @matchinfo:  per-match data
191  * @targetinfo: per-target data
192  * @in:         input netdevice
193  * @out:        output netdevice
194  * @fragoff:    packet is a fragment, this is the data offset
195  * @thoff:      position of transport header relative to skb->data
196  * @hook:       hook number given packet came from
197  * @family:     Actual NFPROTO_* through which the function is invoked
198  *              (helpful when match->family == NFPROTO_UNSPEC)
199  *
200  * Fields written to by extensions:
201  *
202  * @hotdrop:    drop packet if we had inspection problems
203  * Network namespace obtainable using dev_net(in/out)
204  */
205 struct xt_action_param {
206         union {
207                 const struct xt_match *match;
208                 const struct xt_target *target;
209         };
210         union {
211                 const void *matchinfo, *targinfo;
212         };
213         const struct net_device *in, *out;
214         int fragoff;
215         unsigned int thoff;
216         unsigned int hooknum;
217         u_int8_t family;
218         bool hotdrop;
219 };
220
221 /**
222  * struct xt_mtchk_param - parameters for match extensions'
223  * checkentry functions
224  *
225  * @net:        network namespace through which the check was invoked
226  * @table:      table the rule is tried to be inserted into
227  * @entryinfo:  the family-specific rule data
228  *              (struct ipt_ip, ip6t_ip, arpt_arp or (note) ebt_entry)
229  * @match:      struct xt_match through which this function was invoked
230  * @matchinfo:  per-match data
231  * @hook_mask:  via which hooks the new rule is reachable
232  * Other fields as above.
233  */
234 struct xt_mtchk_param {
235         struct net *net;
236         const char *table;
237         const void *entryinfo;
238         const struct xt_match *match;
239         void *matchinfo;
240         unsigned int hook_mask;
241         u_int8_t family;
242 };
243
244 /**
245  * struct xt_mdtor_param - match destructor parameters
246  * Fields as above.
247  */
248 struct xt_mtdtor_param {
249         struct net *net;
250         const struct xt_match *match;
251         void *matchinfo;
252         u_int8_t family;
253 };
254
255 /**
256  * struct xt_tgchk_param - parameters for target extensions'
257  * checkentry functions
258  *
259  * @entryinfo:  the family-specific rule data
260  *              (struct ipt_entry, ip6t_entry, arpt_entry, ebt_entry)
261  *
262  * Other fields see above.
263  */
264 struct xt_tgchk_param {
265         struct net *net;
266         const char *table;
267         const void *entryinfo;
268         const struct xt_target *target;
269         void *targinfo;
270         unsigned int hook_mask;
271         u_int8_t family;
272 };
273
274 /* Target destructor parameters */
275 struct xt_tgdtor_param {
276         struct net *net;
277         const struct xt_target *target;
278         void *targinfo;
279         u_int8_t family;
280 };
281
282 struct xt_match {
283         struct list_head list;
284
285         const char name[XT_EXTENSION_MAXNAMELEN];
286         u_int8_t revision;
287
288         /* Return true or false: return FALSE and set *hotdrop = 1 to
289            force immediate packet drop. */
290         /* Arguments changed since 2.6.9, as this must now handle
291            non-linear skb, using skb_header_pointer and
292            skb_ip_make_writable. */
293         bool (*match)(const struct sk_buff *skb,
294                       struct xt_action_param *);
295
296         /* Called when user tries to insert an entry of this type. */
297         int (*checkentry)(const struct xt_mtchk_param *);
298
299         /* Called when entry of this type deleted. */
300         void (*destroy)(const struct xt_mtdtor_param *);
301 #ifdef CONFIG_COMPAT
302         /* Called when userspace align differs from kernel space one */
303         void (*compat_from_user)(void *dst, const void *src);
304         int (*compat_to_user)(void __user *dst, const void *src);
305 #endif
306         /* Set this to THIS_MODULE if you are a module, otherwise NULL */
307         struct module *me;
308
309         const char *table;
310         unsigned int matchsize;
311 #ifdef CONFIG_COMPAT
312         unsigned int compatsize;
313 #endif
314         unsigned int hooks;
315         unsigned short proto;
316
317         unsigned short family;
318 };
319
320 /* Registration hooks for targets. */
321 struct xt_target {
322         struct list_head list;
323
324         const char name[XT_EXTENSION_MAXNAMELEN];
325         u_int8_t revision;
326
327         /* Returns verdict. Argument order changed since 2.6.9, as this
328            must now handle non-linear skbs, using skb_copy_bits and
329            skb_ip_make_writable. */
330         unsigned int (*target)(struct sk_buff *skb,
331                                const struct xt_action_param *);
332
333         /* Called when user tries to insert an entry of this type:
334            hook_mask is a bitmask of hooks from which it can be
335            called. */
336         /* Should return true or false, or an error code (-Exxxx). */
337         int (*checkentry)(const struct xt_tgchk_param *);
338
339         /* Called when entry of this type deleted. */
340         void (*destroy)(const struct xt_tgdtor_param *);
341 #ifdef CONFIG_COMPAT
342         /* Called when userspace align differs from kernel space one */
343         void (*compat_from_user)(void *dst, const void *src);
344         int (*compat_to_user)(void __user *dst, const void *src);
345 #endif
346         /* Set this to THIS_MODULE if you are a module, otherwise NULL */
347         struct module *me;
348
349         const char *table;
350         unsigned int targetsize;
351 #ifdef CONFIG_COMPAT
352         unsigned int compatsize;
353 #endif
354         unsigned int hooks;
355         unsigned short proto;
356
357         unsigned short family;
358 };
359
360 /* Furniture shopping... */
361 struct xt_table {
362         struct list_head list;
363
364         /* What hooks you will enter on */
365         unsigned int valid_hooks;
366
367         /* Man behind the curtain... */
368         struct xt_table_info *private;
369
370         /* Set this to THIS_MODULE if you are a module, otherwise NULL */
371         struct module *me;
372
373         u_int8_t af;            /* address/protocol family */
374         int priority;           /* hook order */
375
376         /* A unique name... */
377         const char name[XT_TABLE_MAXNAMELEN];
378 };
379
380 #include <linux/netfilter_ipv4.h>
381
382 /* The table itself */
383 struct xt_table_info {
384         /* Size per table */
385         unsigned int size;
386         /* Number of entries: FIXME. --RR */
387         unsigned int number;
388         /* Initial number of entries. Needed for module usage count */
389         unsigned int initial_entries;
390
391         /* Entry points and underflows */
392         unsigned int hook_entry[NF_INET_NUMHOOKS];
393         unsigned int underflow[NF_INET_NUMHOOKS];
394
395         /*
396          * Number of user chains. Since tables cannot have loops, at most
397          * @stacksize jumps (number of user chains) can possibly be made.
398          */
399         unsigned int stacksize;
400         unsigned int *stackptr;
401         void ***jumpstack;
402         /* ipt_entry tables: one per CPU */
403         /* Note : this field MUST be the last one, see XT_TABLE_INFO_SZ */
404         void *entries[1];
405 };
406
407 #define XT_TABLE_INFO_SZ (offsetof(struct xt_table_info, entries) \
408                           + nr_cpu_ids * sizeof(char *))
409 extern int xt_register_target(struct xt_target *target);
410 extern void xt_unregister_target(struct xt_target *target);
411 extern int xt_register_targets(struct xt_target *target, unsigned int n);
412 extern void xt_unregister_targets(struct xt_target *target, unsigned int n);
413
414 extern int xt_register_match(struct xt_match *target);
415 extern void xt_unregister_match(struct xt_match *target);
416 extern int xt_register_matches(struct xt_match *match, unsigned int n);
417 extern void xt_unregister_matches(struct xt_match *match, unsigned int n);
418
419 extern int xt_check_match(struct xt_mtchk_param *,
420                           unsigned int size, u_int8_t proto, bool inv_proto);
421 extern int xt_check_target(struct xt_tgchk_param *,
422                            unsigned int size, u_int8_t proto, bool inv_proto);
423
424 extern struct xt_table *xt_register_table(struct net *net,
425                                           const struct xt_table *table,
426                                           struct xt_table_info *bootstrap,
427                                           struct xt_table_info *newinfo);
428 extern void *xt_unregister_table(struct xt_table *table);
429
430 extern struct xt_table_info *xt_replace_table(struct xt_table *table,
431                                               unsigned int num_counters,
432                                               struct xt_table_info *newinfo,
433                                               int *error);
434
435 extern struct xt_match *xt_find_match(u8 af, const char *name, u8 revision);
436 extern struct xt_target *xt_find_target(u8 af, const char *name, u8 revision);
437 extern struct xt_match *xt_request_find_match(u8 af, const char *name,
438                                               u8 revision);
439 extern struct xt_target *xt_request_find_target(u8 af, const char *name,
440                                                 u8 revision);
441 extern int xt_find_revision(u8 af, const char *name, u8 revision,
442                             int target, int *err);
443
444 extern struct xt_table *xt_find_table_lock(struct net *net, u_int8_t af,
445                                            const char *name);
446 extern void xt_table_unlock(struct xt_table *t);
447
448 extern int xt_proto_init(struct net *net, u_int8_t af);
449 extern void xt_proto_fini(struct net *net, u_int8_t af);
450
451 extern struct xt_table_info *xt_alloc_table_info(unsigned int size);
452 extern void xt_free_table_info(struct xt_table_info *info);
453
454 /*
455  * Per-CPU spinlock associated with per-cpu table entries, and
456  * with a counter for the "reading" side that allows a recursive
457  * reader to avoid taking the lock and deadlocking.
458  *
459  * "reading" is used by ip/arp/ip6 tables rule processing which runs per-cpu.
460  * It needs to ensure that the rules are not being changed while the packet
461  * is being processed. In some cases, the read lock will be acquired
462  * twice on the same CPU; this is okay because of the count.
463  *
464  * "writing" is used when reading counters.
465  *  During replace any readers that are using the old tables have to complete
466  *  before freeing the old table. This is handled by the write locking
467  *  necessary for reading the counters.
468  */
469 struct xt_info_lock {
470         spinlock_t lock;
471         unsigned char readers;
472 };
473 DECLARE_PER_CPU(struct xt_info_lock, xt_info_locks);
474
475 /*
476  * Note: we need to ensure that preemption is disabled before acquiring
477  * the per-cpu-variable, so we do it as a two step process rather than
478  * using "spin_lock_bh()".
479  *
480  * We _also_ need to disable bottom half processing before updating our
481  * nesting count, to make sure that the only kind of re-entrancy is this
482  * code being called by itself: since the count+lock is not an atomic
483  * operation, we can allow no races.
484  *
485  * _Only_ that special combination of being per-cpu and never getting
486  * re-entered asynchronously means that the count is safe.
487  */
488 static inline void xt_info_rdlock_bh(void)
489 {
490         struct xt_info_lock *lock;
491
492         local_bh_disable();
493         lock = &__get_cpu_var(xt_info_locks);
494         if (likely(!lock->readers++))
495                 spin_lock(&lock->lock);
496 }
497
498 static inline void xt_info_rdunlock_bh(void)
499 {
500         struct xt_info_lock *lock = &__get_cpu_var(xt_info_locks);
501
502         if (likely(!--lock->readers))
503                 spin_unlock(&lock->lock);
504         local_bh_enable();
505 }
506
507 /*
508  * The "writer" side needs to get exclusive access to the lock,
509  * regardless of readers.  This must be called with bottom half
510  * processing (and thus also preemption) disabled.
511  */
512 static inline void xt_info_wrlock(unsigned int cpu)
513 {
514         spin_lock(&per_cpu(xt_info_locks, cpu).lock);
515 }
516
517 static inline void xt_info_wrunlock(unsigned int cpu)
518 {
519         spin_unlock(&per_cpu(xt_info_locks, cpu).lock);
520 }
521
522 /*
523  * This helper is performance critical and must be inlined
524  */
525 static inline unsigned long ifname_compare_aligned(const char *_a,
526                                                    const char *_b,
527                                                    const char *_mask)
528 {
529         const unsigned long *a = (const unsigned long *)_a;
530         const unsigned long *b = (const unsigned long *)_b;
531         const unsigned long *mask = (const unsigned long *)_mask;
532         unsigned long ret;
533
534         ret = (a[0] ^ b[0]) & mask[0];
535         if (IFNAMSIZ > sizeof(unsigned long))
536                 ret |= (a[1] ^ b[1]) & mask[1];
537         if (IFNAMSIZ > 2 * sizeof(unsigned long))
538                 ret |= (a[2] ^ b[2]) & mask[2];
539         if (IFNAMSIZ > 3 * sizeof(unsigned long))
540                 ret |= (a[3] ^ b[3]) & mask[3];
541         BUILD_BUG_ON(IFNAMSIZ > 4 * sizeof(unsigned long));
542         return ret;
543 }
544
545 extern struct nf_hook_ops *xt_hook_link(const struct xt_table *, nf_hookfn *);
546 extern void xt_hook_unlink(const struct xt_table *, struct nf_hook_ops *);
547
548 #ifdef CONFIG_COMPAT
549 #include <net/compat.h>
550
551 struct compat_xt_entry_match {
552         union {
553                 struct {
554                         u_int16_t match_size;
555                         char name[XT_FUNCTION_MAXNAMELEN - 1];
556                         u_int8_t revision;
557                 } user;
558                 struct {
559                         u_int16_t match_size;
560                         compat_uptr_t match;
561                 } kernel;
562                 u_int16_t match_size;
563         } u;
564         unsigned char data[0];
565 };
566
567 struct compat_xt_entry_target {
568         union {
569                 struct {
570                         u_int16_t target_size;
571                         char name[XT_FUNCTION_MAXNAMELEN - 1];
572                         u_int8_t revision;
573                 } user;
574                 struct {
575                         u_int16_t target_size;
576                         compat_uptr_t target;
577                 } kernel;
578                 u_int16_t target_size;
579         } u;
580         unsigned char data[0];
581 };
582
583 /* FIXME: this works only on 32 bit tasks
584  * need to change whole approach in order to calculate align as function of
585  * current task alignment */
586
587 struct compat_xt_counters {
588         compat_u64 pcnt, bcnt;                  /* Packet and byte counters */
589 };
590
591 struct compat_xt_counters_info {
592         char name[XT_TABLE_MAXNAMELEN];
593         compat_uint_t num_counters;
594         struct compat_xt_counters counters[0];
595 };
596
597 struct _compat_xt_align {
598         __u8 u8;
599         __u16 u16;
600         __u32 u32;
601         compat_u64 u64;
602 };
603
604 #define COMPAT_XT_ALIGN(s) __ALIGN_KERNEL((s), __alignof__(struct _compat_xt_align))
605
606 extern void xt_compat_lock(u_int8_t af);
607 extern void xt_compat_unlock(u_int8_t af);
608
609 extern int xt_compat_add_offset(u_int8_t af, unsigned int offset, short delta);
610 extern void xt_compat_flush_offsets(u_int8_t af);
611 extern int xt_compat_calc_jump(u_int8_t af, unsigned int offset);
612
613 extern int xt_compat_match_offset(const struct xt_match *match);
614 extern int xt_compat_match_from_user(struct xt_entry_match *m,
615                                      void **dstptr, unsigned int *size);
616 extern int xt_compat_match_to_user(const struct xt_entry_match *m,
617                                    void __user **dstptr, unsigned int *size);
618
619 extern int xt_compat_target_offset(const struct xt_target *target);
620 extern void xt_compat_target_from_user(struct xt_entry_target *t,
621                                        void **dstptr, unsigned int *size);
622 extern int xt_compat_target_to_user(const struct xt_entry_target *t,
623                                     void __user **dstptr, unsigned int *size);
624
625 #endif /* CONFIG_COMPAT */
626 #endif /* __KERNEL__ */
627
628 #endif /* _X_TABLES_H */