LCOV - code coverage report
Current view: top level - include/linux - netfilter.h (source / functions) Hit Total Coverage
Test: Real Lines: 13 47 27.7 %
Date: 2020-10-17 15:46:16 Functions: 0 5 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : #ifndef __LINUX_NETFILTER_H
       3                 :            : #define __LINUX_NETFILTER_H
       4                 :            : 
       5                 :            : #include <linux/init.h>
       6                 :            : #include <linux/skbuff.h>
       7                 :            : #include <linux/net.h>
       8                 :            : #include <linux/if.h>
       9                 :            : #include <linux/in.h>
      10                 :            : #include <linux/in6.h>
      11                 :            : #include <linux/wait.h>
      12                 :            : #include <linux/list.h>
      13                 :            : #include <linux/static_key.h>
      14                 :            : #include <linux/netfilter_defs.h>
      15                 :            : #include <linux/netdevice.h>
      16                 :            : #include <net/net_namespace.h>
      17                 :            : 
      18                 :            : static inline int NF_DROP_GETERR(int verdict)
      19                 :            : {
      20                 :          0 :         return -(verdict >> NF_VERDICT_QBITS);
      21                 :            : }
      22                 :            : 
      23                 :            : static inline int nf_inet_addr_cmp(const union nf_inet_addr *a1,
      24                 :            :                                    const union nf_inet_addr *a2)
      25                 :            : {
      26                 :            : #if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64
      27                 :            :         const unsigned long *ul1 = (const unsigned long *)a1;
      28                 :            :         const unsigned long *ul2 = (const unsigned long *)a2;
      29                 :            : 
      30                 :            :         return ((ul1[0] ^ ul2[0]) | (ul1[1] ^ ul2[1])) == 0UL;
      31                 :            : #else
      32                 :            :         return a1->all[0] == a2->all[0] &&
      33                 :            :                a1->all[1] == a2->all[1] &&
      34                 :            :                a1->all[2] == a2->all[2] &&
      35                 :            :                a1->all[3] == a2->all[3];
      36                 :            : #endif
      37                 :            : }
      38                 :            : 
      39                 :            : static inline void nf_inet_addr_mask(const union nf_inet_addr *a1,
      40                 :            :                                      union nf_inet_addr *result,
      41                 :            :                                      const union nf_inet_addr *mask)
      42                 :            : {
      43                 :            : #if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64
      44                 :            :         const unsigned long *ua = (const unsigned long *)a1;
      45                 :            :         unsigned long *ur = (unsigned long *)result;
      46                 :            :         const unsigned long *um = (const unsigned long *)mask;
      47                 :            : 
      48                 :            :         ur[0] = ua[0] & um[0];
      49                 :            :         ur[1] = ua[1] & um[1];
      50                 :            : #else
      51                 :            :         result->all[0] = a1->all[0] & mask->all[0];
      52                 :            :         result->all[1] = a1->all[1] & mask->all[1];
      53                 :            :         result->all[2] = a1->all[2] & mask->all[2];
      54                 :            :         result->all[3] = a1->all[3] & mask->all[3];
      55                 :            : #endif
      56                 :            : }
      57                 :            : 
      58                 :            : int netfilter_init(void);
      59                 :            : 
      60                 :            : struct sk_buff;
      61                 :            : 
      62                 :            : struct nf_hook_ops;
      63                 :            : 
      64                 :            : struct sock;
      65                 :            : 
      66                 :            : struct nf_hook_state {
      67                 :            :         unsigned int hook;
      68                 :            :         u_int8_t pf;
      69                 :            :         struct net_device *in;
      70                 :            :         struct net_device *out;
      71                 :            :         struct sock *sk;
      72                 :            :         struct net *net;
      73                 :            :         int (*okfn)(struct net *, struct sock *, struct sk_buff *);
      74                 :            : };
      75                 :            : 
      76                 :            : typedef unsigned int nf_hookfn(void *priv,
      77                 :            :                                struct sk_buff *skb,
      78                 :            :                                const struct nf_hook_state *state);
      79                 :            : struct nf_hook_ops {
      80                 :            :         /* User fills in from here down. */
      81                 :            :         nf_hookfn               *hook;
      82                 :            :         struct net_device       *dev;
      83                 :            :         void                    *priv;
      84                 :            :         u_int8_t                pf;
      85                 :            :         unsigned int            hooknum;
      86                 :            :         /* Hooks are ordered in ascending priority. */
      87                 :            :         int                     priority;
      88                 :            : };
      89                 :            : 
      90                 :            : struct nf_hook_entry {
      91                 :            :         nf_hookfn                       *hook;
      92                 :            :         void                            *priv;
      93                 :            : };
      94                 :            : 
      95                 :            : struct nf_hook_entries_rcu_head {
      96                 :            :         struct rcu_head head;
      97                 :            :         void    *allocation;
      98                 :            : };
      99                 :            : 
     100                 :            : struct nf_hook_entries {
     101                 :            :         u16                             num_hook_entries;
     102                 :            :         /* padding */
     103                 :            :         struct nf_hook_entry            hooks[];
     104                 :            : 
     105                 :            :         /* trailer: pointers to original orig_ops of each hook,
     106                 :            :          * followed by rcu_head and scratch space used for freeing
     107                 :            :          * the structure via call_rcu.
     108                 :            :          *
     109                 :            :          *   This is not part of struct nf_hook_entry since its only
     110                 :            :          *   needed in slow path (hook register/unregister):
     111                 :            :          * const struct nf_hook_ops     *orig_ops[]
     112                 :            :          *
     113                 :            :          *   For the same reason, we store this at end -- its
     114                 :            :          *   only needed when a hook is deleted, not during
     115                 :            :          *   packet path processing:
     116                 :            :          * struct nf_hook_entries_rcu_head     head
     117                 :            :          */
     118                 :            : };
     119                 :            : 
     120                 :            : #ifdef CONFIG_NETFILTER
     121                 :            : static inline struct nf_hook_ops **nf_hook_entries_get_hook_ops(const struct nf_hook_entries *e)
     122                 :            : {
     123                 :          0 :         unsigned int n = e->num_hook_entries;
     124                 :            :         const void *hook_end;
     125                 :            : 
     126                 :          0 :         hook_end = &e->hooks[n]; /* this is *past* ->hooks[]! */
     127                 :            : 
     128                 :            :         return (struct nf_hook_ops **)hook_end;
     129                 :            : }
     130                 :            : 
     131                 :            : static inline int
     132                 :            : nf_hook_entry_hookfn(const struct nf_hook_entry *entry, struct sk_buff *skb,
     133                 :            :                      struct nf_hook_state *state)
     134                 :            : {
     135                 :          0 :         return entry->hook(entry->priv, skb, state);
     136                 :            : }
     137                 :            : 
     138                 :            : static inline void nf_hook_state_init(struct nf_hook_state *p,
     139                 :            :                                       unsigned int hook,
     140                 :            :                                       u_int8_t pf,
     141                 :            :                                       struct net_device *indev,
     142                 :            :                                       struct net_device *outdev,
     143                 :            :                                       struct sock *sk,
     144                 :            :                                       struct net *net,
     145                 :            :                                       int (*okfn)(struct net *, struct sock *, struct sk_buff *))
     146                 :            : {
     147                 :          0 :         p->hook = hook;
     148                 :          0 :         p->pf = pf;
     149                 :          0 :         p->in = indev;
     150                 :          0 :         p->out = outdev;
     151                 :          0 :         p->sk = sk;
     152                 :          0 :         p->net = net;
     153                 :          0 :         p->okfn = okfn;
     154                 :            : }
     155                 :            : 
     156                 :            : 
     157                 :            : 
     158                 :            : struct nf_sockopt_ops {
     159                 :            :         struct list_head list;
     160                 :            : 
     161                 :            :         u_int8_t pf;
     162                 :            : 
     163                 :            :         /* Non-inclusive ranges: use 0/0/NULL to never get called. */
     164                 :            :         int set_optmin;
     165                 :            :         int set_optmax;
     166                 :            :         int (*set)(struct sock *sk, int optval, void __user *user, unsigned int len);
     167                 :            : #ifdef CONFIG_COMPAT
     168                 :            :         int (*compat_set)(struct sock *sk, int optval,
     169                 :            :                         void __user *user, unsigned int len);
     170                 :            : #endif
     171                 :            :         int get_optmin;
     172                 :            :         int get_optmax;
     173                 :            :         int (*get)(struct sock *sk, int optval, void __user *user, int *len);
     174                 :            : #ifdef CONFIG_COMPAT
     175                 :            :         int (*compat_get)(struct sock *sk, int optval,
     176                 :            :                         void __user *user, int *len);
     177                 :            : #endif
     178                 :            :         /* Use the module struct to lock set/get code in place */
     179                 :            :         struct module *owner;
     180                 :            : };
     181                 :            : 
     182                 :            : /* Function to register/unregister hook points. */
     183                 :            : int nf_register_net_hook(struct net *net, const struct nf_hook_ops *ops);
     184                 :            : void nf_unregister_net_hook(struct net *net, const struct nf_hook_ops *ops);
     185                 :            : int nf_register_net_hooks(struct net *net, const struct nf_hook_ops *reg,
     186                 :            :                           unsigned int n);
     187                 :            : void nf_unregister_net_hooks(struct net *net, const struct nf_hook_ops *reg,
     188                 :            :                              unsigned int n);
     189                 :            : 
     190                 :            : /* Functions to register get/setsockopt ranges (non-inclusive).  You
     191                 :            :    need to check permissions yourself! */
     192                 :            : int nf_register_sockopt(struct nf_sockopt_ops *reg);
     193                 :            : void nf_unregister_sockopt(struct nf_sockopt_ops *reg);
     194                 :            : 
     195                 :            : #ifdef CONFIG_JUMP_LABEL
     196                 :            : extern struct static_key nf_hooks_needed[NFPROTO_NUMPROTO][NF_MAX_HOOKS];
     197                 :            : #endif
     198                 :            : 
     199                 :            : int nf_hook_slow(struct sk_buff *skb, struct nf_hook_state *state,
     200                 :            :                  const struct nf_hook_entries *e, unsigned int i);
     201                 :            : 
     202                 :            : /**
     203                 :            :  *      nf_hook - call a netfilter hook
     204                 :            :  *
     205                 :            :  *      Returns 1 if the hook has allowed the packet to pass.  The function
     206                 :            :  *      okfn must be invoked by the caller in this case.  Any other return
     207                 :            :  *      value indicates the packet has been consumed by the hook.
     208                 :            :  */
     209                 :          3 : static inline int nf_hook(u_int8_t pf, unsigned int hook, struct net *net,
     210                 :            :                           struct sock *sk, struct sk_buff *skb,
     211                 :            :                           struct net_device *indev, struct net_device *outdev,
     212                 :            :                           int (*okfn)(struct net *, struct sock *, struct sk_buff *))
     213                 :            : {
     214                 :            :         struct nf_hook_entries *hook_head = NULL;
     215                 :            :         int ret = 1;
     216                 :            : 
     217                 :            : #ifdef CONFIG_JUMP_LABEL
     218                 :          3 :         if (__builtin_constant_p(pf) &&
     219                 :          3 :             __builtin_constant_p(hook) &&
     220                 :          3 :             !static_key_false(&nf_hooks_needed[pf][hook]))
     221                 :            :                 return 1;
     222                 :            : #endif
     223                 :            : 
     224                 :            :         rcu_read_lock();
     225                 :          0 :         switch (pf) {
     226                 :            :         case NFPROTO_IPV4:
     227                 :          0 :                 hook_head = rcu_dereference(net->nf.hooks_ipv4[hook]);
     228                 :          0 :                 break;
     229                 :            :         case NFPROTO_IPV6:
     230                 :          0 :                 hook_head = rcu_dereference(net->nf.hooks_ipv6[hook]);
     231                 :          0 :                 break;
     232                 :            :         case NFPROTO_ARP:
     233                 :            : #ifdef CONFIG_NETFILTER_FAMILY_ARP
     234                 :          0 :                 if (WARN_ON_ONCE(hook >= ARRAY_SIZE(net->nf.hooks_arp)))
     235                 :            :                         break;
     236                 :          0 :                 hook_head = rcu_dereference(net->nf.hooks_arp[hook]);
     237                 :            : #endif
     238                 :          0 :                 break;
     239                 :            :         case NFPROTO_BRIDGE:
     240                 :            : #ifdef CONFIG_NETFILTER_FAMILY_BRIDGE
     241                 :          0 :                 hook_head = rcu_dereference(net->nf.hooks_bridge[hook]);
     242                 :            : #endif
     243                 :          0 :                 break;
     244                 :            : #if IS_ENABLED(CONFIG_DECNET)
     245                 :            :         case NFPROTO_DECNET:
     246                 :            :                 hook_head = rcu_dereference(net->nf.hooks_decnet[hook]);
     247                 :            :                 break;
     248                 :            : #endif
     249                 :            :         default:
     250                 :          0 :                 WARN_ON_ONCE(1);
     251                 :            :                 break;
     252                 :            :         }
     253                 :            : 
     254                 :          0 :         if (hook_head) {
     255                 :            :                 struct nf_hook_state state;
     256                 :            : 
     257                 :            :                 nf_hook_state_init(&state, hook, pf, indev, outdev,
     258                 :            :                                    sk, net, okfn);
     259                 :            : 
     260                 :          0 :                 ret = nf_hook_slow(skb, &state, hook_head, 0);
     261                 :            :         }
     262                 :            :         rcu_read_unlock();
     263                 :            : 
     264                 :          0 :         return ret;
     265                 :            : }
     266                 :            : 
     267                 :            : /* Activate hook; either okfn or kfree_skb called, unless a hook
     268                 :            :    returns NF_STOLEN (in which case, it's up to the hook to deal with
     269                 :            :    the consequences).
     270                 :            : 
     271                 :            :    Returns -ERRNO if packet dropped.  Zero means queued, stolen or
     272                 :            :    accepted.
     273                 :            : */
     274                 :            : 
     275                 :            : /* RR:
     276                 :            :    > I don't want nf_hook to return anything because people might forget
     277                 :            :    > about async and trust the return value to mean "packet was ok".
     278                 :            : 
     279                 :            :    AK:
     280                 :            :    Just document it clearly, then you can expect some sense from kernel
     281                 :            :    coders :)
     282                 :            : */
     283                 :            : 
     284                 :            : static inline int
     285                 :          3 : NF_HOOK_COND(uint8_t pf, unsigned int hook, struct net *net, struct sock *sk,
     286                 :            :              struct sk_buff *skb, struct net_device *in, struct net_device *out,
     287                 :            :              int (*okfn)(struct net *, struct sock *, struct sk_buff *),
     288                 :            :              bool cond)
     289                 :            : {
     290                 :            :         int ret;
     291                 :            : 
     292                 :          3 :         if (!cond ||
     293                 :            :             ((ret = nf_hook(pf, hook, net, sk, skb, in, out, okfn)) == 1))
     294                 :          3 :                 ret = okfn(net, sk, skb);
     295                 :          3 :         return ret;
     296                 :            : }
     297                 :            : 
     298                 :            : static inline int
     299                 :          3 : NF_HOOK(uint8_t pf, unsigned int hook, struct net *net, struct sock *sk, struct sk_buff *skb,
     300                 :            :         struct net_device *in, struct net_device *out,
     301                 :            :         int (*okfn)(struct net *, struct sock *, struct sk_buff *))
     302                 :            : {
     303                 :          3 :         int ret = nf_hook(pf, hook, net, sk, skb, in, out, okfn);
     304                 :          3 :         if (ret == 1)
     305                 :          3 :                 ret = okfn(net, sk, skb);
     306                 :          3 :         return ret;
     307                 :            : }
     308                 :            : 
     309                 :            : static inline void
     310                 :          0 : NF_HOOK_LIST(uint8_t pf, unsigned int hook, struct net *net, struct sock *sk,
     311                 :            :              struct list_head *head, struct net_device *in, struct net_device *out,
     312                 :            :              int (*okfn)(struct net *, struct sock *, struct sk_buff *))
     313                 :            : {
     314                 :            :         struct sk_buff *skb, *next;
     315                 :            :         struct list_head sublist;
     316                 :            : 
     317                 :            :         INIT_LIST_HEAD(&sublist);
     318                 :          0 :         list_for_each_entry_safe(skb, next, head, list) {
     319                 :            :                 list_del(&skb->list);
     320                 :          0 :                 if (nf_hook(pf, hook, net, sk, skb, in, out, okfn) == 1)
     321                 :            :                         list_add_tail(&skb->list, &sublist);
     322                 :            :         }
     323                 :            :         /* Put passed packets back on main list */
     324                 :            :         list_splice(&sublist, head);
     325                 :          0 : }
     326                 :            : 
     327                 :            : /* Call setsockopt() */
     328                 :            : int nf_setsockopt(struct sock *sk, u_int8_t pf, int optval, char __user *opt,
     329                 :            :                   unsigned int len);
     330                 :            : int nf_getsockopt(struct sock *sk, u_int8_t pf, int optval, char __user *opt,
     331                 :            :                   int *len);
     332                 :            : #ifdef CONFIG_COMPAT
     333                 :            : int compat_nf_setsockopt(struct sock *sk, u_int8_t pf, int optval,
     334                 :            :                 char __user *opt, unsigned int len);
     335                 :            : int compat_nf_getsockopt(struct sock *sk, u_int8_t pf, int optval,
     336                 :            :                 char __user *opt, int *len);
     337                 :            : #endif
     338                 :            : 
     339                 :            : struct flowi;
     340                 :            : struct nf_queue_entry;
     341                 :            : 
     342                 :            : __sum16 nf_checksum(struct sk_buff *skb, unsigned int hook,
     343                 :            :                     unsigned int dataoff, u_int8_t protocol,
     344                 :            :                     unsigned short family);
     345                 :            : 
     346                 :            : __sum16 nf_checksum_partial(struct sk_buff *skb, unsigned int hook,
     347                 :            :                             unsigned int dataoff, unsigned int len,
     348                 :            :                             u_int8_t protocol, unsigned short family);
     349                 :            : int nf_route(struct net *net, struct dst_entry **dst, struct flowi *fl,
     350                 :            :              bool strict, unsigned short family);
     351                 :            : int nf_reroute(struct sk_buff *skb, struct nf_queue_entry *entry);
     352                 :            : 
     353                 :            : #include <net/flow.h>
     354                 :            : 
     355                 :            : struct nf_conn;
     356                 :            : enum nf_nat_manip_type;
     357                 :            : struct nlattr;
     358                 :            : enum ip_conntrack_dir;
     359                 :            : 
     360                 :            : struct nf_nat_hook {
     361                 :            :         int (*parse_nat_setup)(struct nf_conn *ct, enum nf_nat_manip_type manip,
     362                 :            :                                const struct nlattr *attr);
     363                 :            :         void (*decode_session)(struct sk_buff *skb, struct flowi *fl);
     364                 :            :         unsigned int (*manip_pkt)(struct sk_buff *skb, struct nf_conn *ct,
     365                 :            :                                   enum nf_nat_manip_type mtype,
     366                 :            :                                   enum ip_conntrack_dir dir);
     367                 :            : };
     368                 :            : 
     369                 :            : extern struct nf_nat_hook __rcu *nf_nat_hook;
     370                 :            : 
     371                 :            : static inline void
     372                 :          0 : nf_nat_decode_session(struct sk_buff *skb, struct flowi *fl, u_int8_t family)
     373                 :            : {
     374                 :            : #if IS_ENABLED(CONFIG_NF_NAT)
     375                 :            :         struct nf_nat_hook *nat_hook;
     376                 :            : 
     377                 :            :         rcu_read_lock();
     378                 :          0 :         nat_hook = rcu_dereference(nf_nat_hook);
     379                 :          0 :         if (nat_hook && nat_hook->decode_session)
     380                 :          0 :                 nat_hook->decode_session(skb, fl);
     381                 :            :         rcu_read_unlock();
     382                 :            : #endif
     383                 :          0 : }
     384                 :            : 
     385                 :            : #else /* !CONFIG_NETFILTER */
     386                 :            : static inline int
     387                 :            : NF_HOOK_COND(uint8_t pf, unsigned int hook, struct net *net, struct sock *sk,
     388                 :            :              struct sk_buff *skb, struct net_device *in, struct net_device *out,
     389                 :            :              int (*okfn)(struct net *, struct sock *, struct sk_buff *),
     390                 :            :              bool cond)
     391                 :            : {
     392                 :            :         return okfn(net, sk, skb);
     393                 :            : }
     394                 :            : 
     395                 :            : static inline int
     396                 :            : NF_HOOK(uint8_t pf, unsigned int hook, struct net *net, struct sock *sk,
     397                 :            :         struct sk_buff *skb, struct net_device *in, struct net_device *out,
     398                 :            :         int (*okfn)(struct net *, struct sock *, struct sk_buff *))
     399                 :            : {
     400                 :            :         return okfn(net, sk, skb);
     401                 :            : }
     402                 :            : 
     403                 :            : static inline void
     404                 :            : NF_HOOK_LIST(uint8_t pf, unsigned int hook, struct net *net, struct sock *sk,
     405                 :            :              struct list_head *head, struct net_device *in, struct net_device *out,
     406                 :            :              int (*okfn)(struct net *, struct sock *, struct sk_buff *))
     407                 :            : {
     408                 :            :         /* nothing to do */
     409                 :            : }
     410                 :            : 
     411                 :            : static inline int nf_hook(u_int8_t pf, unsigned int hook, struct net *net,
     412                 :            :                           struct sock *sk, struct sk_buff *skb,
     413                 :            :                           struct net_device *indev, struct net_device *outdev,
     414                 :            :                           int (*okfn)(struct net *, struct sock *, struct sk_buff *))
     415                 :            : {
     416                 :            :         return 1;
     417                 :            : }
     418                 :            : struct flowi;
     419                 :            : static inline void
     420                 :            : nf_nat_decode_session(struct sk_buff *skb, struct flowi *fl, u_int8_t family)
     421                 :            : {
     422                 :            : }
     423                 :            : #endif /*CONFIG_NETFILTER*/
     424                 :            : 
     425                 :            : #if IS_ENABLED(CONFIG_NF_CONNTRACK)
     426                 :            : #include <linux/netfilter/nf_conntrack_zones_common.h>
     427                 :            : 
     428                 :            : extern void (*ip_ct_attach)(struct sk_buff *, const struct sk_buff *) __rcu;
     429                 :            : void nf_ct_attach(struct sk_buff *, const struct sk_buff *);
     430                 :            : struct nf_conntrack_tuple;
     431                 :            : bool nf_ct_get_tuple_skb(struct nf_conntrack_tuple *dst_tuple,
     432                 :            :                          const struct sk_buff *skb);
     433                 :            : #else
     434                 :            : static inline void nf_ct_attach(struct sk_buff *new, struct sk_buff *skb) {}
     435                 :            : struct nf_conntrack_tuple;
     436                 :            : static inline bool nf_ct_get_tuple_skb(struct nf_conntrack_tuple *dst_tuple,
     437                 :            :                                        const struct sk_buff *skb)
     438                 :            : {
     439                 :            :         return false;
     440                 :            : }
     441                 :            : #endif
     442                 :            : 
     443                 :            : struct nf_conn;
     444                 :            : enum ip_conntrack_info;
     445                 :            : 
     446                 :            : struct nf_ct_hook {
     447                 :            :         int (*update)(struct net *net, struct sk_buff *skb);
     448                 :            :         void (*destroy)(struct nf_conntrack *);
     449                 :            :         bool (*get_tuple_skb)(struct nf_conntrack_tuple *,
     450                 :            :                               const struct sk_buff *);
     451                 :            : };
     452                 :            : extern struct nf_ct_hook __rcu *nf_ct_hook;
     453                 :            : 
     454                 :            : struct nlattr;
     455                 :            : 
     456                 :            : struct nfnl_ct_hook {
     457                 :            :         struct nf_conn *(*get_ct)(const struct sk_buff *skb,
     458                 :            :                                   enum ip_conntrack_info *ctinfo);
     459                 :            :         size_t (*build_size)(const struct nf_conn *ct);
     460                 :            :         int (*build)(struct sk_buff *skb, struct nf_conn *ct,
     461                 :            :                      enum ip_conntrack_info ctinfo,
     462                 :            :                      u_int16_t ct_attr, u_int16_t ct_info_attr);
     463                 :            :         int (*parse)(const struct nlattr *attr, struct nf_conn *ct);
     464                 :            :         int (*attach_expect)(const struct nlattr *attr, struct nf_conn *ct,
     465                 :            :                              u32 portid, u32 report);
     466                 :            :         void (*seq_adjust)(struct sk_buff *skb, struct nf_conn *ct,
     467                 :            :                            enum ip_conntrack_info ctinfo, s32 off);
     468                 :            : };
     469                 :            : extern struct nfnl_ct_hook __rcu *nfnl_ct_hook;
     470                 :            : 
     471                 :            : /**
     472                 :            :  * nf_skb_duplicated - TEE target has sent a packet
     473                 :            :  *
     474                 :            :  * When a xtables target sends a packet, the OUTPUT and POSTROUTING
     475                 :            :  * hooks are traversed again, i.e. nft and xtables are invoked recursively.
     476                 :            :  *
     477                 :            :  * This is used by xtables TEE target to prevent the duplicated skb from
     478                 :            :  * being duplicated again.
     479                 :            :  */
     480                 :            : DECLARE_PER_CPU(bool, nf_skb_duplicated);
     481                 :            : 
     482                 :            : #endif /*__LINUX_NETFILTER_H*/
    

Generated by: LCOV version 1.14