err.no Git - linux-2.6/blob - include/linux/netfilter.h

   1 #ifndef __LINUX_NETFILTER_H
   2 #define __LINUX_NETFILTER_H
   3
   4 #ifdef __KERNEL__
   5 #include <linux/init.h>
   6 #include <linux/types.h>
   7 #include <linux/skbuff.h>
   8 #include <linux/net.h>
   9 #include <linux/if.h>
  10 #include <linux/wait.h>
  11 #include <linux/list.h>
  12 #endif
  13 #include <linux/compiler.h>
  14
  15 /* Responses from hook functions. */
  16 #define NF_DROP 0
  17 #define NF_ACCEPT 1
  18 #define NF_STOLEN 2
  19 #define NF_QUEUE 3
  20 #define NF_REPEAT 4
  21 #define NF_STOP 5
  22 #define NF_MAX_VERDICT NF_STOP
  23
  24 /* we overload the higher bits for encoding auxiliary data such as the queue
  25  * number. Not nice, but better than additional function arguments. */
  26 #define NF_VERDICT_MASK 0x0000ffff
  27 #define NF_VERDICT_BITS 16
  28
  29 #define NF_VERDICT_QMASK 0xffff0000
  30 #define NF_VERDICT_QBITS 16
  31
  32 #define NF_QUEUE_NR(x) (((x << NF_VERDICT_QBITS) & NF_VERDICT_QMASK) | NF_QUEUE)
  33
  34 /* only for userspace compatibility */
  35 #ifndef __KERNEL__
  36 /* Generic cache responses from hook functions.
  37    <= 0x2000 is used for protocol-flags. */
  38 #define NFC_UNKNOWN 0x4000
  39 #define NFC_ALTERED 0x8000
  40 #endif
  41
  42 enum nf_inet_hooks {
  43         NF_INET_PRE_ROUTING,
  44         NF_INET_LOCAL_IN,
  45         NF_INET_FORWARD,
  46         NF_INET_LOCAL_OUT,
  47         NF_INET_POST_ROUTING,
  48         NF_INET_NUMHOOKS
  49 };
  50
  51 #ifdef __KERNEL__
  52 #ifdef CONFIG_NETFILTER
  53
  54 extern void netfilter_init(void);
  55
  56 /* Largest hook number + 1 */
  57 #define NF_MAX_HOOKS 8
  58
  59 struct sk_buff;
  60 struct net_device;
  61
  62 typedef unsigned int nf_hookfn(unsigned int hooknum,
  63                                struct sk_buff *skb,
  64                                const struct net_device *in,
  65                                const struct net_device *out,
  66                                int (*okfn)(struct sk_buff *));
  67
  68 struct nf_hook_ops
  69 {
  70         struct list_head list;
  71
  72         /* User fills in from here down. */
  73         nf_hookfn *hook;
  74         struct module *owner;
  75         int pf;
  76         int hooknum;
  77         /* Hooks are ordered in ascending priority. */
  78         int priority;
  79 };
  80
  81 struct nf_sockopt_ops
  82 {
  83         struct list_head list;
  84
  85         int pf;
  86
  87         /* Non-inclusive ranges: use 0/0/NULL to never get called. */
  88         int set_optmin;
  89         int set_optmax;
  90         int (*set)(struct sock *sk, int optval, void __user *user, unsigned int len);
  91         int (*compat_set)(struct sock *sk, int optval,
  92                         void __user *user, unsigned int len);
  93
  94         int get_optmin;
  95         int get_optmax;
  96         int (*get)(struct sock *sk, int optval, void __user *user, int *len);
  97         int (*compat_get)(struct sock *sk, int optval,
  98                         void __user *user, int *len);
  99
 100         /* Use the module struct to lock set/get code in place */
 101         struct module *owner;
 102 };
 103
 104 /* Function to register/unregister hook points. */
 105 int nf_register_hook(struct nf_hook_ops *reg);
 106 void nf_unregister_hook(struct nf_hook_ops *reg);
 107 int nf_register_hooks(struct nf_hook_ops *reg, unsigned int n);
 108 void nf_unregister_hooks(struct nf_hook_ops *reg, unsigned int n);
 109
 110 /* Functions to register get/setsockopt ranges (non-inclusive).  You
 111    need to check permissions yourself! */
 112 int nf_register_sockopt(struct nf_sockopt_ops *reg);
 113 void nf_unregister_sockopt(struct nf_sockopt_ops *reg);
 114
 115 #ifdef CONFIG_SYSCTL
 116 /* Sysctl registration */
 117 struct ctl_table_header *nf_register_sysctl_table(struct ctl_table *path,
 118                                                   struct ctl_table *table);
 119 void nf_unregister_sysctl_table(struct ctl_table_header *header,
 120                                 struct ctl_table *table);
 121 extern struct ctl_table nf_net_netfilter_sysctl_path[];
 122 extern struct ctl_table nf_net_ipv4_netfilter_sysctl_path[];
 123 #endif /* CONFIG_SYSCTL */
 124
 125 extern struct list_head nf_hooks[NPROTO][NF_MAX_HOOKS];
 126
 127 int nf_hook_slow(int pf, unsigned int hook, struct sk_buff *skb,
 128                  struct net_device *indev, struct net_device *outdev,
 129                  int (*okfn)(struct sk_buff *), int thresh);
 130
 131 /**
 132  *      nf_hook_thresh - call a netfilter hook
 133  *
 134  *      Returns 1 if the hook has allowed the packet to pass.  The function
 135  *      okfn must be invoked by the caller in this case.  Any other return
 136  *      value indicates the packet has been consumed by the hook.
 137  */
 138 static inline int nf_hook_thresh(int pf, unsigned int hook,
 139                                  struct sk_buff *skb,
 140                                  struct net_device *indev,
 141                                  struct net_device *outdev,
 142                                  int (*okfn)(struct sk_buff *), int thresh,
 143                                  int cond)
 144 {
 145         if (!cond)
 146                 return 1;
 147 #ifndef CONFIG_NETFILTER_DEBUG
 148         if (list_empty(&nf_hooks[pf][hook]))
 149                 return 1;
 150 #endif
 151         return nf_hook_slow(pf, hook, skb, indev, outdev, okfn, thresh);
 152 }
 153
 154 static inline int nf_hook(int pf, unsigned int hook, struct sk_buff *skb,
 155                           struct net_device *indev, struct net_device *outdev,
 156                           int (*okfn)(struct sk_buff *))
 157 {
 158         return nf_hook_thresh(pf, hook, skb, indev, outdev, okfn, INT_MIN, 1);
 159 }
 160
 161 /* Activate hook; either okfn or kfree_skb called, unless a hook
 162    returns NF_STOLEN (in which case, it's up to the hook to deal with
 163    the consequences).
 164
 165    Returns -ERRNO if packet dropped.  Zero means queued, stolen or
 166    accepted.
 167 */
 168
 169 /* RR:
 170    > I don't want nf_hook to return anything because people might forget
 171    > about async and trust the return value to mean "packet was ok".
 172
 173    AK:
 174    Just document it clearly, then you can expect some sense from kernel
 175    coders :)
 176 */
 177
 178 /* This is gross, but inline doesn't cut it for avoiding the function
 179    call in fast path: gcc doesn't inline (needs value tracking?). --RR */
 180
 181 /* HX: It's slightly less gross now. */
 182
 183 #define NF_HOOK_THRESH(pf, hook, skb, indev, outdev, okfn, thresh)             \
 184 ({int __ret;                                                                   \
 185 if ((__ret=nf_hook_thresh(pf, hook, (skb), indev, outdev, okfn, thresh, 1)) == 1)\
 186         __ret = (okfn)(skb);                                                   \
 187 __ret;})
 188
 189 #define NF_HOOK_COND(pf, hook, skb, indev, outdev, okfn, cond)                 \
 190 ({int __ret;                                                                   \
 191 if ((__ret=nf_hook_thresh(pf, hook, (skb), indev, outdev, okfn, INT_MIN, cond)) == 1)\
 192         __ret = (okfn)(skb);                                                   \
 193 __ret;})
 194
 195 #define NF_HOOK(pf, hook, skb, indev, outdev, okfn) \
 196         NF_HOOK_THRESH(pf, hook, skb, indev, outdev, okfn, INT_MIN)
 197
 198 /* Call setsockopt() */
 199 int nf_setsockopt(struct sock *sk, int pf, int optval, char __user *opt,
 200                   int len);
 201 int nf_getsockopt(struct sock *sk, int pf, int optval, char __user *opt,
 202                   int *len);
 203
 204 int compat_nf_setsockopt(struct sock *sk, int pf, int optval,
 205                 char __user *opt, int len);
 206 int compat_nf_getsockopt(struct sock *sk, int pf, int optval,
 207                 char __user *opt, int *len);
 208
 209 /* Call this before modifying an existing packet: ensures it is
 210    modifiable and linear to the point you care about (writable_len).
 211    Returns true or false. */
 212 extern int skb_make_writable(struct sk_buff *skb, unsigned int writable_len);
 213
 214 struct flowi;
 215 struct nf_queue_entry;
 216
 217 struct nf_afinfo {
 218         unsigned short  family;
 219         __sum16         (*checksum)(struct sk_buff *skb, unsigned int hook,
 220                                     unsigned int dataoff, u_int8_t protocol);
 221         int             (*route)(struct dst_entry **dst, struct flowi *fl);
 222         void            (*saveroute)(const struct sk_buff *skb,
 223                                      struct nf_queue_entry *entry);
 224         int             (*reroute)(struct sk_buff *skb,
 225                                    const struct nf_queue_entry *entry);
 226         int             route_key_size;
 227 };
 228
 229 extern struct nf_afinfo *nf_afinfo[];
 230 static inline struct nf_afinfo *nf_get_afinfo(unsigned short family)
 231 {
 232         return rcu_dereference(nf_afinfo[family]);
 233 }
 234
 235 static inline __sum16
 236 nf_checksum(struct sk_buff *skb, unsigned int hook, unsigned int dataoff,
 237             u_int8_t protocol, unsigned short family)
 238 {
 239         struct nf_afinfo *afinfo;
 240         __sum16 csum = 0;
 241
 242         rcu_read_lock();
 243         afinfo = nf_get_afinfo(family);
 244         if (afinfo)
 245                 csum = afinfo->checksum(skb, hook, dataoff, protocol);
 246         rcu_read_unlock();
 247         return csum;
 248 }
 249
 250 extern int nf_register_afinfo(struct nf_afinfo *afinfo);
 251 extern void nf_unregister_afinfo(struct nf_afinfo *afinfo);
 252
 253 #include <net/flow.h>
 254 extern void (*ip_nat_decode_session)(struct sk_buff *, struct flowi *);
 255
 256 static inline void
 257 nf_nat_decode_session(struct sk_buff *skb, struct flowi *fl, int family)
 258 {
 259 #if defined(CONFIG_IP_NF_NAT_NEEDED) || defined(CONFIG_NF_NAT_NEEDED)
 260         void (*decodefn)(struct sk_buff *, struct flowi *);
 261
 262         if (family == AF_INET && (decodefn = ip_nat_decode_session) != NULL)
 263                 decodefn(skb, fl);
 264 #endif
 265 }
 266
 267 #ifdef CONFIG_PROC_FS
 268 #include <linux/proc_fs.h>
 269 extern struct proc_dir_entry *proc_net_netfilter;
 270 #endif
 271
 272 #else /* !CONFIG_NETFILTER */
 273 #define NF_HOOK(pf, hook, skb, indev, outdev, okfn) (okfn)(skb)
 274 #define NF_HOOK_COND(pf, hook, skb, indev, outdev, okfn, cond) (okfn)(skb)
 275 static inline int nf_hook_thresh(int pf, unsigned int hook,
 276                                  struct sk_buff *skb,
 277                                  struct net_device *indev,
 278                                  struct net_device *outdev,
 279                                  int (*okfn)(struct sk_buff *), int thresh,
 280                                  int cond)
 281 {
 282         return okfn(skb);
 283 }
 284 static inline int nf_hook(int pf, unsigned int hook, struct sk_buff *skb,
 285                           struct net_device *indev, struct net_device *outdev,
 286                           int (*okfn)(struct sk_buff *))
 287 {
 288         return 1;
 289 }
 290 struct flowi;
 291 static inline void
 292 nf_nat_decode_session(struct sk_buff *skb, struct flowi *fl, int family) {}
 293 #endif /*CONFIG_NETFILTER*/
 294
 295 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
 296 extern void (*ip_ct_attach)(struct sk_buff *, struct sk_buff *);
 297 extern void nf_ct_attach(struct sk_buff *, struct sk_buff *);
 298 extern void (*nf_ct_destroy)(struct nf_conntrack *);
 299 #else
 300 static inline void nf_ct_attach(struct sk_buff *new, struct sk_buff *skb) {}
 301 #endif
 302
 303 #endif /*__KERNEL__*/
 304 #endif /*__LINUX_NETFILTER_H*/