net/netfilter/xt_MARK.c

   1 /* This is a module which is used for setting the NFMARK field of an skb. */
   2
   3 /* (C) 1999-2001 Marc Boucher <marc@mbsi.ca>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  */
   9
  10 #include <linux/module.h>
  11 #include <linux/skbuff.h>
  12 #include <linux/ip.h>
  13 #include <net/checksum.h>
  14
  15 #include <linux/netfilter/x_tables.h>
  16 #include <linux/netfilter/xt_MARK.h>
  17
  18 MODULE_LICENSE("GPL");
  19 MODULE_AUTHOR("Marc Boucher <marc@mbsi.ca>");
  20 MODULE_DESCRIPTION("ip[6]tables MARK modification module");
  21 MODULE_ALIAS("ipt_MARK");
  22 MODULE_ALIAS("ip6t_MARK");
  23
  24 static unsigned int
  25 target_v0(struct sk_buff **pskb,
  26           const struct net_device *in,
  27           const struct net_device *out,
  28           unsigned int hooknum,
  29           const struct xt_target *target,
  30           const void *targinfo)
  31 {
  32         const struct xt_mark_target_info *markinfo = targinfo;
  33
  34         if((*pskb)->mark != markinfo->mark)
  35                 (*pskb)->mark = markinfo->mark;
  36
  37         return XT_CONTINUE;
  38 }
  39
  40 static unsigned int
  41 target_v1(struct sk_buff **pskb,
  42           const struct net_device *in,
  43           const struct net_device *out,
  44           unsigned int hooknum,
  45           const struct xt_target *target,
  46           const void *targinfo)
  47 {
  48         const struct xt_mark_target_info_v1 *markinfo = targinfo;
  49         int mark = 0;
  50
  51         switch (markinfo->mode) {
  52         case XT_MARK_SET:
  53                 mark = markinfo->mark;
  54                 break;
  55
  56         case XT_MARK_AND:
  57                 mark = (*pskb)->mark & markinfo->mark;
  58                 break;
  59
  60         case XT_MARK_OR:
  61                 mark = (*pskb)->mark | markinfo->mark;
  62                 break;
  63         }
  64
  65         if((*pskb)->mark != mark)
  66                 (*pskb)->mark = mark;
  67
  68         return XT_CONTINUE;
  69 }
  70
  71
  72 static int
  73 checkentry_v0(const char *tablename,
  74               const void *entry,
  75               const struct xt_target *target,
  76               void *targinfo,
  77               unsigned int hook_mask)
  78 {
  79         struct xt_mark_target_info *markinfo = targinfo;
  80
  81         if (markinfo->mark > 0xffffffff) {
  82                 printk(KERN_WARNING "MARK: Only supports 32bit wide mark\n");
  83                 return 0;
  84         }
  85         return 1;
  86 }
  87
  88 static int
  89 checkentry_v1(const char *tablename,
  90               const void *entry,
  91               const struct xt_target *target,
  92               void *targinfo,
  93               unsigned int hook_mask)
  94 {
  95         struct xt_mark_target_info_v1 *markinfo = targinfo;
  96
  97         if (markinfo->mode != XT_MARK_SET
  98             && markinfo->mode != XT_MARK_AND
  99             && markinfo->mode != XT_MARK_OR) {
 100                 printk(KERN_WARNING "MARK: unknown mode %u\n",
 101                        markinfo->mode);
 102                 return 0;
 103         }
 104         if (markinfo->mark > 0xffffffff) {
 105                 printk(KERN_WARNING "MARK: Only supports 32bit wide mark\n");
 106                 return 0;
 107         }
 108         return 1;
 109 }
 110
 111 #ifdef CONFIG_COMPAT
 112 struct compat_xt_mark_target_info_v1 {
 113         compat_ulong_t  mark;
 114         u_int8_t        mode;
 115         u_int8_t        __pad1;
 116         u_int16_t       __pad2;
 117 };
 118
 119 static void compat_from_user_v1(void *dst, void *src)
 120 {
 121         struct compat_xt_mark_target_info_v1 *cm = src;
 122         struct xt_mark_target_info_v1 m = {
 123                 .mark   = cm->mark,
 124                 .mode   = cm->mode,
 125         };
 126         memcpy(dst, &m, sizeof(m));
 127 }
 128
 129 static int compat_to_user_v1(void __user *dst, void *src)
 130 {
 131         struct xt_mark_target_info_v1 *m = src;
 132         struct compat_xt_mark_target_info_v1 cm = {
 133                 .mark   = m->mark,
 134                 .mode   = m->mode,
 135         };
 136         return copy_to_user(dst, &cm, sizeof(cm)) ? -EFAULT : 0;
 137 }
 138 #endif /* CONFIG_COMPAT */
 139
 140 static struct xt_target xt_mark_target[] = {
 141         {
 142                 .name           = "MARK",
 143                 .family         = AF_INET,
 144                 .revision       = 0,
 145                 .checkentry     = checkentry_v0,
 146                 .target         = target_v0,
 147                 .targetsize     = sizeof(struct xt_mark_target_info),
 148                 .table          = "mangle",
 149                 .me             = THIS_MODULE,
 150         },
 151         {
 152                 .name           = "MARK",
 153                 .family         = AF_INET,
 154                 .revision       = 1,
 155                 .checkentry     = checkentry_v1,
 156                 .target         = target_v1,
 157                 .targetsize     = sizeof(struct xt_mark_target_info_v1),
 158 #ifdef CONFIG_COMPAT
 159                 .compatsize     = sizeof(struct compat_xt_mark_target_info_v1),
 160                 .compat_from_user = compat_from_user_v1,
 161                 .compat_to_user = compat_to_user_v1,
 162 #endif
 163                 .table          = "mangle",
 164                 .me             = THIS_MODULE,
 165         },
 166         {
 167                 .name           = "MARK",
 168                 .family         = AF_INET6,
 169                 .revision       = 0,
 170                 .checkentry     = checkentry_v0,
 171                 .target         = target_v0,
 172                 .targetsize     = sizeof(struct xt_mark_target_info),
 173                 .table          = "mangle",
 174                 .me             = THIS_MODULE,
 175         },
 176 };
 177
 178 static int __init xt_mark_init(void)
 179 {
 180         return xt_register_targets(xt_mark_target, ARRAY_SIZE(xt_mark_target));
 181 }
 182
 183 static void __exit xt_mark_fini(void)
 184 {
 185         xt_unregister_targets(xt_mark_target, ARRAY_SIZE(xt_mark_target));
 186 }
 187
 188 module_init(xt_mark_init);
 189 module_exit(xt_mark_fini);