LCOV - code coverage report
Current view: top level - include/linux - netfilter.h (source / functions) Hit Total Coverage
Test: combined.info Lines: 5 79 6.3 %
Date: 2022-03-28 16:04:14 Functions: 0 4 0.0 %
Branches: 0 69 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                 :          0 : static inline int NF_DROP_GETERR(int verdict)
      19                 :            : {
      20         [ #  # ]:          0 :         return -(verdict >> NF_VERDICT_QBITS);
      21                 :            : }
      22                 :            : 
      23                 :          0 : 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                 :          0 :         const unsigned long *ul1 = (const unsigned long *)a1;
      28                 :          0 :         const unsigned long *ul2 = (const unsigned long *)a2;
      29                 :            : 
      30   [ #  #  #  #  :          0 :         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                 :        884 : static inline struct nf_hook_ops **nf_hook_entries_get_hook_ops(const struct nf_hook_entries *e)
     122                 :            : {
     123                 :        884 :         unsigned int n = e->num_hook_entries;
     124                 :        884 :         const void *hook_end;
     125                 :            : 
     126                 :        884 :         hook_end = &e->hooks[n]; /* this is *past* ->hooks[]! */
     127                 :            : 
     128                 :        884 :         return (struct nf_hook_ops **)hook_end;
     129                 :            : }
     130                 :            : 
     131                 :            : static inline int
     132                 :          0 : 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                 :          0 : 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                 :            : void nf_hook_slow_list(struct list_head *head, struct nf_hook_state *state,
     203                 :            :                        const struct nf_hook_entries *e);
     204                 :            : /**
     205                 :            :  *      nf_hook - call a netfilter hook
     206                 :            :  *
     207                 :            :  *      Returns 1 if the hook has allowed the packet to pass.  The function
     208                 :            :  *      okfn must be invoked by the caller in this case.  Any other return
     209                 :            :  *      value indicates the packet has been consumed by the hook.
     210                 :            :  */
     211                 :          0 : static inline int nf_hook(u_int8_t pf, unsigned int hook, struct net *net,
     212                 :            :                           struct sock *sk, struct sk_buff *skb,
     213                 :            :                           struct net_device *indev, struct net_device *outdev,
     214                 :            :                           int (*okfn)(struct net *, struct sock *, struct sk_buff *))
     215                 :            : {
     216                 :          0 :         struct nf_hook_entries *hook_head = NULL;
     217                 :          0 :         int ret = 1;
     218                 :            : 
     219                 :            : #ifdef CONFIG_JUMP_LABEL
     220         [ #  # ]:          0 :         if (__builtin_constant_p(pf) &&
     221         [ #  # ]:          0 :             __builtin_constant_p(hook) &&
     222         [ #  # ]:          0 :             !static_key_false(&nf_hooks_needed[pf][hook]))
     223                 :          0 :                 return 1;
     224                 :            : #endif
     225                 :            : 
     226                 :          0 :         rcu_read_lock();
     227   [ #  #  #  # ]:          0 :         switch (pf) {
     228                 :            :         case NFPROTO_IPV4:
     229                 :          0 :                 hook_head = rcu_dereference(net->nf.hooks_ipv4[hook]);
     230                 :          0 :                 break;
     231                 :            :         case NFPROTO_IPV6:
     232                 :          0 :                 hook_head = rcu_dereference(net->nf.hooks_ipv6[hook]);
     233                 :          0 :                 break;
     234                 :            :         case NFPROTO_ARP:
     235                 :            : #ifdef CONFIG_NETFILTER_FAMILY_ARP
     236                 :            :                 if (WARN_ON_ONCE(hook >= ARRAY_SIZE(net->nf.hooks_arp)))
     237                 :            :                         break;
     238                 :            :                 hook_head = rcu_dereference(net->nf.hooks_arp[hook]);
     239                 :            : #endif
     240                 :            :                 break;
     241                 :            :         case NFPROTO_BRIDGE:
     242                 :            : #ifdef CONFIG_NETFILTER_FAMILY_BRIDGE
     243                 :            :                 hook_head = rcu_dereference(net->nf.hooks_bridge[hook]);
     244                 :            : #endif
     245                 :            :                 break;
     246                 :            : #if IS_ENABLED(CONFIG_DECNET)
     247                 :            :         case NFPROTO_DECNET:
     248                 :            :                 hook_head = rcu_dereference(net->nf.hooks_decnet[hook]);
     249                 :            :                 break;
     250                 :            : #endif
     251                 :            :         default:
     252                 :          0 :                 WARN_ON_ONCE(1);
     253                 :          0 :                 break;
     254                 :            :         }
     255                 :            : 
     256         [ #  # ]:          0 :         if (hook_head) {
     257                 :          0 :                 struct nf_hook_state state;
     258                 :            : 
     259                 :          0 :                 nf_hook_state_init(&state, hook, pf, indev, outdev,
     260                 :            :                                    sk, net, okfn);
     261                 :            : 
     262                 :          0 :                 ret = nf_hook_slow(skb, &state, hook_head, 0);
     263                 :            :         }
     264                 :          0 :         rcu_read_unlock();
     265                 :            : 
     266                 :          0 :         return ret;
     267                 :            : }
     268                 :            : 
     269                 :            : /* Activate hook; either okfn or kfree_skb called, unless a hook
     270                 :            :    returns NF_STOLEN (in which case, it's up to the hook to deal with
     271                 :            :    the consequences).
     272                 :            : 
     273                 :            :    Returns -ERRNO if packet dropped.  Zero means queued, stolen or
     274                 :            :    accepted.
     275                 :            : */
     276                 :            : 
     277                 :            : /* RR:
     278                 :            :    > I don't want nf_hook to return anything because people might forget
     279                 :            :    > about async and trust the return value to mean "packet was ok".
     280                 :            : 
     281                 :            :    AK:
     282                 :            :    Just document it clearly, then you can expect some sense from kernel
     283                 :            :    coders :)
     284                 :            : */
     285                 :            : 
     286                 :            : static inline int
     287                 :          0 : NF_HOOK_COND(uint8_t pf, unsigned int hook, struct net *net, struct sock *sk,
     288                 :            :              struct sk_buff *skb, struct net_device *in, struct net_device *out,
     289                 :            :              int (*okfn)(struct net *, struct sock *, struct sk_buff *),
     290                 :            :              bool cond)
     291                 :            : {
     292                 :          0 :         int ret;
     293                 :            : 
     294   [ #  #  #  # ]:          0 :         if (!cond ||
     295                 :          0 :             ((ret = nf_hook(pf, hook, net, sk, skb, in, out, okfn)) == 1))
     296                 :          0 :                 ret = okfn(net, sk, skb);
     297                 :          0 :         return ret;
     298                 :            : }
     299                 :            : 
     300                 :            : static inline int
     301                 :          0 : NF_HOOK(uint8_t pf, unsigned int hook, struct net *net, struct sock *sk, struct sk_buff *skb,
     302                 :            :         struct net_device *in, struct net_device *out,
     303                 :            :         int (*okfn)(struct net *, struct sock *, struct sk_buff *))
     304                 :            : {
     305                 :          0 :         int ret = nf_hook(pf, hook, net, sk, skb, in, out, okfn);
     306         [ #  # ]:          0 :         if (ret == 1)
     307                 :          0 :                 ret = okfn(net, sk, skb);
     308                 :          0 :         return ret;
     309                 :            : }
     310                 :            : 
     311                 :            : static inline void
     312                 :          0 : NF_HOOK_LIST(uint8_t pf, unsigned int hook, struct net *net, struct sock *sk,
     313                 :            :              struct list_head *head, struct net_device *in, struct net_device *out,
     314                 :            :              int (*okfn)(struct net *, struct sock *, struct sk_buff *))
     315                 :            : {
     316                 :          0 :         struct nf_hook_entries *hook_head = NULL;
     317                 :            : 
     318                 :            : #ifdef CONFIG_JUMP_LABEL
     319         [ #  # ]:          0 :         if (__builtin_constant_p(pf) &&
     320         [ #  # ]:          0 :             __builtin_constant_p(hook) &&
     321         [ #  # ]:          0 :             !static_key_false(&nf_hooks_needed[pf][hook]))
     322                 :          0 :                 return;
     323                 :            : #endif
     324                 :            : 
     325                 :          0 :         rcu_read_lock();
     326      [ #  #  # ]:          0 :         switch (pf) {
     327                 :            :         case NFPROTO_IPV4:
     328                 :          0 :                 hook_head = rcu_dereference(net->nf.hooks_ipv4[hook]);
     329                 :          0 :                 break;
     330                 :            :         case NFPROTO_IPV6:
     331                 :          0 :                 hook_head = rcu_dereference(net->nf.hooks_ipv6[hook]);
     332                 :          0 :                 break;
     333                 :            :         default:
     334                 :          0 :                 WARN_ON_ONCE(1);
     335                 :          0 :                 break;
     336                 :            :         }
     337                 :            : 
     338         [ #  # ]:          0 :         if (hook_head) {
     339                 :          0 :                 struct nf_hook_state state;
     340                 :            : 
     341                 :          0 :                 nf_hook_state_init(&state, hook, pf, in, out, sk, net, okfn);
     342                 :            : 
     343                 :          0 :                 nf_hook_slow_list(head, &state, hook_head);
     344                 :            :         }
     345                 :          0 :         rcu_read_unlock();
     346                 :            : }
     347                 :            : 
     348                 :            : /* Call setsockopt() */
     349                 :            : int nf_setsockopt(struct sock *sk, u_int8_t pf, int optval, char __user *opt,
     350                 :            :                   unsigned int len);
     351                 :            : int nf_getsockopt(struct sock *sk, u_int8_t pf, int optval, char __user *opt,
     352                 :            :                   int *len);
     353                 :            : #ifdef CONFIG_COMPAT
     354                 :            : int compat_nf_setsockopt(struct sock *sk, u_int8_t pf, int optval,
     355                 :            :                 char __user *opt, unsigned int len);
     356                 :            : int compat_nf_getsockopt(struct sock *sk, u_int8_t pf, int optval,
     357                 :            :                 char __user *opt, int *len);
     358                 :            : #endif
     359                 :            : 
     360                 :            : struct flowi;
     361                 :            : struct nf_queue_entry;
     362                 :            : 
     363                 :            : __sum16 nf_checksum(struct sk_buff *skb, unsigned int hook,
     364                 :            :                     unsigned int dataoff, u_int8_t protocol,
     365                 :            :                     unsigned short family);
     366                 :            : 
     367                 :            : __sum16 nf_checksum_partial(struct sk_buff *skb, unsigned int hook,
     368                 :            :                             unsigned int dataoff, unsigned int len,
     369                 :            :                             u_int8_t protocol, unsigned short family);
     370                 :            : int nf_route(struct net *net, struct dst_entry **dst, struct flowi *fl,
     371                 :            :              bool strict, unsigned short family);
     372                 :            : int nf_reroute(struct sk_buff *skb, struct nf_queue_entry *entry);
     373                 :            : 
     374                 :            : #include <net/flow.h>
     375                 :            : 
     376                 :            : struct nf_conn;
     377                 :            : enum nf_nat_manip_type;
     378                 :            : struct nlattr;
     379                 :            : enum ip_conntrack_dir;
     380                 :            : 
     381                 :            : struct nf_nat_hook {
     382                 :            :         int (*parse_nat_setup)(struct nf_conn *ct, enum nf_nat_manip_type manip,
     383                 :            :                                const struct nlattr *attr);
     384                 :            :         void (*decode_session)(struct sk_buff *skb, struct flowi *fl);
     385                 :            :         unsigned int (*manip_pkt)(struct sk_buff *skb, struct nf_conn *ct,
     386                 :            :                                   enum nf_nat_manip_type mtype,
     387                 :            :                                   enum ip_conntrack_dir dir);
     388                 :            : };
     389                 :            : 
     390                 :            : extern struct nf_nat_hook __rcu *nf_nat_hook;
     391                 :            : 
     392                 :            : static inline void
     393                 :          0 : nf_nat_decode_session(struct sk_buff *skb, struct flowi *fl, u_int8_t family)
     394                 :            : {
     395                 :            : #if IS_ENABLED(CONFIG_NF_NAT)
     396                 :          0 :         struct nf_nat_hook *nat_hook;
     397                 :            : 
     398                 :          0 :         rcu_read_lock();
     399         [ #  # ]:          0 :         nat_hook = rcu_dereference(nf_nat_hook);
     400   [ #  #  #  # ]:          0 :         if (nat_hook && nat_hook->decode_session)
     401                 :          0 :                 nat_hook->decode_session(skb, fl);
     402                 :          0 :         rcu_read_unlock();
     403                 :            : #endif
     404                 :            : }
     405                 :            : 
     406                 :            : #else /* !CONFIG_NETFILTER */
     407                 :            : static inline int
     408                 :            : NF_HOOK_COND(uint8_t pf, unsigned int hook, struct net *net, struct sock *sk,
     409                 :            :              struct sk_buff *skb, struct net_device *in, struct net_device *out,
     410                 :            :              int (*okfn)(struct net *, struct sock *, struct sk_buff *),
     411                 :            :              bool cond)
     412                 :            : {
     413                 :            :         return okfn(net, sk, skb);
     414                 :            : }
     415                 :            : 
     416                 :            : static inline int
     417                 :            : NF_HOOK(uint8_t pf, unsigned int hook, struct net *net, struct sock *sk,
     418                 :            :         struct sk_buff *skb, struct net_device *in, struct net_device *out,
     419                 :            :         int (*okfn)(struct net *, struct sock *, struct sk_buff *))
     420                 :            : {
     421                 :            :         return okfn(net, sk, skb);
     422                 :            : }
     423                 :            : 
     424                 :            : static inline void
     425                 :            : NF_HOOK_LIST(uint8_t pf, unsigned int hook, struct net *net, struct sock *sk,
     426                 :            :              struct list_head *head, struct net_device *in, struct net_device *out,
     427                 :            :              int (*okfn)(struct net *, struct sock *, struct sk_buff *))
     428                 :            : {
     429                 :            :         /* nothing to do */
     430                 :            : }
     431                 :            : 
     432                 :            : static inline int nf_hook(u_int8_t pf, unsigned int hook, struct net *net,
     433                 :            :                           struct sock *sk, struct sk_buff *skb,
     434                 :            :                           struct net_device *indev, struct net_device *outdev,
     435                 :            :                           int (*okfn)(struct net *, struct sock *, struct sk_buff *))
     436                 :            : {
     437                 :            :         return 1;
     438                 :            : }
     439                 :            : struct flowi;
     440                 :            : static inline void
     441                 :            : nf_nat_decode_session(struct sk_buff *skb, struct flowi *fl, u_int8_t family)
     442                 :            : {
     443                 :            : }
     444                 :            : #endif /*CONFIG_NETFILTER*/
     445                 :            : 
     446                 :            : #if IS_ENABLED(CONFIG_NF_CONNTRACK)
     447                 :            : #include <linux/netfilter/nf_conntrack_zones_common.h>
     448                 :            : 
     449                 :            : extern void (*ip_ct_attach)(struct sk_buff *, const struct sk_buff *) __rcu;
     450                 :            : void nf_ct_attach(struct sk_buff *, const struct sk_buff *);
     451                 :            : struct nf_conntrack_tuple;
     452                 :            : bool nf_ct_get_tuple_skb(struct nf_conntrack_tuple *dst_tuple,
     453                 :            :                          const struct sk_buff *skb);
     454                 :            : #else
     455                 :            : static inline void nf_ct_attach(struct sk_buff *new, struct sk_buff *skb) {}
     456                 :            : struct nf_conntrack_tuple;
     457                 :            : static inline bool nf_ct_get_tuple_skb(struct nf_conntrack_tuple *dst_tuple,
     458                 :            :                                        const struct sk_buff *skb)
     459                 :            : {
     460                 :            :         return false;
     461                 :            : }
     462                 :            : #endif
     463                 :            : 
     464                 :            : struct nf_conn;
     465                 :            : enum ip_conntrack_info;
     466                 :            : 
     467                 :            : struct nf_ct_hook {
     468                 :            :         int (*update)(struct net *net, struct sk_buff *skb);
     469                 :            :         void (*destroy)(struct nf_conntrack *);
     470                 :            :         bool (*get_tuple_skb)(struct nf_conntrack_tuple *,
     471                 :            :                               const struct sk_buff *);
     472                 :            : };
     473                 :            : extern struct nf_ct_hook __rcu *nf_ct_hook;
     474                 :            : 
     475                 :            : struct nlattr;
     476                 :            : 
     477                 :            : struct nfnl_ct_hook {
     478                 :            :         struct nf_conn *(*get_ct)(const struct sk_buff *skb,
     479                 :            :                                   enum ip_conntrack_info *ctinfo);
     480                 :            :         size_t (*build_size)(const struct nf_conn *ct);
     481                 :            :         int (*build)(struct sk_buff *skb, struct nf_conn *ct,
     482                 :            :                      enum ip_conntrack_info ctinfo,
     483                 :            :                      u_int16_t ct_attr, u_int16_t ct_info_attr);
     484                 :            :         int (*parse)(const struct nlattr *attr, struct nf_conn *ct);
     485                 :            :         int (*attach_expect)(const struct nlattr *attr, struct nf_conn *ct,
     486                 :            :                              u32 portid, u32 report);
     487                 :            :         void (*seq_adjust)(struct sk_buff *skb, struct nf_conn *ct,
     488                 :            :                            enum ip_conntrack_info ctinfo, s32 off);
     489                 :            : };
     490                 :            : extern struct nfnl_ct_hook __rcu *nfnl_ct_hook;
     491                 :            : 
     492                 :            : /**
     493                 :            :  * nf_skb_duplicated - TEE target has sent a packet
     494                 :            :  *
     495                 :            :  * When a xtables target sends a packet, the OUTPUT and POSTROUTING
     496                 :            :  * hooks are traversed again, i.e. nft and xtables are invoked recursively.
     497                 :            :  *
     498                 :            :  * This is used by xtables TEE target to prevent the duplicated skb from
     499                 :            :  * being duplicated again.
     500                 :            :  */
     501                 :            : DECLARE_PER_CPU(bool, nf_skb_duplicated);
     502                 :            : 
     503                 :            : #endif /*__LINUX_NETFILTER_H*/

Generated by: LCOV version 1.14