net/ipv4/netfilter/ipt_multiport.c

   1 /* Kernel module to match one of a list of TCP/UDP ports: ports are in
   2    the same place so we can treat them as equal. */
   3
   4 /* (C) 1999-2001 Paul `Rusty' Russell
   5  * (C) 2002-2004 Netfilter Core Team <coreteam@netfilter.org>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11
  12 #include <linux/module.h>
  13 #include <linux/types.h>
  14 #include <linux/udp.h>
  15 #include <linux/skbuff.h>
  16
  17 #include <linux/netfilter_ipv4/ipt_multiport.h>
  18 #include <linux/netfilter_ipv4/ip_tables.h>
  19
  20 MODULE_LICENSE("GPL");
  21 MODULE_AUTHOR("Netfilter Core Team <coreteam@netfilter.org>");
  22 MODULE_DESCRIPTION("iptables multiple port match module");
  23
  24 #if 0
  25 #define duprintf(format, args...) printk(format , ## args)
  26 #else
  27 #define duprintf(format, args...)
  28 #endif
  29
  30 /* Returns 1 if the port is matched by the test, 0 otherwise. */
  31 static inline int
  32 ports_match(const u_int16_t *portlist, enum ipt_multiport_flags flags,
  33             u_int8_t count, u_int16_t src, u_int16_t dst)
  34 {
  35         unsigned int i;
  36         for (i=0; i<count; i++) {
  37                 if (flags != IPT_MULTIPORT_DESTINATION
  38                     && portlist[i] == src)
  39                         return 1;
  40
  41                 if (flags != IPT_MULTIPORT_SOURCE
  42                     && portlist[i] == dst)
  43                         return 1;
  44         }
  45
  46         return 0;
  47 }
  48
  49 /* Returns 1 if the port is matched by the test, 0 otherwise. */
  50 static inline int
  51 ports_match_v1(const struct ipt_multiport_v1 *minfo,
  52                u_int16_t src, u_int16_t dst)
  53 {
  54         unsigned int i;
  55         u_int16_t s, e;
  56
  57         for (i=0; i < minfo->count; i++) {
  58                 s = minfo->ports[i];
  59
  60                 if (minfo->pflags[i]) {
  61                         /* range port matching */
  62                         e = minfo->ports[++i];
  63                         duprintf("src or dst matches with %d-%d?\n", s, e);
  64
  65                         if (minfo->flags == IPT_MULTIPORT_SOURCE
  66                             && src >= s && src <= e)
  67                                 return 1 ^ minfo->invert;
  68                         if (minfo->flags == IPT_MULTIPORT_DESTINATION
  69                             && dst >= s && dst <= e)
  70                                 return 1 ^ minfo->invert;
  71                         if (minfo->flags == IPT_MULTIPORT_EITHER
  72                             && ((dst >= s && dst <= e)
  73                                 || (src >= s && src <= e)))
  74                                 return 1 ^ minfo->invert;
  75                 } else {
  76                         /* exact port matching */
  77                         duprintf("src or dst matches with %d?\n", s);
  78
  79                         if (minfo->flags == IPT_MULTIPORT_SOURCE
  80                             && src == s)
  81                                 return 1 ^ minfo->invert;
  82                         if (minfo->flags == IPT_MULTIPORT_DESTINATION
  83                             && dst == s)
  84                                 return 1 ^ minfo->invert;
  85                         if (minfo->flags == IPT_MULTIPORT_EITHER
  86                             && (src == s || dst == s))
  87                                 return 1 ^ minfo->invert;
  88                 }
  89         }
  90
  91         return minfo->invert;
  92 }
  93
  94 static int
  95 match(const struct sk_buff *skb,
  96       const struct net_device *in,
  97       const struct net_device *out,
  98       const struct xt_match *match,
  99       const void *matchinfo,
 100       int offset,
 101       unsigned int protoff,
 102       int *hotdrop)
 103 {
 104         u16 _ports[2], *pptr;
 105         const struct ipt_multiport *multiinfo = matchinfo;
 106
 107         if (offset)
 108                 return 0;
 109
 110         pptr = skb_header_pointer(skb, protoff,
 111                                   sizeof(_ports), _ports);
 112         if (pptr == NULL) {
 113                 /* We've been asked to examine this packet, and we
 114                  * can't.  Hence, no choice but to drop.
 115                  */
 116                 duprintf("ipt_multiport:"
 117                          " Dropping evil offset=0 tinygram.\n");
 118                 *hotdrop = 1;
 119                 return 0;
 120         }
 121
 122         return ports_match(multiinfo->ports,
 123                            multiinfo->flags, multiinfo->count,
 124                            ntohs(pptr[0]), ntohs(pptr[1]));
 125 }
 126
 127 static int
 128 match_v1(const struct sk_buff *skb,
 129          const struct net_device *in,
 130          const struct net_device *out,
 131          const struct xt_match *match,
 132          const void *matchinfo,
 133          int offset,
 134          unsigned int protoff,
 135          int *hotdrop)
 136 {
 137         u16 _ports[2], *pptr;
 138         const struct ipt_multiport_v1 *multiinfo = matchinfo;
 139
 140         if (offset)
 141                 return 0;
 142
 143         pptr = skb_header_pointer(skb, protoff,
 144                                   sizeof(_ports), _ports);
 145         if (pptr == NULL) {
 146                 /* We've been asked to examine this packet, and we
 147                  * can't.  Hence, no choice but to drop.
 148                  */
 149                 duprintf("ipt_multiport:"
 150                          " Dropping evil offset=0 tinygram.\n");
 151                 *hotdrop = 1;
 152                 return 0;
 153         }
 154
 155         return ports_match_v1(multiinfo, ntohs(pptr[0]), ntohs(pptr[1]));
 156 }
 157
 158 static struct ipt_match multiport_match = {
 159         .name           = "multiport",
 160         .revision       = 0,
 161         .match          = match,
 162         .matchsize      = sizeof(struct ipt_multiport),
 163         .me             = THIS_MODULE,
 164 };
 165
 166 static struct ipt_match multiport_match_v1 = {
 167         .name           = "multiport",
 168         .revision       = 1,
 169         .match          = match_v1,
 170         .matchsize      = sizeof(struct ipt_multiport_v1),
 171         .me             = THIS_MODULE,
 172 };
 173
 174 static int __init init(void)
 175 {
 176         int err;
 177
 178         err = ipt_register_match(&multiport_match);
 179         if (!err) {
 180                 err = ipt_register_match(&multiport_match_v1);
 181                 if (err)
 182                         ipt_unregister_match(&multiport_match);
 183         }
 184
 185         return err;
 186 }
 187
 188 static void __exit fini(void)
 189 {
 190         ipt_unregister_match(&multiport_match);
 191         ipt_unregister_match(&multiport_match_v1);
 192 }
 193
 194 module_init(init);
 195 module_exit(fini);