include/linux/netfilter.h

   1 #ifndef __LINUX_NETFILTER_H
   2 #define __LINUX_NETFILTER_H
   3
   4 #include <linux/init.h>
   5 #include <linux/skbuff.h>
   6 #include <linux/net.h>
   7 #include <linux/if.h>
   8 #include <linux/in.h>
   9 #include <linux/in6.h>
  10 #include <linux/wait.h>
  11 #include <linux/list.h>
  12 #include <linux/static_key.h>
  13 #include <linux/netfilter_defs.h>
  14 #include <linux/netdevice.h>
  15 #include <net/net_namespace.h>
  16
  17 #ifdef CONFIG_NETFILTER
  18 static inline int NF_DROP_GETERR(int verdict)
  19 {
  20         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         return a1->all[0] == a2->all[0] &&
  27                a1->all[1] == a2->all[1] &&
  28                a1->all[2] == a2->all[2] &&
  29                a1->all[3] == a2->all[3];
  30 }
  31
  32 static inline void nf_inet_addr_mask(const union nf_inet_addr *a1,
  33                                      union nf_inet_addr *result,
  34                                      const union nf_inet_addr *mask)
  35 {
  36         result->all[0] = a1->all[0] & mask->all[0];
  37         result->all[1] = a1->all[1] & mask->all[1];
  38         result->all[2] = a1->all[2] & mask->all[2];
  39         result->all[3] = a1->all[3] & mask->all[3];
  40 }
  41
  42 int netfilter_init(void);
  43
  44 struct sk_buff;
  45
  46 struct nf_hook_ops;
  47
  48 struct sock;
  49
  50 struct nf_hook_state {
  51         unsigned int hook;
  52         int thresh;
  53         u_int8_t pf;
  54         struct net_device *in;
  55         struct net_device *out;
  56         struct sock *sk;
  57         struct net *net;
  58         struct nf_hook_entry __rcu *hook_entries;
  59         int (*okfn)(struct net *, struct sock *, struct sk_buff *);
  60 };
  61
  62 typedef unsigned int nf_hookfn(void *priv,
  63                                struct sk_buff *skb,
  64                                const struct nf_hook_state *state);
  65 struct nf_hook_ops {
  66         struct list_head        list;
  67
  68         /* User fills in from here down. */
  69         nf_hookfn               *hook;
  70         struct net_device       *dev;
  71         void                    *priv;
  72         u_int8_t                pf;
  73         unsigned int            hooknum;
  74         /* Hooks are ordered in ascending priority. */
  75         int                     priority;
  76 };
  77
  78 struct nf_hook_entry {
  79         struct nf_hook_entry __rcu      *next;
  80         struct nf_hook_ops              ops;
  81         const struct nf_hook_ops        *orig_ops;
  82 };
  83
  84 static inline void nf_hook_state_init(struct nf_hook_state *p,
  85                                       struct nf_hook_entry *hook_entry,
  86                                       unsigned int hook,
  87                                       int thresh, u_int8_t pf,
  88                                       struct net_device *indev,
  89                                       struct net_device *outdev,
  90                                       struct sock *sk,
  91                                       struct net *net,
  92                                       int (*okfn)(struct net *, struct sock *, struct sk_buff *))
  93 {
  94         p->hook = hook;
  95         p->thresh = thresh;
  96         p->pf = pf;
  97         p->in = indev;
  98         p->out = outdev;
  99         p->sk = sk;
 100         p->net = net;
 101         RCU_INIT_POINTER(p->hook_entries, hook_entry);
 102         p->okfn = okfn;
 103 }
 104
 105
 106
 107 struct nf_sockopt_ops {
 108         struct list_head list;
 109
 110         u_int8_t pf;
 111
 112         /* Non-inclusive ranges: use 0/0/NULL to never get called. */
 113         int set_optmin;
 114         int set_optmax;
 115         int (*set)(struct sock *sk, int optval, void __user *user, unsigned int len);
 116 #ifdef CONFIG_COMPAT
 117         int (*compat_set)(struct sock *sk, int optval,
 118                         void __user *user, unsigned int len);
 119 #endif
 120         int get_optmin;
 121         int get_optmax;
 122         int (*get)(struct sock *sk, int optval, void __user *user, int *len);
 123 #ifdef CONFIG_COMPAT
 124         int (*compat_get)(struct sock *sk, int optval,
 125                         void __user *user, int *len);
 126 #endif
 127         /* Use the module struct to lock set/get code in place */
 128         struct module *owner;
 129 };
 130
 131 /* Function to register/unregister hook points. */
 132 int nf_register_net_hook(struct net *net, const struct nf_hook_ops *ops);
 133 void nf_unregister_net_hook(struct net *net, const struct nf_hook_ops *ops);
 134 int nf_register_net_hooks(struct net *net, const struct nf_hook_ops *reg,
 135                           unsigned int n);
 136 void nf_unregister_net_hooks(struct net *net, const struct nf_hook_ops *reg,
 137                              unsigned int n);
 138
 139 int nf_register_hook(struct nf_hook_ops *reg);
 140 void nf_unregister_hook(struct nf_hook_ops *reg);
 141 int nf_register_hooks(struct nf_hook_ops *reg, unsigned int n);
 142 void nf_unregister_hooks(struct nf_hook_ops *reg, unsigned int n);
 143
 144 /* Functions to register get/setsockopt ranges (non-inclusive).  You
 145    need to check permissions yourself! */
 146 int nf_register_sockopt(struct nf_sockopt_ops *reg);
 147 void nf_unregister_sockopt(struct nf_sockopt_ops *reg);
 148
 149 #ifdef HAVE_JUMP_LABEL
 150 extern struct static_key nf_hooks_needed[NFPROTO_NUMPROTO][NF_MAX_HOOKS];
 151 #endif
 152
 153 int nf_hook_slow(struct sk_buff *skb, struct nf_hook_state *state);
 154
 155 /**
 156  *      nf_hook_thresh - call a netfilter hook
 157  *
 158  *      Returns 1 if the hook has allowed the packet to pass.  The function
 159  *      okfn must be invoked by the caller in this case.  Any other return
 160  *      value indicates the packet has been consumed by the hook.
 161  */
 162 static inline int nf_hook_thresh(u_int8_t pf, unsigned int hook,
 163                                  struct net *net,
 164                                  struct sock *sk,
 165                                  struct sk_buff *skb,
 166                                  struct net_device *indev,
 167                                  struct net_device *outdev,
 168                                  int (*okfn)(struct net *, struct sock *, struct sk_buff *),
 169                                  int thresh)
 170 {
 171         struct nf_hook_entry *hook_head;
 172         int ret = 1;
 173
 174 #ifdef HAVE_JUMP_LABEL
 175         if (__builtin_constant_p(pf) &&
 176             __builtin_constant_p(hook) &&
 177             !static_key_false(&nf_hooks_needed[pf][hook]))
 178                 return 1;
 179 #endif
 180
 181         rcu_read_lock();
 182         hook_head = rcu_dereference(net->nf.hooks[pf][hook]);
 183         if (hook_head) {
 184                 struct nf_hook_state state;
 185
 186                 nf_hook_state_init(&state, hook_head, hook, thresh,
 187                                    pf, indev, outdev, sk, net, okfn);
 188
 189                 ret = nf_hook_slow(skb, &state);
 190         }
 191         rcu_read_unlock();
 192
 193         return ret;
 194 }
 195
 196 static inline int nf_hook(u_int8_t pf, unsigned int hook, struct net *net,
 197                           struct sock *sk, struct sk_buff *skb,
 198                           struct net_device *indev, struct net_device *outdev,
 199                           int (*okfn)(struct net *, struct sock *, struct sk_buff *))
 200 {
 201         return nf_hook_thresh(pf, hook, net, sk, skb, indev, outdev, okfn, INT_MIN);
 202 }
 203
 204 /* Activate hook; either okfn or kfree_skb called, unless a hook
 205    returns NF_STOLEN (in which case, it's up to the hook to deal with
 206    the consequences).
 207
 208    Returns -ERRNO if packet dropped.  Zero means queued, stolen or
 209    accepted.
 210 */
 211
 212 /* RR:
 213    > I don't want nf_hook to return anything because people might forget
 214    > about async and trust the return value to mean "packet was ok".
 215
 216    AK:
 217    Just document it clearly, then you can expect some sense from kernel
 218    coders :)
 219 */
 220
 221 static inline int
 222 NF_HOOK_THRESH(uint8_t pf, unsigned int hook, struct net *net, struct sock *sk,
 223                struct sk_buff *skb, struct net_device *in,
 224                struct net_device *out,
 225                int (*okfn)(struct net *, struct sock *, struct sk_buff *),
 226                int thresh)
 227 {
 228         int ret = nf_hook_thresh(pf, hook, net, sk, skb, in, out, okfn, thresh);
 229         if (ret == 1)
 230                 ret = okfn(net, sk, skb);
 231         return ret;
 232 }
 233
 234 static inline int
 235 NF_HOOK_COND(uint8_t pf, unsigned int hook, struct net *net, struct sock *sk,
 236              struct sk_buff *skb, struct net_device *in, struct net_device *out,
 237              int (*okfn)(struct net *, struct sock *, struct sk_buff *),
 238              bool cond)
 239 {
 240         int ret;
 241
 242         if (!cond ||
 243             ((ret = nf_hook_thresh(pf, hook, net, sk, skb, in, out, okfn, INT_MIN)) == 1))
 244                 ret = okfn(net, sk, skb);
 245         return ret;
 246 }
 247
 248 static inline int
 249 NF_HOOK(uint8_t pf, unsigned int hook, struct net *net, struct sock *sk, struct sk_buff *skb,
 250         struct net_device *in, struct net_device *out,
 251         int (*okfn)(struct net *, struct sock *, struct sk_buff *))
 252 {
 253         return NF_HOOK_THRESH(pf, hook, net, sk, skb, in, out, okfn, INT_MIN);
 254 }
 255
 256 /* Call setsockopt() */
 257 int nf_setsockopt(struct sock *sk, u_int8_t pf, int optval, char __user *opt,
 258                   unsigned int len);
 259 int nf_getsockopt(struct sock *sk, u_int8_t pf, int optval, char __user *opt,
 260                   int *len);
 261 #ifdef CONFIG_COMPAT
 262 int compat_nf_setsockopt(struct sock *sk, u_int8_t pf, int optval,
 263                 char __user *opt, unsigned int len);
 264 int compat_nf_getsockopt(struct sock *sk, u_int8_t pf, int optval,
 265                 char __user *opt, int *len);
 266 #endif
 267
 268 /* Call this before modifying an existing packet: ensures it is
 269    modifiable and linear to the point you care about (writable_len).
 270    Returns true or false. */
 271 int skb_make_writable(struct sk_buff *skb, unsigned int writable_len);
 272
 273 struct flowi;
 274 struct nf_queue_entry;
 275
 276 struct nf_afinfo {
 277         unsigned short  family;
 278         __sum16         (*checksum)(struct sk_buff *skb, unsigned int hook,
 279                                     unsigned int dataoff, u_int8_t protocol);
 280         __sum16         (*checksum_partial)(struct sk_buff *skb,
 281                                             unsigned int hook,
 282                                             unsigned int dataoff,
 283                                             unsigned int len,
 284                                             u_int8_t protocol);
 285         int             (*route)(struct net *net, struct dst_entry **dst,
 286                                  struct flowi *fl, bool strict);
 287         void            (*saveroute)(const struct sk_buff *skb,
 288                                      struct nf_queue_entry *entry);
 289         int             (*reroute)(struct net *net, struct sk_buff *skb,
 290                                    const struct nf_queue_entry *entry);
 291         int             route_key_size;
 292 };
 293
 294 extern const struct nf_afinfo __rcu *nf_afinfo[NFPROTO_NUMPROTO];
 295 static inline const struct nf_afinfo *nf_get_afinfo(unsigned short family)
 296 {
 297         return rcu_dereference(nf_afinfo[family]);
 298 }
 299
 300 static inline __sum16
 301 nf_checksum(struct sk_buff *skb, unsigned int hook, unsigned int dataoff,
 302             u_int8_t protocol, unsigned short family)
 303 {
 304         const struct nf_afinfo *afinfo;
 305         __sum16 csum = 0;
 306
 307         rcu_read_lock();
 308         afinfo = nf_get_afinfo(family);
 309         if (afinfo)
 310                 csum = afinfo->checksum(skb, hook, dataoff, protocol);
 311         rcu_read_unlock();
 312         return csum;
 313 }
 314
 315 static inline __sum16
 316 nf_checksum_partial(struct sk_buff *skb, unsigned int hook,
 317                     unsigned int dataoff, unsigned int len,
 318                     u_int8_t protocol, unsigned short family)
 319 {
 320         const struct nf_afinfo *afinfo;
 321         __sum16 csum = 0;
 322
 323         rcu_read_lock();
 324         afinfo = nf_get_afinfo(family);
 325         if (afinfo)
 326                 csum = afinfo->checksum_partial(skb, hook, dataoff, len,
 327                                                 protocol);
 328         rcu_read_unlock();
 329         return csum;
 330 }
 331
 332 int nf_register_afinfo(const struct nf_afinfo *afinfo);
 333 void nf_unregister_afinfo(const struct nf_afinfo *afinfo);
 334
 335 #include <net/flow.h>
 336 extern void (*nf_nat_decode_session_hook)(struct sk_buff *, struct flowi *);
 337
 338 static inline void
 339 nf_nat_decode_session(struct sk_buff *skb, struct flowi *fl, u_int8_t family)
 340 {
 341 #ifdef CONFIG_NF_NAT_NEEDED
 342         void (*decodefn)(struct sk_buff *, struct flowi *);
 343
 344         rcu_read_lock();
 345         decodefn = rcu_dereference(nf_nat_decode_session_hook);
 346         if (decodefn)
 347                 decodefn(skb, fl);
 348         rcu_read_unlock();
 349 #endif
 350 }
 351
 352 #else /* !CONFIG_NETFILTER */
 353 static inline int
 354 NF_HOOK_COND(uint8_t pf, unsigned int hook, struct net *net, struct sock *sk,
 355              struct sk_buff *skb, struct net_device *in, struct net_device *out,
 356              int (*okfn)(struct net *, struct sock *, struct sk_buff *),
 357              bool cond)
 358 {
 359         return okfn(net, sk, skb);
 360 }
 361
 362 static inline int
 363 NF_HOOK(uint8_t pf, unsigned int hook, struct net *net, struct sock *sk,
 364         struct sk_buff *skb, struct net_device *in, struct net_device *out,
 365         int (*okfn)(struct net *, struct sock *, struct sk_buff *))
 366 {
 367         return okfn(net, sk, skb);
 368 }
 369
 370 static inline int nf_hook(u_int8_t pf, unsigned int hook, struct net *net,
 371                           struct sock *sk, struct sk_buff *skb,
 372                           struct net_device *indev, struct net_device *outdev,
 373                           int (*okfn)(struct net *, struct sock *, struct sk_buff *))
 374 {
 375         return 1;
 376 }
 377 struct flowi;
 378 static inline void
 379 nf_nat_decode_session(struct sk_buff *skb, struct flowi *fl, u_int8_t family)
 380 {
 381 }
 382 #endif /*CONFIG_NETFILTER*/
 383
 384 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
 385 #include <linux/netfilter/nf_conntrack_zones_common.h>
 386
 387 extern void (*ip_ct_attach)(struct sk_buff *, const struct sk_buff *) __rcu;
 388 void nf_ct_attach(struct sk_buff *, const struct sk_buff *);
 389 extern void (*nf_ct_destroy)(struct nf_conntrack *) __rcu;
 390 #else
 391 static inline void nf_ct_attach(struct sk_buff *new, struct sk_buff *skb) {}
 392 #endif
 393
 394 struct nf_conn;
 395 enum ip_conntrack_info;
 396 struct nlattr;
 397
 398 struct nfnl_ct_hook {
 399         struct nf_conn *(*get_ct)(const struct sk_buff *skb,
 400                                   enum ip_conntrack_info *ctinfo);
 401         size_t (*build_size)(const struct nf_conn *ct);
 402         int (*build)(struct sk_buff *skb, struct nf_conn *ct,
 403                      enum ip_conntrack_info ctinfo,
 404                      u_int16_t ct_attr, u_int16_t ct_info_attr);
 405         int (*parse)(const struct nlattr *attr, struct nf_conn *ct);
 406         int (*attach_expect)(const struct nlattr *attr, struct nf_conn *ct,
 407                              u32 portid, u32 report);
 408         void (*seq_adjust)(struct sk_buff *skb, struct nf_conn *ct,
 409                            enum ip_conntrack_info ctinfo, s32 off);
 410 };
 411 extern struct nfnl_ct_hook __rcu *nfnl_ct_hook;
 412
 413 /**
 414  * nf_skb_duplicated - TEE target has sent a packet
 415  *
 416  * When a xtables target sends a packet, the OUTPUT and POSTROUTING
 417  * hooks are traversed again, i.e. nft and xtables are invoked recursively.
 418  *
 419  * This is used by xtables TEE target to prevent the duplicated skb from
 420  * being duplicated again.
 421  */
 422 DECLARE_PER_CPU(bool, nf_skb_duplicated);
 423
 424 #endif /*__LINUX_NETFILTER_H*/