LCOV - code coverage report
Current view: top level - include/linux/netfilter - x_tables.h (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 0 15 0.0 %
Date: 2020-09-30 20:25:40 Functions: 0 1 0.0 %
Branches: 0 8 0.0 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : #ifndef _X_TABLES_H
       3                 :            : #define _X_TABLES_H
       4                 :            : 
       5                 :            : 
       6                 :            : #include <linux/netdevice.h>
       7                 :            : #include <linux/static_key.h>
       8                 :            : #include <linux/netfilter.h>
       9                 :            : #include <uapi/linux/netfilter/x_tables.h>
      10                 :            : 
      11                 :            : /* Test a struct->invflags and a boolean for inequality */
      12                 :            : #define NF_INVF(ptr, flag, boolean)                                     \
      13                 :            :         ((boolean) ^ !!((ptr)->invflags & (flag)))
      14                 :            : 
      15                 :            : /**
      16                 :            :  * struct xt_action_param - parameters for matches/targets
      17                 :            :  *
      18                 :            :  * @match:      the match extension
      19                 :            :  * @target:     the target extension
      20                 :            :  * @matchinfo:  per-match data
      21                 :            :  * @targetinfo: per-target data
      22                 :            :  * @state:      pointer to hook state this packet came from
      23                 :            :  * @fragoff:    packet is a fragment, this is the data offset
      24                 :            :  * @thoff:      position of transport header relative to skb->data
      25                 :            :  *
      26                 :            :  * Fields written to by extensions:
      27                 :            :  *
      28                 :            :  * @hotdrop:    drop packet if we had inspection problems
      29                 :            :  */
      30                 :            : struct xt_action_param {
      31                 :            :         union {
      32                 :            :                 const struct xt_match *match;
      33                 :            :                 const struct xt_target *target;
      34                 :            :         };
      35                 :            :         union {
      36                 :            :                 const void *matchinfo, *targinfo;
      37                 :            :         };
      38                 :            :         const struct nf_hook_state *state;
      39                 :            :         int fragoff;
      40                 :            :         unsigned int thoff;
      41                 :            :         bool hotdrop;
      42                 :            : };
      43                 :            : 
      44                 :            : static inline struct net *xt_net(const struct xt_action_param *par)
      45                 :            : {
      46                 :            :         return par->state->net;
      47                 :            : }
      48                 :            : 
      49                 :            : static inline struct net_device *xt_in(const struct xt_action_param *par)
      50                 :            : {
      51                 :            :         return par->state->in;
      52                 :            : }
      53                 :            : 
      54                 :            : static inline const char *xt_inname(const struct xt_action_param *par)
      55                 :            : {
      56                 :            :         return par->state->in->name;
      57                 :            : }
      58                 :            : 
      59                 :            : static inline struct net_device *xt_out(const struct xt_action_param *par)
      60                 :            : {
      61                 :            :         return par->state->out;
      62                 :            : }
      63                 :            : 
      64                 :            : static inline const char *xt_outname(const struct xt_action_param *par)
      65                 :            : {
      66                 :            :         return par->state->out->name;
      67                 :            : }
      68                 :            : 
      69                 :            : static inline unsigned int xt_hooknum(const struct xt_action_param *par)
      70                 :            : {
      71                 :            :         return par->state->hook;
      72                 :            : }
      73                 :            : 
      74                 :            : static inline u_int8_t xt_family(const struct xt_action_param *par)
      75                 :            : {
      76                 :            :         return par->state->pf;
      77                 :            : }
      78                 :            : 
      79                 :            : /**
      80                 :            :  * struct xt_mtchk_param - parameters for match extensions'
      81                 :            :  * checkentry functions
      82                 :            :  *
      83                 :            :  * @net:        network namespace through which the check was invoked
      84                 :            :  * @table:      table the rule is tried to be inserted into
      85                 :            :  * @entryinfo:  the family-specific rule data
      86                 :            :  *              (struct ipt_ip, ip6t_ip, arpt_arp or (note) ebt_entry)
      87                 :            :  * @match:      struct xt_match through which this function was invoked
      88                 :            :  * @matchinfo:  per-match data
      89                 :            :  * @hook_mask:  via which hooks the new rule is reachable
      90                 :            :  * Other fields as above.
      91                 :            :  */
      92                 :            : struct xt_mtchk_param {
      93                 :            :         struct net *net;
      94                 :            :         const char *table;
      95                 :            :         const void *entryinfo;
      96                 :            :         const struct xt_match *match;
      97                 :            :         void *matchinfo;
      98                 :            :         unsigned int hook_mask;
      99                 :            :         u_int8_t family;
     100                 :            :         bool nft_compat;
     101                 :            : };
     102                 :            : 
     103                 :            : /**
     104                 :            :  * struct xt_mdtor_param - match destructor parameters
     105                 :            :  * Fields as above.
     106                 :            :  */
     107                 :            : struct xt_mtdtor_param {
     108                 :            :         struct net *net;
     109                 :            :         const struct xt_match *match;
     110                 :            :         void *matchinfo;
     111                 :            :         u_int8_t family;
     112                 :            : };
     113                 :            : 
     114                 :            : /**
     115                 :            :  * struct xt_tgchk_param - parameters for target extensions'
     116                 :            :  * checkentry functions
     117                 :            :  *
     118                 :            :  * @entryinfo:  the family-specific rule data
     119                 :            :  *              (struct ipt_entry, ip6t_entry, arpt_entry, ebt_entry)
     120                 :            :  *
     121                 :            :  * Other fields see above.
     122                 :            :  */
     123                 :            : struct xt_tgchk_param {
     124                 :            :         struct net *net;
     125                 :            :         const char *table;
     126                 :            :         const void *entryinfo;
     127                 :            :         const struct xt_target *target;
     128                 :            :         void *targinfo;
     129                 :            :         unsigned int hook_mask;
     130                 :            :         u_int8_t family;
     131                 :            :         bool nft_compat;
     132                 :            : };
     133                 :            : 
     134                 :            : /* Target destructor parameters */
     135                 :            : struct xt_tgdtor_param {
     136                 :            :         struct net *net;
     137                 :            :         const struct xt_target *target;
     138                 :            :         void *targinfo;
     139                 :            :         u_int8_t family;
     140                 :            : };
     141                 :            : 
     142                 :            : struct xt_match {
     143                 :            :         struct list_head list;
     144                 :            : 
     145                 :            :         const char name[XT_EXTENSION_MAXNAMELEN];
     146                 :            :         u_int8_t revision;
     147                 :            : 
     148                 :            :         /* Return true or false: return FALSE and set *hotdrop = 1 to
     149                 :            :            force immediate packet drop. */
     150                 :            :         /* Arguments changed since 2.6.9, as this must now handle
     151                 :            :            non-linear skb, using skb_header_pointer and
     152                 :            :            skb_ip_make_writable. */
     153                 :            :         bool (*match)(const struct sk_buff *skb,
     154                 :            :                       struct xt_action_param *);
     155                 :            : 
     156                 :            :         /* Called when user tries to insert an entry of this type. */
     157                 :            :         int (*checkentry)(const struct xt_mtchk_param *);
     158                 :            : 
     159                 :            :         /* Called when entry of this type deleted. */
     160                 :            :         void (*destroy)(const struct xt_mtdtor_param *);
     161                 :            : #ifdef CONFIG_COMPAT
     162                 :            :         /* Called when userspace align differs from kernel space one */
     163                 :            :         void (*compat_from_user)(void *dst, const void *src);
     164                 :            :         int (*compat_to_user)(void __user *dst, const void *src);
     165                 :            : #endif
     166                 :            :         /* Set this to THIS_MODULE if you are a module, otherwise NULL */
     167                 :            :         struct module *me;
     168                 :            : 
     169                 :            :         const char *table;
     170                 :            :         unsigned int matchsize;
     171                 :            :         unsigned int usersize;
     172                 :            : #ifdef CONFIG_COMPAT
     173                 :            :         unsigned int compatsize;
     174                 :            : #endif
     175                 :            :         unsigned int hooks;
     176                 :            :         unsigned short proto;
     177                 :            : 
     178                 :            :         unsigned short family;
     179                 :            : };
     180                 :            : 
     181                 :            : /* Registration hooks for targets. */
     182                 :            : struct xt_target {
     183                 :            :         struct list_head list;
     184                 :            : 
     185                 :            :         const char name[XT_EXTENSION_MAXNAMELEN];
     186                 :            :         u_int8_t revision;
     187                 :            : 
     188                 :            :         /* Returns verdict. Argument order changed since 2.6.9, as this
     189                 :            :            must now handle non-linear skbs, using skb_copy_bits and
     190                 :            :            skb_ip_make_writable. */
     191                 :            :         unsigned int (*target)(struct sk_buff *skb,
     192                 :            :                                const struct xt_action_param *);
     193                 :            : 
     194                 :            :         /* Called when user tries to insert an entry of this type:
     195                 :            :            hook_mask is a bitmask of hooks from which it can be
     196                 :            :            called. */
     197                 :            :         /* Should return 0 on success or an error code otherwise (-Exxxx). */
     198                 :            :         int (*checkentry)(const struct xt_tgchk_param *);
     199                 :            : 
     200                 :            :         /* Called when entry of this type deleted. */
     201                 :            :         void (*destroy)(const struct xt_tgdtor_param *);
     202                 :            : #ifdef CONFIG_COMPAT
     203                 :            :         /* Called when userspace align differs from kernel space one */
     204                 :            :         void (*compat_from_user)(void *dst, const void *src);
     205                 :            :         int (*compat_to_user)(void __user *dst, const void *src);
     206                 :            : #endif
     207                 :            :         /* Set this to THIS_MODULE if you are a module, otherwise NULL */
     208                 :            :         struct module *me;
     209                 :            : 
     210                 :            :         const char *table;
     211                 :            :         unsigned int targetsize;
     212                 :            :         unsigned int usersize;
     213                 :            : #ifdef CONFIG_COMPAT
     214                 :            :         unsigned int compatsize;
     215                 :            : #endif
     216                 :            :         unsigned int hooks;
     217                 :            :         unsigned short proto;
     218                 :            : 
     219                 :            :         unsigned short family;
     220                 :            : };
     221                 :            : 
     222                 :            : /* Furniture shopping... */
     223                 :            : struct xt_table {
     224                 :            :         struct list_head list;
     225                 :            : 
     226                 :            :         /* What hooks you will enter on */
     227                 :            :         unsigned int valid_hooks;
     228                 :            : 
     229                 :            :         /* Man behind the curtain... */
     230                 :            :         struct xt_table_info *private;
     231                 :            : 
     232                 :            :         /* Set this to THIS_MODULE if you are a module, otherwise NULL */
     233                 :            :         struct module *me;
     234                 :            : 
     235                 :            :         u_int8_t af;            /* address/protocol family */
     236                 :            :         int priority;           /* hook order */
     237                 :            : 
     238                 :            :         /* called when table is needed in the given netns */
     239                 :            :         int (*table_init)(struct net *net);
     240                 :            : 
     241                 :            :         /* A unique name... */
     242                 :            :         const char name[XT_TABLE_MAXNAMELEN];
     243                 :            : };
     244                 :            : 
     245                 :            : #include <linux/netfilter_ipv4.h>
     246                 :            : 
     247                 :            : /* The table itself */
     248                 :            : struct xt_table_info {
     249                 :            :         /* Size per table */
     250                 :            :         unsigned int size;
     251                 :            :         /* Number of entries: FIXME. --RR */
     252                 :            :         unsigned int number;
     253                 :            :         /* Initial number of entries. Needed for module usage count */
     254                 :            :         unsigned int initial_entries;
     255                 :            : 
     256                 :            :         /* Entry points and underflows */
     257                 :            :         unsigned int hook_entry[NF_INET_NUMHOOKS];
     258                 :            :         unsigned int underflow[NF_INET_NUMHOOKS];
     259                 :            : 
     260                 :            :         /*
     261                 :            :          * Number of user chains. Since tables cannot have loops, at most
     262                 :            :          * @stacksize jumps (number of user chains) can possibly be made.
     263                 :            :          */
     264                 :            :         unsigned int stacksize;
     265                 :            :         void ***jumpstack;
     266                 :            : 
     267                 :            :         unsigned char entries[0] __aligned(8);
     268                 :            : };
     269                 :            : 
     270                 :            : int xt_register_target(struct xt_target *target);
     271                 :            : void xt_unregister_target(struct xt_target *target);
     272                 :            : int xt_register_targets(struct xt_target *target, unsigned int n);
     273                 :            : void xt_unregister_targets(struct xt_target *target, unsigned int n);
     274                 :            : 
     275                 :            : int xt_register_match(struct xt_match *target);
     276                 :            : void xt_unregister_match(struct xt_match *target);
     277                 :            : int xt_register_matches(struct xt_match *match, unsigned int n);
     278                 :            : void xt_unregister_matches(struct xt_match *match, unsigned int n);
     279                 :            : 
     280                 :            : int xt_check_entry_offsets(const void *base, const char *elems,
     281                 :            :                            unsigned int target_offset,
     282                 :            :                            unsigned int next_offset);
     283                 :            : 
     284                 :            : int xt_check_table_hooks(const struct xt_table_info *info, unsigned int valid_hooks);
     285                 :            : 
     286                 :            : unsigned int *xt_alloc_entry_offsets(unsigned int size);
     287                 :            : bool xt_find_jump_offset(const unsigned int *offsets,
     288                 :            :                          unsigned int target, unsigned int size);
     289                 :            : 
     290                 :            : int xt_check_proc_name(const char *name, unsigned int size);
     291                 :            : 
     292                 :            : int xt_check_match(struct xt_mtchk_param *, unsigned int size, u16 proto,
     293                 :            :                    bool inv_proto);
     294                 :            : int xt_check_target(struct xt_tgchk_param *, unsigned int size, u16 proto,
     295                 :            :                     bool inv_proto);
     296                 :            : 
     297                 :            : int xt_match_to_user(const struct xt_entry_match *m,
     298                 :            :                      struct xt_entry_match __user *u);
     299                 :            : int xt_target_to_user(const struct xt_entry_target *t,
     300                 :            :                       struct xt_entry_target __user *u);
     301                 :            : int xt_data_to_user(void __user *dst, const void *src,
     302                 :            :                     int usersize, int size, int aligned_size);
     303                 :            : 
     304                 :            : void *xt_copy_counters_from_user(const void __user *user, unsigned int len,
     305                 :            :                                  struct xt_counters_info *info, bool compat);
     306                 :            : struct xt_counters *xt_counters_alloc(unsigned int counters);
     307                 :            : 
     308                 :            : struct xt_table *xt_register_table(struct net *net,
     309                 :            :                                    const struct xt_table *table,
     310                 :            :                                    struct xt_table_info *bootstrap,
     311                 :            :                                    struct xt_table_info *newinfo);
     312                 :            : void *xt_unregister_table(struct xt_table *table);
     313                 :            : 
     314                 :            : struct xt_table_info *xt_replace_table(struct xt_table *table,
     315                 :            :                                        unsigned int num_counters,
     316                 :            :                                        struct xt_table_info *newinfo,
     317                 :            :                                        int *error);
     318                 :            : 
     319                 :            : struct xt_match *xt_find_match(u8 af, const char *name, u8 revision);
     320                 :            : struct xt_match *xt_request_find_match(u8 af, const char *name, u8 revision);
     321                 :            : struct xt_target *xt_request_find_target(u8 af, const char *name, u8 revision);
     322                 :            : int xt_find_revision(u8 af, const char *name, u8 revision, int target,
     323                 :            :                      int *err);
     324                 :            : 
     325                 :            : struct xt_table *xt_find_table_lock(struct net *net, u_int8_t af,
     326                 :            :                                     const char *name);
     327                 :            : struct xt_table *xt_request_find_table_lock(struct net *net, u_int8_t af,
     328                 :            :                                             const char *name);
     329                 :            : void xt_table_unlock(struct xt_table *t);
     330                 :            : 
     331                 :            : int xt_proto_init(struct net *net, u_int8_t af);
     332                 :            : void xt_proto_fini(struct net *net, u_int8_t af);
     333                 :            : 
     334                 :            : struct xt_table_info *xt_alloc_table_info(unsigned int size);
     335                 :            : void xt_free_table_info(struct xt_table_info *info);
     336                 :            : 
     337                 :            : /**
     338                 :            :  * xt_recseq - recursive seqcount for netfilter use
     339                 :            :  *
     340                 :            :  * Packet processing changes the seqcount only if no recursion happened
     341                 :            :  * get_counters() can use read_seqcount_begin()/read_seqcount_retry(),
     342                 :            :  * because we use the normal seqcount convention :
     343                 :            :  * Low order bit set to 1 if a writer is active.
     344                 :            :  */
     345                 :            : DECLARE_PER_CPU(seqcount_t, xt_recseq);
     346                 :            : 
     347                 :            : /* xt_tee_enabled - true if x_tables needs to handle reentrancy
     348                 :            :  *
     349                 :            :  * Enabled if current ip(6)tables ruleset has at least one -j TEE rule.
     350                 :            :  */
     351                 :            : extern struct static_key xt_tee_enabled;
     352                 :            : 
     353                 :            : /**
     354                 :            :  * xt_write_recseq_begin - start of a write section
     355                 :            :  *
     356                 :            :  * Begin packet processing : all readers must wait the end
     357                 :            :  * 1) Must be called with preemption disabled
     358                 :            :  * 2) softirqs must be disabled too (or we should use this_cpu_add())
     359                 :            :  * Returns :
     360                 :            :  *  1 if no recursion on this cpu
     361                 :            :  *  0 if recursion detected
     362                 :            :  */
     363                 :            : static inline unsigned int xt_write_recseq_begin(void)
     364                 :            : {
     365                 :            :         unsigned int addend;
     366                 :            : 
     367                 :            :         /*
     368                 :            :          * Low order bit of sequence is set if we already
     369                 :            :          * called xt_write_recseq_begin().
     370                 :            :          */
     371                 :          0 :         addend = (__this_cpu_read(xt_recseq.sequence) + 1) & 1;
     372                 :            : 
     373                 :            :         /*
     374                 :            :          * This is kind of a write_seqcount_begin(), but addend is 0 or 1
     375                 :            :          * We dont check addend value to avoid a test and conditional jump,
     376                 :            :          * since addend is most likely 1
     377                 :            :          */
     378                 :          0 :         __this_cpu_add(xt_recseq.sequence, addend);
     379                 :          0 :         smp_wmb();
     380                 :            : 
     381                 :            :         return addend;
     382                 :            : }
     383                 :            : 
     384                 :            : /**
     385                 :            :  * xt_write_recseq_end - end of a write section
     386                 :            :  * @addend: return value from previous xt_write_recseq_begin()
     387                 :            :  *
     388                 :            :  * End packet processing : all readers can proceed
     389                 :            :  * 1) Must be called with preemption disabled
     390                 :            :  * 2) softirqs must be disabled too (or we should use this_cpu_add())
     391                 :            :  */
     392                 :            : static inline void xt_write_recseq_end(unsigned int addend)
     393                 :            : {
     394                 :            :         /* this is kind of a write_seqcount_end(), but addend is 0 or 1 */
     395                 :          0 :         smp_wmb();
     396                 :          0 :         __this_cpu_add(xt_recseq.sequence, addend);
     397                 :            : }
     398                 :            : 
     399                 :            : /*
     400                 :            :  * This helper is performance critical and must be inlined
     401                 :            :  */
     402                 :          0 : static inline unsigned long ifname_compare_aligned(const char *_a,
     403                 :            :                                                    const char *_b,
     404                 :            :                                                    const char *_mask)
     405                 :            : {
     406                 :            :         const unsigned long *a = (const unsigned long *)_a;
     407                 :            :         const unsigned long *b = (const unsigned long *)_b;
     408                 :            :         const unsigned long *mask = (const unsigned long *)_mask;
     409                 :            :         unsigned long ret;
     410                 :            : 
     411                 :          0 :         ret = (a[0] ^ b[0]) & mask[0];
     412                 :            :         if (IFNAMSIZ > sizeof(unsigned long))
     413                 :          0 :                 ret |= (a[1] ^ b[1]) & mask[1];
     414                 :            :         if (IFNAMSIZ > 2 * sizeof(unsigned long))
     415                 :          0 :                 ret |= (a[2] ^ b[2]) & mask[2];
     416                 :            :         if (IFNAMSIZ > 3 * sizeof(unsigned long))
     417                 :          0 :                 ret |= (a[3] ^ b[3]) & mask[3];
     418                 :            :         BUILD_BUG_ON(IFNAMSIZ > 4 * sizeof(unsigned long));
     419                 :          0 :         return ret;
     420                 :            : }
     421                 :            : 
     422                 :            : struct xt_percpu_counter_alloc_state {
     423                 :            :         unsigned int off;
     424                 :            :         const char __percpu *mem;
     425                 :            : };
     426                 :            : 
     427                 :            : bool xt_percpu_counter_alloc(struct xt_percpu_counter_alloc_state *state,
     428                 :            :                              struct xt_counters *counter);
     429                 :            : void xt_percpu_counter_free(struct xt_counters *cnt);
     430                 :            : 
     431                 :            : static inline struct xt_counters *
     432                 :            : xt_get_this_cpu_counter(struct xt_counters *cnt)
     433                 :            : {
     434   [ #  #  #  # ]:          0 :         if (nr_cpu_ids > 1)
     435                 :          0 :                 return this_cpu_ptr((void __percpu *) (unsigned long) cnt->pcnt);
     436                 :            : 
     437                 :            :         return cnt;
     438                 :            : }
     439                 :            : 
     440                 :            : static inline struct xt_counters *
     441                 :            : xt_get_per_cpu_counter(struct xt_counters *cnt, unsigned int cpu)
     442                 :            : {
     443   [ #  #  #  # ]:          0 :         if (nr_cpu_ids > 1)
     444                 :          0 :                 return per_cpu_ptr((void __percpu *) (unsigned long) cnt->pcnt, cpu);
     445                 :            : 
     446                 :            :         return cnt;
     447                 :            : }
     448                 :            : 
     449                 :            : struct nf_hook_ops *xt_hook_ops_alloc(const struct xt_table *, nf_hookfn *);
     450                 :            : 
     451                 :            : #ifdef CONFIG_COMPAT
     452                 :            : #include <net/compat.h>
     453                 :            : 
     454                 :            : struct compat_xt_entry_match {
     455                 :            :         union {
     456                 :            :                 struct {
     457                 :            :                         u_int16_t match_size;
     458                 :            :                         char name[XT_FUNCTION_MAXNAMELEN - 1];
     459                 :            :                         u_int8_t revision;
     460                 :            :                 } user;
     461                 :            :                 struct {
     462                 :            :                         u_int16_t match_size;
     463                 :            :                         compat_uptr_t match;
     464                 :            :                 } kernel;
     465                 :            :                 u_int16_t match_size;
     466                 :            :         } u;
     467                 :            :         unsigned char data[0];
     468                 :            : };
     469                 :            : 
     470                 :            : struct compat_xt_entry_target {
     471                 :            :         union {
     472                 :            :                 struct {
     473                 :            :                         u_int16_t target_size;
     474                 :            :                         char name[XT_FUNCTION_MAXNAMELEN - 1];
     475                 :            :                         u_int8_t revision;
     476                 :            :                 } user;
     477                 :            :                 struct {
     478                 :            :                         u_int16_t target_size;
     479                 :            :                         compat_uptr_t target;
     480                 :            :                 } kernel;
     481                 :            :                 u_int16_t target_size;
     482                 :            :         } u;
     483                 :            :         unsigned char data[0];
     484                 :            : };
     485                 :            : 
     486                 :            : /* FIXME: this works only on 32 bit tasks
     487                 :            :  * need to change whole approach in order to calculate align as function of
     488                 :            :  * current task alignment */
     489                 :            : 
     490                 :            : struct compat_xt_counters {
     491                 :            :         compat_u64 pcnt, bcnt;                  /* Packet and byte counters */
     492                 :            : };
     493                 :            : 
     494                 :            : struct compat_xt_counters_info {
     495                 :            :         char name[XT_TABLE_MAXNAMELEN];
     496                 :            :         compat_uint_t num_counters;
     497                 :            :         struct compat_xt_counters counters[0];
     498                 :            : };
     499                 :            : 
     500                 :            : struct _compat_xt_align {
     501                 :            :         __u8 u8;
     502                 :            :         __u16 u16;
     503                 :            :         __u32 u32;
     504                 :            :         compat_u64 u64;
     505                 :            : };
     506                 :            : 
     507                 :            : #define COMPAT_XT_ALIGN(s) __ALIGN_KERNEL((s), __alignof__(struct _compat_xt_align))
     508                 :            : 
     509                 :            : void xt_compat_lock(u_int8_t af);
     510                 :            : void xt_compat_unlock(u_int8_t af);
     511                 :            : 
     512                 :            : int xt_compat_add_offset(u_int8_t af, unsigned int offset, int delta);
     513                 :            : void xt_compat_flush_offsets(u_int8_t af);
     514                 :            : int xt_compat_init_offsets(u8 af, unsigned int number);
     515                 :            : int xt_compat_calc_jump(u_int8_t af, unsigned int offset);
     516                 :            : 
     517                 :            : int xt_compat_match_offset(const struct xt_match *match);
     518                 :            : void xt_compat_match_from_user(struct xt_entry_match *m, void **dstptr,
     519                 :            :                               unsigned int *size);
     520                 :            : int xt_compat_match_to_user(const struct xt_entry_match *m,
     521                 :            :                             void __user **dstptr, unsigned int *size);
     522                 :            : 
     523                 :            : int xt_compat_target_offset(const struct xt_target *target);
     524                 :            : void xt_compat_target_from_user(struct xt_entry_target *t, void **dstptr,
     525                 :            :                                 unsigned int *size);
     526                 :            : int xt_compat_target_to_user(const struct xt_entry_target *t,
     527                 :            :                              void __user **dstptr, unsigned int *size);
     528                 :            : int xt_compat_check_entry_offsets(const void *base, const char *elems,
     529                 :            :                                   unsigned int target_offset,
     530                 :            :                                   unsigned int next_offset);
     531                 :            : 
     532                 :            : #endif /* CONFIG_COMPAT */
     533                 :            : #endif /* _X_TABLES_H */

Generated by: LCOV version 1.14