LCOV - code coverage report
Current view: top level - net/netfilter - core.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 17 222 7.7 %
Date: 2020-09-30 20:25:40 Functions: 3 23 13.0 %
Branches: 12 202 5.9 %

           Branch data     Line data    Source code
       1                 :            : /* netfilter.c: look after the filters for various protocols.
       2                 :            :  * Heavily influenced by the old firewall.c by David Bonn and Alan Cox.
       3                 :            :  *
       4                 :            :  * Thanks to Rob `CmdrTaco' Malda for not influencing this code in any
       5                 :            :  * way.
       6                 :            :  *
       7                 :            :  * This code is GPL.
       8                 :            :  */
       9                 :            : #include <linux/kernel.h>
      10                 :            : #include <linux/netfilter.h>
      11                 :            : #include <net/protocol.h>
      12                 :            : #include <linux/init.h>
      13                 :            : #include <linux/skbuff.h>
      14                 :            : #include <linux/wait.h>
      15                 :            : #include <linux/module.h>
      16                 :            : #include <linux/interrupt.h>
      17                 :            : #include <linux/if.h>
      18                 :            : #include <linux/netdevice.h>
      19                 :            : #include <linux/netfilter_ipv6.h>
      20                 :            : #include <linux/inetdevice.h>
      21                 :            : #include <linux/proc_fs.h>
      22                 :            : #include <linux/mutex.h>
      23                 :            : #include <linux/mm.h>
      24                 :            : #include <linux/rcupdate.h>
      25                 :            : #include <net/net_namespace.h>
      26                 :            : #include <net/netfilter/nf_queue.h>
      27                 :            : #include <net/sock.h>
      28                 :            : 
      29                 :            : #include "nf_internals.h"
      30                 :            : 
      31                 :            : const struct nf_ipv6_ops __rcu *nf_ipv6_ops __read_mostly;
      32                 :            : EXPORT_SYMBOL_GPL(nf_ipv6_ops);
      33                 :            : 
      34                 :            : DEFINE_PER_CPU(bool, nf_skb_duplicated);
      35                 :            : EXPORT_SYMBOL_GPL(nf_skb_duplicated);
      36                 :            : 
      37                 :            : #ifdef CONFIG_JUMP_LABEL
      38                 :            : struct static_key nf_hooks_needed[NFPROTO_NUMPROTO][NF_MAX_HOOKS];
      39                 :            : EXPORT_SYMBOL(nf_hooks_needed);
      40                 :            : #endif
      41                 :            : 
      42                 :            : static DEFINE_MUTEX(nf_hook_mutex);
      43                 :            : 
      44                 :            : /* max hooks per family/hooknum */
      45                 :            : #define MAX_HOOK_COUNT          1024
      46                 :            : 
      47                 :            : #define nf_entry_dereference(e) \
      48                 :            :         rcu_dereference_protected(e, lockdep_is_held(&nf_hook_mutex))
      49                 :            : 
      50                 :          0 : static struct nf_hook_entries *allocate_hook_entries_size(u16 num)
      51                 :            : {
      52                 :            :         struct nf_hook_entries *e;
      53                 :          0 :         size_t alloc = sizeof(*e) +
      54                 :          0 :                        sizeof(struct nf_hook_entry) * num +
      55                 :            :                        sizeof(struct nf_hook_ops *) * num +
      56                 :            :                        sizeof(struct nf_hook_entries_rcu_head);
      57                 :            : 
      58         [ #  # ]:          0 :         if (num == 0)
      59                 :            :                 return NULL;
      60                 :            : 
      61                 :            :         e = kvzalloc(alloc, GFP_KERNEL);
      62         [ #  # ]:          0 :         if (e)
      63                 :          0 :                 e->num_hook_entries = num;
      64                 :          0 :         return e;
      65                 :            : }
      66                 :            : 
      67                 :          0 : static void __nf_hook_entries_free(struct rcu_head *h)
      68                 :            : {
      69                 :            :         struct nf_hook_entries_rcu_head *head;
      70                 :            : 
      71                 :            :         head = container_of(h, struct nf_hook_entries_rcu_head, head);
      72                 :          0 :         kvfree(head->allocation);
      73                 :          0 : }
      74                 :            : 
      75                 :          0 : static void nf_hook_entries_free(struct nf_hook_entries *e)
      76                 :            : {
      77                 :            :         struct nf_hook_entries_rcu_head *head;
      78                 :            :         struct nf_hook_ops **ops;
      79                 :            :         unsigned int num;
      80                 :            : 
      81         [ #  # ]:          0 :         if (!e)
      82                 :          0 :                 return;
      83                 :            : 
      84                 :          0 :         num = e->num_hook_entries;
      85                 :            :         ops = nf_hook_entries_get_hook_ops(e);
      86                 :          0 :         head = (void *)&ops[num];
      87                 :          0 :         head->allocation = e;
      88                 :          0 :         call_rcu(&head->head, __nf_hook_entries_free);
      89                 :            : }
      90                 :            : 
      91                 :          0 : static unsigned int accept_all(void *priv,
      92                 :            :                                struct sk_buff *skb,
      93                 :            :                                const struct nf_hook_state *state)
      94                 :            : {
      95                 :          0 :         return NF_ACCEPT; /* ACCEPT makes nf_hook_slow call next hook */
      96                 :            : }
      97                 :            : 
      98                 :            : static const struct nf_hook_ops dummy_ops = {
      99                 :            :         .hook = accept_all,
     100                 :            :         .priority = INT_MIN,
     101                 :            : };
     102                 :            : 
     103                 :            : static struct nf_hook_entries *
     104                 :          0 : nf_hook_entries_grow(const struct nf_hook_entries *old,
     105                 :            :                      const struct nf_hook_ops *reg)
     106                 :            : {
     107                 :            :         unsigned int i, alloc_entries, nhooks, old_entries;
     108                 :            :         struct nf_hook_ops **orig_ops = NULL;
     109                 :            :         struct nf_hook_ops **new_ops;
     110                 :            :         struct nf_hook_entries *new;
     111                 :            :         bool inserted = false;
     112                 :            : 
     113                 :            :         alloc_entries = 1;
     114         [ #  # ]:          0 :         old_entries = old ? old->num_hook_entries : 0;
     115                 :            : 
     116         [ #  # ]:          0 :         if (old) {
     117                 :            :                 orig_ops = nf_hook_entries_get_hook_ops(old);
     118                 :            : 
     119         [ #  # ]:          0 :                 for (i = 0; i < old_entries; i++) {
     120         [ #  # ]:          0 :                         if (orig_ops[i] != &dummy_ops)
     121                 :          0 :                                 alloc_entries++;
     122                 :            :                 }
     123                 :            :         }
     124                 :            : 
     125         [ #  # ]:          0 :         if (alloc_entries > MAX_HOOK_COUNT)
     126                 :            :                 return ERR_PTR(-E2BIG);
     127                 :            : 
     128                 :          0 :         new = allocate_hook_entries_size(alloc_entries);
     129         [ #  # ]:          0 :         if (!new)
     130                 :            :                 return ERR_PTR(-ENOMEM);
     131                 :            : 
     132                 :            :         new_ops = nf_hook_entries_get_hook_ops(new);
     133                 :            : 
     134                 :            :         i = 0;
     135                 :            :         nhooks = 0;
     136         [ #  # ]:          0 :         while (i < old_entries) {
     137         [ #  # ]:          0 :                 if (orig_ops[i] == &dummy_ops) {
     138                 :          0 :                         ++i;
     139                 :          0 :                         continue;
     140                 :            :                 }
     141                 :            : 
     142   [ #  #  #  # ]:          0 :                 if (inserted || reg->priority > orig_ops[i]->priority) {
     143                 :          0 :                         new_ops[nhooks] = (void *)orig_ops[i];
     144                 :          0 :                         new->hooks[nhooks] = old->hooks[i];
     145                 :          0 :                         i++;
     146                 :            :                 } else {
     147                 :          0 :                         new_ops[nhooks] = (void *)reg;
     148                 :          0 :                         new->hooks[nhooks].hook = reg->hook;
     149                 :          0 :                         new->hooks[nhooks].priv = reg->priv;
     150                 :            :                         inserted = true;
     151                 :            :                 }
     152                 :          0 :                 nhooks++;
     153                 :            :         }
     154                 :            : 
     155         [ #  # ]:          0 :         if (!inserted) {
     156                 :          0 :                 new_ops[nhooks] = (void *)reg;
     157                 :          0 :                 new->hooks[nhooks].hook = reg->hook;
     158                 :          0 :                 new->hooks[nhooks].priv = reg->priv;
     159                 :            :         }
     160                 :            : 
     161                 :          0 :         return new;
     162                 :            : }
     163                 :            : 
     164                 :          0 : static void hooks_validate(const struct nf_hook_entries *hooks)
     165                 :            : {
     166                 :            : #ifdef CONFIG_DEBUG_MISC
     167                 :            :         struct nf_hook_ops **orig_ops;
     168                 :            :         int prio = INT_MIN;
     169                 :            :         size_t i = 0;
     170                 :            : 
     171                 :            :         orig_ops = nf_hook_entries_get_hook_ops(hooks);
     172                 :            : 
     173         [ #  # ]:          0 :         for (i = 0; i < hooks->num_hook_entries; i++) {
     174         [ #  # ]:          0 :                 if (orig_ops[i] == &dummy_ops)
     175                 :          0 :                         continue;
     176                 :            : 
     177         [ #  # ]:          0 :                 WARN_ON(orig_ops[i]->priority < prio);
     178                 :            : 
     179         [ #  # ]:          0 :                 if (orig_ops[i]->priority > prio)
     180                 :            :                         prio = orig_ops[i]->priority;
     181                 :            :         }
     182                 :            : #endif
     183                 :          0 : }
     184                 :            : 
     185                 :          0 : int nf_hook_entries_insert_raw(struct nf_hook_entries __rcu **pp,
     186                 :            :                                 const struct nf_hook_ops *reg)
     187                 :            : {
     188                 :            :         struct nf_hook_entries *new_hooks;
     189                 :            :         struct nf_hook_entries *p;
     190                 :            : 
     191                 :          0 :         p = rcu_dereference_raw(*pp);
     192                 :          0 :         new_hooks = nf_hook_entries_grow(p, reg);
     193         [ #  # ]:          0 :         if (IS_ERR(new_hooks))
     194                 :          0 :                 return PTR_ERR(new_hooks);
     195                 :            : 
     196                 :          0 :         hooks_validate(new_hooks);
     197                 :            : 
     198                 :          0 :         rcu_assign_pointer(*pp, new_hooks);
     199                 :            : 
     200         [ #  # ]:          0 :         BUG_ON(p == new_hooks);
     201                 :          0 :         nf_hook_entries_free(p);
     202                 :          0 :         return 0;
     203                 :            : }
     204                 :            : EXPORT_SYMBOL_GPL(nf_hook_entries_insert_raw);
     205                 :            : 
     206                 :            : /*
     207                 :            :  * __nf_hook_entries_try_shrink - try to shrink hook array
     208                 :            :  *
     209                 :            :  * @old -- current hook blob at @pp
     210                 :            :  * @pp -- location of hook blob
     211                 :            :  *
     212                 :            :  * Hook unregistration must always succeed, so to-be-removed hooks
     213                 :            :  * are replaced by a dummy one that will just move to next hook.
     214                 :            :  *
     215                 :            :  * This counts the current dummy hooks, attempts to allocate new blob,
     216                 :            :  * copies the live hooks, then replaces and discards old one.
     217                 :            :  *
     218                 :            :  * return values:
     219                 :            :  *
     220                 :            :  * Returns address to free, or NULL.
     221                 :            :  */
     222                 :          0 : static void *__nf_hook_entries_try_shrink(struct nf_hook_entries *old,
     223                 :            :                                           struct nf_hook_entries __rcu **pp)
     224                 :            : {
     225                 :            :         unsigned int i, j, skip = 0, hook_entries;
     226                 :            :         struct nf_hook_entries *new = NULL;
     227                 :            :         struct nf_hook_ops **orig_ops;
     228                 :            :         struct nf_hook_ops **new_ops;
     229                 :            : 
     230   [ #  #  #  #  :          0 :         if (WARN_ON_ONCE(!old))
                   #  # ]
     231                 :            :                 return NULL;
     232                 :            : 
     233                 :            :         orig_ops = nf_hook_entries_get_hook_ops(old);
     234         [ #  # ]:          0 :         for (i = 0; i < old->num_hook_entries; i++) {
     235         [ #  # ]:          0 :                 if (orig_ops[i] == &dummy_ops)
     236                 :          0 :                         skip++;
     237                 :            :         }
     238                 :            : 
     239                 :            :         /* if skip == hook_entries all hooks have been removed */
     240                 :            :         hook_entries = old->num_hook_entries;
     241         [ #  # ]:          0 :         if (skip == hook_entries)
     242                 :            :                 goto out_assign;
     243                 :            : 
     244         [ #  # ]:          0 :         if (skip == 0)
     245                 :            :                 return NULL;
     246                 :            : 
     247                 :          0 :         hook_entries -= skip;
     248                 :          0 :         new = allocate_hook_entries_size(hook_entries);
     249         [ #  # ]:          0 :         if (!new)
     250                 :            :                 return NULL;
     251                 :            : 
     252                 :            :         new_ops = nf_hook_entries_get_hook_ops(new);
     253         [ #  # ]:          0 :         for (i = 0, j = 0; i < old->num_hook_entries; i++) {
     254         [ #  # ]:          0 :                 if (orig_ops[i] == &dummy_ops)
     255                 :          0 :                         continue;
     256                 :          0 :                 new->hooks[j] = old->hooks[i];
     257                 :          0 :                 new_ops[j] = (void *)orig_ops[i];
     258                 :          0 :                 j++;
     259                 :            :         }
     260                 :          0 :         hooks_validate(new);
     261                 :            : out_assign:
     262                 :          0 :         rcu_assign_pointer(*pp, new);
     263                 :          0 :         return old;
     264                 :            : }
     265                 :            : 
     266                 :            : static struct nf_hook_entries __rcu **
     267                 :          0 : nf_hook_entry_head(struct net *net, int pf, unsigned int hooknum,
     268                 :            :                    struct net_device *dev)
     269                 :            : {
     270   [ #  #  #  #  :          0 :         switch (pf) {
                   #  # ]
     271                 :            :         case NFPROTO_NETDEV:
     272                 :            :                 break;
     273                 :            : #ifdef CONFIG_NETFILTER_FAMILY_ARP
     274                 :            :         case NFPROTO_ARP:
     275   [ #  #  #  #  :          0 :                 if (WARN_ON_ONCE(ARRAY_SIZE(net->nf.hooks_arp) <= hooknum))
                   #  # ]
     276                 :            :                         return NULL;
     277                 :          0 :                 return net->nf.hooks_arp + hooknum;
     278                 :            : #endif
     279                 :            : #ifdef CONFIG_NETFILTER_FAMILY_BRIDGE
     280                 :            :         case NFPROTO_BRIDGE:
     281   [ #  #  #  #  :          0 :                 if (WARN_ON_ONCE(ARRAY_SIZE(net->nf.hooks_bridge) <= hooknum))
                   #  # ]
     282                 :            :                         return NULL;
     283                 :          0 :                 return net->nf.hooks_bridge + hooknum;
     284                 :            : #endif
     285                 :            :         case NFPROTO_IPV4:
     286   [ #  #  #  #  :          0 :                 if (WARN_ON_ONCE(ARRAY_SIZE(net->nf.hooks_ipv4) <= hooknum))
                   #  # ]
     287                 :            :                         return NULL;
     288                 :          0 :                 return net->nf.hooks_ipv4 + hooknum;
     289                 :            :         case NFPROTO_IPV6:
     290   [ #  #  #  #  :          0 :                 if (WARN_ON_ONCE(ARRAY_SIZE(net->nf.hooks_ipv6) <= hooknum))
                   #  # ]
     291                 :            :                         return NULL;
     292                 :          0 :                 return net->nf.hooks_ipv6 + hooknum;
     293                 :            : #if IS_ENABLED(CONFIG_DECNET)
     294                 :            :         case NFPROTO_DECNET:
     295                 :            :                 if (WARN_ON_ONCE(ARRAY_SIZE(net->nf.hooks_decnet) <= hooknum))
     296                 :            :                         return NULL;
     297                 :            :                 return net->nf.hooks_decnet + hooknum;
     298                 :            : #endif
     299                 :            :         default:
     300         [ #  # ]:          0 :                 WARN_ON_ONCE(1);
     301                 :            :                 return NULL;
     302                 :            :         }
     303                 :            : 
     304                 :            : #ifdef CONFIG_NETFILTER_INGRESS
     305         [ #  # ]:          0 :         if (hooknum == NF_NETDEV_INGRESS) {
     306   [ #  #  #  # ]:          0 :                 if (dev && dev_net(dev) == net)
     307                 :          0 :                         return &dev->nf_hooks_ingress;
     308                 :            :         }
     309                 :            : #endif
     310         [ #  # ]:          0 :         WARN_ON_ONCE(1);
     311                 :            :         return NULL;
     312                 :            : }
     313                 :            : 
     314                 :          0 : static int __nf_register_net_hook(struct net *net, int pf,
     315                 :            :                                   const struct nf_hook_ops *reg)
     316                 :            : {
     317                 :            :         struct nf_hook_entries *p, *new_hooks;
     318                 :            :         struct nf_hook_entries __rcu **pp;
     319                 :            : 
     320         [ #  # ]:          0 :         if (pf == NFPROTO_NETDEV) {
     321                 :            : #ifndef CONFIG_NETFILTER_INGRESS
     322                 :            :                 if (reg->hooknum == NF_NETDEV_INGRESS)
     323                 :            :                         return -EOPNOTSUPP;
     324                 :            : #endif
     325   [ #  #  #  # ]:          0 :                 if (reg->hooknum != NF_NETDEV_INGRESS ||
     326         [ #  # ]:          0 :                     !reg->dev || dev_net(reg->dev) != net)
     327                 :            :                         return -EINVAL;
     328                 :            :         }
     329                 :            : 
     330                 :          0 :         pp = nf_hook_entry_head(net, pf, reg->hooknum, reg->dev);
     331         [ #  # ]:          0 :         if (!pp)
     332                 :            :                 return -EINVAL;
     333                 :            : 
     334                 :          0 :         mutex_lock(&nf_hook_mutex);
     335                 :            : 
     336                 :          0 :         p = nf_entry_dereference(*pp);
     337                 :          0 :         new_hooks = nf_hook_entries_grow(p, reg);
     338                 :            : 
     339         [ #  # ]:          0 :         if (!IS_ERR(new_hooks))
     340                 :          0 :                 rcu_assign_pointer(*pp, new_hooks);
     341                 :            : 
     342                 :          0 :         mutex_unlock(&nf_hook_mutex);
     343         [ #  # ]:          0 :         if (IS_ERR(new_hooks))
     344                 :          0 :                 return PTR_ERR(new_hooks);
     345                 :            : 
     346                 :          0 :         hooks_validate(new_hooks);
     347                 :            : #ifdef CONFIG_NETFILTER_INGRESS
     348   [ #  #  #  # ]:          0 :         if (pf == NFPROTO_NETDEV && reg->hooknum == NF_NETDEV_INGRESS)
     349                 :          0 :                 net_inc_ingress_queue();
     350                 :            : #endif
     351                 :            : #ifdef CONFIG_JUMP_LABEL
     352                 :          0 :         static_key_slow_inc(&nf_hooks_needed[pf][reg->hooknum]);
     353                 :            : #endif
     354         [ #  # ]:          0 :         BUG_ON(p == new_hooks);
     355                 :          0 :         nf_hook_entries_free(p);
     356                 :          0 :         return 0;
     357                 :            : }
     358                 :            : 
     359                 :            : /*
     360                 :            :  * nf_remove_net_hook - remove a hook from blob
     361                 :            :  *
     362                 :            :  * @oldp: current address of hook blob
     363                 :            :  * @unreg: hook to unregister
     364                 :            :  *
     365                 :            :  * This cannot fail, hook unregistration must always succeed.
     366                 :            :  * Therefore replace the to-be-removed hook with a dummy hook.
     367                 :            :  */
     368                 :            : static bool nf_remove_net_hook(struct nf_hook_entries *old,
     369                 :            :                                const struct nf_hook_ops *unreg)
     370                 :            : {
     371                 :            :         struct nf_hook_ops **orig_ops;
     372                 :            :         unsigned int i;
     373                 :            : 
     374                 :            :         orig_ops = nf_hook_entries_get_hook_ops(old);
     375   [ #  #  #  # ]:          0 :         for (i = 0; i < old->num_hook_entries; i++) {
     376   [ #  #  #  # ]:          0 :                 if (orig_ops[i] != unreg)
     377                 :          0 :                         continue;
     378                 :          0 :                 WRITE_ONCE(old->hooks[i].hook, accept_all);
     379                 :          0 :                 WRITE_ONCE(orig_ops[i], &dummy_ops);
     380                 :            :                 return true;
     381                 :            :         }
     382                 :            : 
     383                 :            :         return false;
     384                 :            : }
     385                 :            : 
     386                 :          0 : static void __nf_unregister_net_hook(struct net *net, int pf,
     387                 :            :                                      const struct nf_hook_ops *reg)
     388                 :            : {
     389                 :            :         struct nf_hook_entries __rcu **pp;
     390                 :            :         struct nf_hook_entries *p;
     391                 :            : 
     392                 :          0 :         pp = nf_hook_entry_head(net, pf, reg->hooknum, reg->dev);
     393         [ #  # ]:          0 :         if (!pp)
     394                 :            :                 return;
     395                 :            : 
     396                 :          0 :         mutex_lock(&nf_hook_mutex);
     397                 :            : 
     398                 :          0 :         p = nf_entry_dereference(*pp);
     399   [ #  #  #  #  :          0 :         if (WARN_ON_ONCE(!p)) {
                   #  # ]
     400                 :          0 :                 mutex_unlock(&nf_hook_mutex);
     401                 :          0 :                 return;
     402                 :            :         }
     403                 :            : 
     404         [ #  # ]:          0 :         if (nf_remove_net_hook(p, reg)) {
     405                 :            : #ifdef CONFIG_NETFILTER_INGRESS
     406   [ #  #  #  # ]:          0 :                 if (pf == NFPROTO_NETDEV && reg->hooknum == NF_NETDEV_INGRESS)
     407                 :          0 :                         net_dec_ingress_queue();
     408                 :            : #endif
     409                 :            : #ifdef CONFIG_JUMP_LABEL
     410                 :          0 :                 static_key_slow_dec(&nf_hooks_needed[pf][reg->hooknum]);
     411                 :            : #endif
     412                 :            :         } else {
     413         [ #  # ]:          0 :                 WARN_ONCE(1, "hook not found, pf %d num %d", pf, reg->hooknum);
     414                 :            :         }
     415                 :            : 
     416                 :          0 :         p = __nf_hook_entries_try_shrink(p, pp);
     417                 :          0 :         mutex_unlock(&nf_hook_mutex);
     418         [ #  # ]:          0 :         if (!p)
     419                 :            :                 return;
     420                 :            : 
     421                 :          0 :         nf_queue_nf_hook_drop(net);
     422                 :          0 :         nf_hook_entries_free(p);
     423                 :            : }
     424                 :            : 
     425                 :          0 : void nf_unregister_net_hook(struct net *net, const struct nf_hook_ops *reg)
     426                 :            : {
     427         [ #  # ]:          0 :         if (reg->pf == NFPROTO_INET) {
     428                 :          0 :                 __nf_unregister_net_hook(net, NFPROTO_IPV4, reg);
     429                 :          0 :                 __nf_unregister_net_hook(net, NFPROTO_IPV6, reg);
     430                 :            :         } else {
     431                 :          0 :                 __nf_unregister_net_hook(net, reg->pf, reg);
     432                 :            :         }
     433                 :          0 : }
     434                 :            : EXPORT_SYMBOL(nf_unregister_net_hook);
     435                 :            : 
     436                 :          0 : void nf_hook_entries_delete_raw(struct nf_hook_entries __rcu **pp,
     437                 :            :                                 const struct nf_hook_ops *reg)
     438                 :            : {
     439                 :            :         struct nf_hook_entries *p;
     440                 :            : 
     441                 :          0 :         p = rcu_dereference_raw(*pp);
     442         [ #  # ]:          0 :         if (nf_remove_net_hook(p, reg)) {
     443                 :          0 :                 p = __nf_hook_entries_try_shrink(p, pp);
     444                 :          0 :                 nf_hook_entries_free(p);
     445                 :            :         }
     446                 :          0 : }
     447                 :            : EXPORT_SYMBOL_GPL(nf_hook_entries_delete_raw);
     448                 :            : 
     449                 :          0 : int nf_register_net_hook(struct net *net, const struct nf_hook_ops *reg)
     450                 :            : {
     451                 :            :         int err;
     452                 :            : 
     453         [ #  # ]:          0 :         if (reg->pf == NFPROTO_INET) {
     454                 :          0 :                 err = __nf_register_net_hook(net, NFPROTO_IPV4, reg);
     455         [ #  # ]:          0 :                 if (err < 0)
     456                 :            :                         return err;
     457                 :            : 
     458                 :          0 :                 err = __nf_register_net_hook(net, NFPROTO_IPV6, reg);
     459         [ #  # ]:          0 :                 if (err < 0) {
     460                 :          0 :                         __nf_unregister_net_hook(net, NFPROTO_IPV4, reg);
     461                 :          0 :                         return err;
     462                 :            :                 }
     463                 :            :         } else {
     464                 :          0 :                 err = __nf_register_net_hook(net, reg->pf, reg);
     465         [ #  # ]:          0 :                 if (err < 0)
     466                 :          0 :                         return err;
     467                 :            :         }
     468                 :            : 
     469                 :            :         return 0;
     470                 :            : }
     471                 :            : EXPORT_SYMBOL(nf_register_net_hook);
     472                 :            : 
     473                 :          0 : int nf_register_net_hooks(struct net *net, const struct nf_hook_ops *reg,
     474                 :            :                           unsigned int n)
     475                 :            : {
     476                 :            :         unsigned int i;
     477                 :            :         int err = 0;
     478                 :            : 
     479         [ #  # ]:          0 :         for (i = 0; i < n; i++) {
     480                 :          0 :                 err = nf_register_net_hook(net, &reg[i]);
     481         [ #  # ]:          0 :                 if (err)
     482                 :            :                         goto err;
     483                 :            :         }
     484                 :          0 :         return err;
     485                 :            : 
     486                 :            : err:
     487         [ #  # ]:          0 :         if (i > 0)
     488                 :            :                 nf_unregister_net_hooks(net, reg, i);
     489                 :          0 :         return err;
     490                 :            : }
     491                 :            : EXPORT_SYMBOL(nf_register_net_hooks);
     492                 :            : 
     493                 :          0 : void nf_unregister_net_hooks(struct net *net, const struct nf_hook_ops *reg,
     494                 :            :                              unsigned int hookcount)
     495                 :            : {
     496                 :            :         unsigned int i;
     497                 :            : 
     498   [ #  #  #  # ]:          0 :         for (i = 0; i < hookcount; i++)
     499                 :          0 :                 nf_unregister_net_hook(net, &reg[i]);
     500                 :          0 : }
     501                 :            : EXPORT_SYMBOL(nf_unregister_net_hooks);
     502                 :            : 
     503                 :            : /* Returns 1 if okfn() needs to be executed by the caller,
     504                 :            :  * -EPERM for NF_DROP, 0 otherwise.  Caller must hold rcu_read_lock. */
     505                 :          0 : int nf_hook_slow(struct sk_buff *skb, struct nf_hook_state *state,
     506                 :            :                  const struct nf_hook_entries *e, unsigned int s)
     507                 :            : {
     508                 :            :         unsigned int verdict;
     509                 :            :         int ret;
     510                 :            : 
     511         [ #  # ]:          0 :         for (; s < e->num_hook_entries; s++) {
     512                 :            :                 verdict = nf_hook_entry_hookfn(&e->hooks[s], skb, state);
     513   [ #  #  #  # ]:          0 :                 switch (verdict & NF_VERDICT_MASK) {
     514                 :            :                 case NF_ACCEPT:
     515                 :            :                         break;
     516                 :            :                 case NF_DROP:
     517                 :          0 :                         kfree_skb(skb);
     518                 :          0 :                         ret = NF_DROP_GETERR(verdict);
     519         [ #  # ]:          0 :                         if (ret == 0)
     520                 :            :                                 ret = -EPERM;
     521                 :          0 :                         return ret;
     522                 :            :                 case NF_QUEUE:
     523                 :          0 :                         ret = nf_queue(skb, state, s, verdict);
     524         [ #  # ]:          0 :                         if (ret == 1)
     525                 :          0 :                                 continue;
     526                 :          0 :                         return ret;
     527                 :            :                 default:
     528                 :            :                         /* Implicit handling for NF_STOLEN, as well as any other
     529                 :            :                          * non conventional verdicts.
     530                 :            :                          */
     531                 :            :                         return 0;
     532                 :            :                 }
     533                 :            :         }
     534                 :            : 
     535                 :            :         return 1;
     536                 :            : }
     537                 :            : EXPORT_SYMBOL(nf_hook_slow);
     538                 :            : 
     539                 :            : /* This needs to be compiled in any case to avoid dependencies between the
     540                 :            :  * nfnetlink_queue code and nf_conntrack.
     541                 :            :  */
     542                 :            : struct nfnl_ct_hook __rcu *nfnl_ct_hook __read_mostly;
     543                 :            : EXPORT_SYMBOL_GPL(nfnl_ct_hook);
     544                 :            : 
     545                 :            : struct nf_ct_hook __rcu *nf_ct_hook __read_mostly;
     546                 :            : EXPORT_SYMBOL_GPL(nf_ct_hook);
     547                 :            : 
     548                 :            : #if IS_ENABLED(CONFIG_NF_CONNTRACK)
     549                 :            : /* This does not belong here, but locally generated errors need it if connection
     550                 :            :    tracking in use: without this, connection may not be in hash table, and hence
     551                 :            :    manufactured ICMP or RST packets will not be associated with it. */
     552                 :            : void (*ip_ct_attach)(struct sk_buff *, const struct sk_buff *)
     553                 :            :                 __rcu __read_mostly;
     554                 :            : EXPORT_SYMBOL(ip_ct_attach);
     555                 :            : 
     556                 :            : struct nf_nat_hook __rcu *nf_nat_hook __read_mostly;
     557                 :            : EXPORT_SYMBOL_GPL(nf_nat_hook);
     558                 :            : 
     559                 :        828 : void nf_ct_attach(struct sk_buff *new, const struct sk_buff *skb)
     560                 :            : {
     561                 :            :         void (*attach)(struct sk_buff *, const struct sk_buff *);
     562                 :            : 
     563         [ -  + ]:        828 :         if (skb->_nfct) {
     564                 :            :                 rcu_read_lock();
     565                 :          0 :                 attach = rcu_dereference(ip_ct_attach);
     566         [ #  # ]:          0 :                 if (attach)
     567                 :          0 :                         attach(new, skb);
     568                 :            :                 rcu_read_unlock();
     569                 :            :         }
     570                 :        828 : }
     571                 :            : EXPORT_SYMBOL(nf_ct_attach);
     572                 :            : 
     573                 :          0 : void nf_conntrack_destroy(struct nf_conntrack *nfct)
     574                 :            : {
     575                 :            :         struct nf_ct_hook *ct_hook;
     576                 :            : 
     577                 :            :         rcu_read_lock();
     578                 :          0 :         ct_hook = rcu_dereference(nf_ct_hook);
     579         [ #  # ]:          0 :         BUG_ON(ct_hook == NULL);
     580                 :          0 :         ct_hook->destroy(nfct);
     581                 :            :         rcu_read_unlock();
     582                 :          0 : }
     583                 :            : EXPORT_SYMBOL(nf_conntrack_destroy);
     584                 :            : 
     585                 :          0 : bool nf_ct_get_tuple_skb(struct nf_conntrack_tuple *dst_tuple,
     586                 :            :                          const struct sk_buff *skb)
     587                 :            : {
     588                 :            :         struct nf_ct_hook *ct_hook;
     589                 :            :         bool ret = false;
     590                 :            : 
     591                 :            :         rcu_read_lock();
     592                 :          0 :         ct_hook = rcu_dereference(nf_ct_hook);
     593         [ #  # ]:          0 :         if (ct_hook)
     594                 :          0 :                 ret = ct_hook->get_tuple_skb(dst_tuple, skb);
     595                 :            :         rcu_read_unlock();
     596                 :          0 :         return ret;
     597                 :            : }
     598                 :            : EXPORT_SYMBOL(nf_ct_get_tuple_skb);
     599                 :            : 
     600                 :            : /* Built-in default zone used e.g. by modules. */
     601                 :            : const struct nf_conntrack_zone nf_ct_zone_dflt = {
     602                 :            :         .id     = NF_CT_DEFAULT_ZONE_ID,
     603                 :            :         .dir    = NF_CT_DEFAULT_ZONE_DIR,
     604                 :            : };
     605                 :            : EXPORT_SYMBOL_GPL(nf_ct_zone_dflt);
     606                 :            : #endif /* CONFIG_NF_CONNTRACK */
     607                 :            : 
     608                 :            : static void __net_init
     609                 :            : __netfilter_net_init(struct nf_hook_entries __rcu **e, int max)
     610                 :            : {
     611                 :            :         int h;
     612                 :            : 
     613   [ +  +  +  +  :       3726 :         for (h = 0; h < max; h++)
             +  +  +  + ]
     614                 :       3726 :                 RCU_INIT_POINTER(e[h], NULL);
     615                 :            : }
     616                 :            : 
     617                 :        207 : static int __net_init netfilter_net_init(struct net *net)
     618                 :            : {
     619                 :        207 :         __netfilter_net_init(net->nf.hooks_ipv4, ARRAY_SIZE(net->nf.hooks_ipv4));
     620                 :        207 :         __netfilter_net_init(net->nf.hooks_ipv6, ARRAY_SIZE(net->nf.hooks_ipv6));
     621                 :            : #ifdef CONFIG_NETFILTER_FAMILY_ARP
     622                 :        207 :         __netfilter_net_init(net->nf.hooks_arp, ARRAY_SIZE(net->nf.hooks_arp));
     623                 :            : #endif
     624                 :            : #ifdef CONFIG_NETFILTER_FAMILY_BRIDGE
     625                 :        207 :         __netfilter_net_init(net->nf.hooks_bridge, ARRAY_SIZE(net->nf.hooks_bridge));
     626                 :            : #endif
     627                 :            : #if IS_ENABLED(CONFIG_DECNET)
     628                 :            :         __netfilter_net_init(net->nf.hooks_decnet, ARRAY_SIZE(net->nf.hooks_decnet));
     629                 :            : #endif
     630                 :            : 
     631                 :            : #ifdef CONFIG_PROC_FS
     632                 :        414 :         net->nf.proc_netfilter = proc_net_mkdir(net, "netfilter",
     633                 :            :                                                 net->proc_net);
     634         [ -  + ]:        207 :         if (!net->nf.proc_netfilter) {
     635         [ #  # ]:          0 :                 if (!net_eq(net, &init_net))
     636                 :          0 :                         pr_err("cannot create netfilter proc entry");
     637                 :            : 
     638                 :            :                 return -ENOMEM;
     639                 :            :         }
     640                 :            : #endif
     641                 :            : 
     642                 :            :         return 0;
     643                 :            : }
     644                 :            : 
     645                 :          0 : static void __net_exit netfilter_net_exit(struct net *net)
     646                 :            : {
     647                 :          0 :         remove_proc_entry("netfilter", net->proc_net);
     648                 :          0 : }
     649                 :            : 
     650                 :            : static struct pernet_operations netfilter_net_ops = {
     651                 :            :         .init = netfilter_net_init,
     652                 :            :         .exit = netfilter_net_exit,
     653                 :            : };
     654                 :            : 
     655                 :        207 : int __init netfilter_init(void)
     656                 :            : {
     657                 :            :         int ret;
     658                 :            : 
     659                 :        207 :         ret = register_pernet_subsys(&netfilter_net_ops);
     660         [ +  - ]:        207 :         if (ret < 0)
     661                 :            :                 goto err;
     662                 :            : 
     663                 :        207 :         ret = netfilter_log_init();
     664         [ -  + ]:        207 :         if (ret < 0)
     665                 :            :                 goto err_pernet;
     666                 :            : 
     667                 :            :         return 0;
     668                 :            : err_pernet:
     669                 :          0 :         unregister_pernet_subsys(&netfilter_net_ops);
     670                 :            : err:
     671                 :          0 :         return ret;
     672                 :            : }

Generated by: LCOV version 1.14