net/netfilter/xt_DSCP.c

   1 /* x_tables module for setting the IPv4/IPv6 DSCP field, Version 1.8
   2  *
   3  * (C) 2002 by Harald Welte <laforge@netfilter.org>
   4  * based on ipt_FTOS.c (C) 2000 by Matthew G. Marsh <mgm@paktronix.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  * See RFC2474 for a description of the DSCP field within the IP Header.
  11  *
  12  * xt_DSCP.c,v 1.8 2002/08/06 18:41:57 laforge Exp
  13 */
  14
  15 #include <linux/module.h>
  16 #include <linux/skbuff.h>
  17 #include <linux/ip.h>
  18 #include <linux/ipv6.h>
  19 #include <net/dsfield.h>
  20
  21 #include <linux/netfilter/x_tables.h>
  22 #include <linux/netfilter/xt_DSCP.h>
  23
  24 MODULE_AUTHOR("Harald Welte <laforge@netfilter.org>");
  25 MODULE_DESCRIPTION("x_tables DSCP modification module");
  26 MODULE_LICENSE("GPL");
  27 MODULE_ALIAS("ipt_DSCP");
  28 MODULE_ALIAS("ip6t_DSCP");
  29
  30 static unsigned int target(struct sk_buff **pskb,
  31                            const struct net_device *in,
  32                            const struct net_device *out,
  33                            unsigned int hooknum,
  34                            const struct xt_target *target,
  35                            const void *targinfo)
  36 {
  37         const struct xt_DSCP_info *dinfo = targinfo;
  38         u_int8_t dscp = ipv4_get_dsfield((*pskb)->nh.iph) >> XT_DSCP_SHIFT;
  39
  40         if (dscp != dinfo->dscp) {
  41                 if (!skb_make_writable(pskb, sizeof(struct iphdr)))
  42                         return NF_DROP;
  43
  44                 ipv4_change_dsfield((*pskb)->nh.iph, (__u8)(~XT_DSCP_MASK),
  45                                     dinfo->dscp << XT_DSCP_SHIFT);
  46
  47         }
  48         return XT_CONTINUE;
  49 }
  50
  51 static unsigned int target6(struct sk_buff **pskb,
  52                             const struct net_device *in,
  53                             const struct net_device *out,
  54                             unsigned int hooknum,
  55                             const struct xt_target *target,
  56                             const void *targinfo)
  57 {
  58         const struct xt_DSCP_info *dinfo = targinfo;
  59         u_int8_t dscp = ipv6_get_dsfield((*pskb)->nh.ipv6h) >> XT_DSCP_SHIFT;
  60
  61         if (dscp != dinfo->dscp) {
  62                 if (!skb_make_writable(pskb, sizeof(struct ipv6hdr)))
  63                         return NF_DROP;
  64
  65                 ipv6_change_dsfield((*pskb)->nh.ipv6h, (__u8)(~XT_DSCP_MASK),
  66                                     dinfo->dscp << XT_DSCP_SHIFT);
  67         }
  68         return XT_CONTINUE;
  69 }
  70
  71 static int checkentry(const char *tablename,
  72                       const void *e_void,
  73                       const struct xt_target *target,
  74                       void *targinfo,
  75                       unsigned int hook_mask)
  76 {
  77         const u_int8_t dscp = ((struct xt_DSCP_info *)targinfo)->dscp;
  78
  79         if ((dscp > XT_DSCP_MAX)) {
  80                 printk(KERN_WARNING "DSCP: dscp %x out of range\n", dscp);
  81                 return 0;
  82         }
  83         return 1;
  84 }
  85
  86 static struct xt_target xt_dscp_target[] = {
  87         {
  88                 .name           = "DSCP",
  89                 .family         = AF_INET,
  90                 .checkentry     = checkentry,
  91                 .target         = target,
  92                 .targetsize     = sizeof(struct xt_DSCP_info),
  93                 .table          = "mangle",
  94                 .me             = THIS_MODULE,
  95         },
  96         {
  97                 .name           = "DSCP",
  98                 .family         = AF_INET6,
  99                 .checkentry     = checkentry,
 100                 .target         = target6,
 101                 .targetsize     = sizeof(struct xt_DSCP_info),
 102                 .table          = "mangle",
 103                 .me             = THIS_MODULE,
 104         },
 105 };
 106
 107 static int __init xt_dscp_target_init(void)
 108 {
 109         return xt_register_targets(xt_dscp_target, ARRAY_SIZE(xt_dscp_target));
 110 }
 111
 112 static void __exit xt_dscp_target_fini(void)
 113 {
 114         xt_unregister_targets(xt_dscp_target, ARRAY_SIZE(xt_dscp_target));
 115 }
 116
 117 module_init(xt_dscp_target_init);
 118 module_exit(xt_dscp_target_fini);