release/src-rt-6.x/linux/linux-2.6/net/ipv4/netfilter/ip_set_iphash.c

   1 /* Copyright (C) 2003-2008 Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>
   2  *
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License version 2 as
   5  * published by the Free Software Foundation.
   6  */
   7
   8 /* Kernel module implementing an ip hash set */
   9
  10 #include <linux/module.h>
  11 #include <linux/moduleparam.h>
  12 #include <linux/ip.h>
  13 #include <linux/skbuff.h>
  14 #include <linux/netfilter_ipv4/ip_set_jhash.h>
  15 #include <linux/errno.h>
  16 #include <asm/uaccess.h>
  17 #include <asm/bitops.h>
  18 #include <linux/spinlock.h>
  19 #include <linux/random.h>
  20
  21 #include <net/ip.h>
  22
  23 #include <linux/netfilter_ipv4/ip_set_iphash.h>
  24
  25 static int limit = MAX_RANGE;
  26
  27 static inline __u32
  28 iphash_id(struct ip_set *set, ip_set_ip_t ip)
  29 {
  30         struct ip_set_iphash *map = set->data;
  31         __u32 id;
  32         u_int16_t i;
  33         ip_set_ip_t *elem;
  34
  35
  36         ip &= map->netmask;
  37         DP("set: %s, ip:%u.%u.%u.%u", set->name, HIPQUAD(ip));
  38         for (i = 0; i < map->probes; i++) {
  39                 id = jhash_ip(map, i, ip) % map->hashsize;
  40                 DP("hash key: %u", id);
  41                 elem = HARRAY_ELEM(map->members, ip_set_ip_t *, id);
  42                 if (*elem == ip)
  43                         return id;
  44                 /* No shortcut - there can be deleted entries. */
  45         }
  46         return UINT_MAX;
  47 }
  48
  49 static inline int
  50 iphash_test(struct ip_set *set, ip_set_ip_t ip)
  51 {
  52         return (ip && iphash_id(set, ip) != UINT_MAX);
  53 }
  54
  55 #define KADT_CONDITION
  56
  57 UADT(iphash, test)
  58 KADT(iphash, test, ipaddr)
  59
  60 static inline int
  61 __iphash_add(struct ip_set_iphash *map, ip_set_ip_t *ip)
  62 {
  63         __u32 probe;
  64         u_int16_t i;
  65         ip_set_ip_t *elem, *slot = NULL;
  66
  67         for (i = 0; i < map->probes; i++) {
  68                 probe = jhash_ip(map, i, *ip) % map->hashsize;
  69                 elem = HARRAY_ELEM(map->members, ip_set_ip_t *, probe);
  70                 if (*elem == *ip)
  71                         return -EEXIST;
  72                 if (!(slot || *elem))
  73                         slot = elem;
  74                 /* There can be deleted entries, must check all slots */
  75         }
  76         if (slot) {
  77                 *slot = *ip;
  78                 map->elements++;
  79                 return 0;
  80         }
  81         /* Trigger rehashing */
  82         return -EAGAIN;
  83 }
  84
  85 static inline int
  86 iphash_add(struct ip_set *set, ip_set_ip_t ip)
  87 {
  88         struct ip_set_iphash *map = set->data;
  89
  90         if (!ip || map->elements >= limit)
  91                 return -ERANGE;
  92
  93         ip &= map->netmask;
  94         return __iphash_add(map, &ip);
  95 }
  96
  97 UADT(iphash, add)
  98 KADT(iphash, add, ipaddr)
  99
 100 static inline void
 101 __iphash_retry(struct ip_set_iphash *tmp, struct ip_set_iphash *map)
 102 {
 103         tmp->netmask = map->netmask;
 104 }
 105
 106 HASH_RETRY(iphash, ip_set_ip_t)
 107
 108 static inline int
 109 iphash_del(struct ip_set *set, ip_set_ip_t ip)
 110 {
 111         struct ip_set_iphash *map = set->data;
 112         ip_set_ip_t id, *elem;
 113
 114         if (!ip)
 115                 return -ERANGE;
 116
 117         id = iphash_id(set, ip);
 118         if (id == UINT_MAX)
 119                 return -EEXIST;
 120
 121         elem = HARRAY_ELEM(map->members, ip_set_ip_t *, id);
 122         *elem = 0;
 123         map->elements--;
 124
 125         return 0;
 126 }
 127
 128 UADT(iphash, del)
 129 KADT(iphash, del, ipaddr)
 130
 131 static inline int
 132 __iphash_create(const struct ip_set_req_iphash_create *req,
 133                 struct ip_set_iphash *map)
 134 {
 135         map->netmask = req->netmask;
 136
 137         return 0;
 138 }
 139
 140 HASH_CREATE(iphash, ip_set_ip_t)
 141 HASH_DESTROY(iphash)
 142
 143 HASH_FLUSH(iphash, ip_set_ip_t)
 144
 145 static inline void
 146 __iphash_list_header(const struct ip_set_iphash *map,
 147                      struct ip_set_req_iphash_create *header)
 148 {
 149         header->netmask = map->netmask;
 150 }
 151
 152 HASH_LIST_HEADER(iphash)
 153 HASH_LIST_MEMBERS_SIZE(iphash, ip_set_ip_t)
 154 HASH_LIST_MEMBERS(iphash, ip_set_ip_t)
 155
 156 IP_SET_RTYPE(iphash, IPSET_TYPE_IP | IPSET_DATA_SINGLE)
 157
 158 MODULE_LICENSE("GPL");
 159 MODULE_AUTHOR("Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>");
 160 MODULE_DESCRIPTION("iphash type of IP sets");
 161 module_param(limit, int, 0600);
 162 MODULE_PARM_DESC(limit, "maximal number of elements stored in the sets");
 163
 164 REGISTER_MODULE(iphash)