关于Linux下每IP的NAT Session数限制的问题

Hi again,

Jan Du Caju wrote:
> >  Ing. CIP Alejandro Celi Mariategui wrote:
> >
> >  (Sorry, but my english is very bad)
> >  Hi,
> >  I compile with p-o-m the server kernel with IPLIMIT Patch by Gerd
> >  Knorr
> >  [1]
> >  It work fine, i can limit ex: max 10 TCP connections on the server,
> >  but i want to limit the UDP connections to 10 (max).
> >  How I can do it?

>    This week I made a updlimit patch (shameless copy of iplimit ;-)
>    I will post it this afternoon/evening when I have more time (and
>    a cross post to the netfilter-devel list. Maybe they like it)

In attachment you will find:
udplimit.patch
udplimit.patch.config.in
udplimit.patch.configure.help
udplimit.patch.help
udplimit.patch.makefile

put those under /base/ directory

in the directory you run: ./runme base
(don't forget to select udplimit ;-)

recompile your kernel (with Connections/UDP limit match support
CONFIG_IP_NF_MATCH_UDPLIMIT ;-)

Place the other file attachment (libipt_udplimit.c) in the directory
/extensions/

in this directory you will also find the file Makefile where you add
udplimit just after iplimit

recompile iptables

Hope this helps (it works for me :-)

Greetz,
Jan.
--------------------------------------------- KULeuvenNet -----

1. diff -urN -x *~ -x [Cc]onfig.* -x Makefile
   
2. vanilla-2.4.21-pre4/net/ipv4/netfilter/ipt_udplimit.c
   
3. linux-2.4.21-pre4/net/ipv4/netfilter/ipt_udplimit.c
   
4. --- vanilla-2.4.21-pre4/net/ipv4/netfilter/ipt_udplimit.c       Fri Feb 21
   
5. 17:20:55 2003
   
6. +++ linux-2.4.21-pre4/net/ipv4/netfilter/ipt_udplimit.c Fri Feb 21 17:17:38 2003
   
7. @@ -0,0 +1,215 @@
   
8. +/*
   
9. + * netfilter module to limit the number of parallel udp
   
10. + * connections per IP address.
    
11. + * Jan Du Caju
    
12. + *
    
13. + * based on ...
    
14. + * iplimit (in fact a shameless copy ;-)
    
15. + *   (c) 2000 Gerd Knorr
    
16. + *   Nov 2002: Martin Bene :
    
17. + *             only ignore TIME_WAIT or gone connections
    
18. + *
    
19. + *
    
20. + * Kernel module to match connection tracking information.
    
21. + * GPL (C) 1999  Rusty Russell (rusty@xxxxxxxxxxxxxxx).
    
22. + */
    
23. +#include
    
24. +#include
    
25. +#include
    
26. +#include
    
27. +#include
    
28. +#include
    
29. +#include
    
30. +
    
31. +#define DEBUG 0
    
32. +
    
33. +MODULE_LICENSE("GPL");
    
34. +
    
35. +/* we'll save the tuples of all connections we care about */
    
36. +struct ipt_iplimit_conn
    
37. +{
    
38. +        struct list_head list;
    
39. +       struct ip_conntrack_tuple tuple;
    
40. +};
    
41. +
    
42. +struct ipt_iplimit_data {
    
43. +       spinlock_t lock;
    
44. +       struct list_head iphash[256];
    
45. +};
    
46. +
    
47. +static int ipt_iphash(u_int32_t addr)
    
48. +{
    
49. +       int hash;
    
50. +
    
51. +       hash  =  addr        & 0xff;
    
52. +       hash ^= (addr >>  8) & 0xff;
    
53. +       hash ^= (addr >> 16) & 0xff;
    
54. +       hash ^= (addr >> 24) & 0xff;
    
55. +       return hash;
    
56. +}
    
57. +
    
58. +static int count_them(struct ipt_iplimit_data *data,
    
59. +                     u_int32_t addr, u_int32_t mask,
    
60. +                     struct ip_conntrack *ct)
    
61. +{
    
62. +       int addit = 1, matches = 0;
    
63. +       struct ip_conntrack_tuple tuple;
    
64. +       struct ip_conntrack_tuple_hash *found;
    
65. +       struct ipt_iplimit_conn *conn;
    
66. +       struct list_head *hash,*lh;
    
67. +
    
68. +       spin_lock(&data->lock);
    
69. +       tuple = ct->tuplehash[0].tuple;
    
70. +       hash = &data->iphash[ipt_iphash(addr & mask)];
    
71. +
    
72. +       /* check the saved connections */
    
73. +       for (lh = hash->next; lh != hash; lh = lh->next) {
    
74. +               conn = list_entry(lh,struct ipt_iplimit_conn,list);
    
75. +               found = ip_conntrack_find_get(&conn->tuple,ct);
    
76. +               if (0 == memcmp(&conn->tuple,&tuple,sizeof(tuple)) &&
    
77. +                   found != NULL) {
    
78. +                       addit = 0;
    
79. +               }
    
80. +#if DEBUG
    
81. +               printk("ipt_udplimit [%d]: src=%u.%u.%u.%u:%d
    
82. dst=%u.%u.%u.%u:%d\n",
    
83. +                      ipt_iphash(addr & mask),
    
84. +                      NIPQUAD(conn->tuple.src.ip),
    
85. ntohs(conn->tuple.src.u.udp.port),
    
86. +                      NIPQUAD(conn->tuple.dst.ip),
    
87. ntohs(conn->tuple.dst.u.udp.port));
    
88. +#endif
    
89. +               if (NULL == found) {
    
90. +                       /* this one is gone */
    
91. +                       lh = lh->prev;
    
92. +                       list_del(lh->next);
    
93. +                       kfree(conn);
    
94. +                       continue;
    
95. +               }
    
96. +               if ((addr & mask) == (conn->tuple.src.ip & mask)) {
    
97. +                       /* same source IP address -> be counted! */
    
98. +                       matches++;
    
99. +               }
    
100. +               nf_conntrack_put(&found->ctrack->infos[0]);
     
101. +       }
     
102. +       if (addit) {
     
103. +               /* save the new connection in our list */
     
104. +#if DEBUG
     
105. +               printk("ipt_udplimit [%d]: src=%u.%u.%u.%u:%d
     
106. dst=%u.%u.%u.%u:%d new\n",
     
107. +                      ipt_iphash(addr & mask),
     
108. +                      NIPQUAD(tuple.src.ip), ntohs(tuple.src.u.tcp.port),
     
109. +                      NIPQUAD(tuple.dst.ip), ntohs(tuple.dst.u.tcp.port));
     
110. +#endif
     
111. +               conn = kmalloc(sizeof(*conn),GFP_ATOMIC);
     
112. +               if (NULL == conn)
     
113. +                       return -1;
     
114. +               memset(conn,0,sizeof(*conn));
     
115. +               INIT_LIST_HEAD(&conn->list);
     
116. +               conn->tuple = tuple;
     
117. +               list_add(&conn->list,hash);
     
118. +               matches++;
     
119. +       }
     
120. +       spin_unlock(&data->lock);
     
121. +       return matches;
     
122. +}
     
123. +
     
124. +static int
     
125. +match(const struct sk_buff *skb,
     
126. +      const struct net_device *in,
     
127. +      const struct net_device *out,
     
128. +      const void *matchinfo,
     
129. +      int offset,
     
130. +      const void *hdr,
     
131. +      u_int16_t datalen,
     
132. +      int *hotdrop)
     
133. +{
     
134. +       const struct ipt_iplimit_info *info = matchinfo;
     
135. +       int connections, match;
     
136. +       struct ip_conntrack *ct;
     
137. +       enum ip_conntrack_info ctinfo;
     
138. +
     
139. +       ct = ip_conntrack_get((struct sk_buff *)skb, &ctinfo);
     
140. +       if (NULL == ct) {
     
141. +               printk("ipt_udplimit: Oops: invalid ct state ?\n");
     
142. +               *hotdrop = 1;
     
143. +               return 0;
     
144. +       }
     
145. +       connections = count_them(info->data,skb->nh.iph->saddr,info->mask,ct);
     
146. +       if (-1 == connections) {
     
147. +               printk("ipt_udplimit: Hmm, kmalloc failed :-(\n");
     
148. +               *hotdrop = 1; /* let's free some memory :-) */
     
149. +               return 0;
     
150. +       }
     
151. +        match = (info->inverse) ? (connections <= info->limit) : (connections
     
152. > info->limit);
     
153. +#if DEBUG
     
154. +       printk("ipt_udplimit: src=%u.%u.%u.%u mask=%u.%u.%u.%u "
     
155. +              "connections=%d limit=%d match=%s\n",
     
156. +              NIPQUAD(skb->nh.iph->saddr), NIPQUAD(info->mask),
     
157. +              connections, info->limit, match ? "yes" : "no");
     
158. +#endif
     
159. +
     
160. +       return match;
     
161. +}
     
162. +
     
163. +static int check(const char *tablename,
     
164. +                const struct ipt_ip *ip,
     
165. +                void *matchinfo,
     
166. +                unsigned int matchsize,
     
167. +                unsigned int hook_mask)
     
168. +{
     
169. +       struct ipt_iplimit_info *info = matchinfo;
     
170. +       int i;
     
171. +
     
172. +       /* verify size */
     
173. +       if (matchsize != IPT_ALIGN(sizeof(struct ipt_iplimit_info)))
     
174. +               return 0;
     
175. +
     
176. +       /* refuse anything but udp */
     
177. +       if (ip->proto != IPPROTO_UDP)
     
178. +               return 0;
     
179. +
     
180. +       /* init private data */
     
181. +       info->data = kmalloc(sizeof(struct ipt_iplimit_data),GFP_KERNEL);
     
182. +       spin_lock_init(&(info->data->lock));
     
183. +       for (i = 0; i < 256; i++)
     
184. +               INIT_LIST_HEAD(&(info->data->iphash));
     
185. +      
     
186. +       return 1;
     
187. +}
     
188. +
     
189. +static void destroy(void *matchinfo, unsigned int matchinfosize)
     
190. +{
     
191. +       struct ipt_iplimit_info *info = matchinfo;
     
192. +       struct ipt_iplimit_conn *conn;
     
193. +       struct list_head *hash;
     
194. +       int i;
     
195. +
     
196. +       /* cleanup */
     
197. +       for (i = 0; i < 256; i++) {
     
198. +               hash = &(info->data->iphash);
     
199. +               while (hash != hash->next) {
     
200. +                       conn = list_entry(hash->next,struct
     
201. ipt_iplimit_conn,list);
     
202. +                       list_del(hash->next);
     
203. +                       kfree(conn);
     
204. +               }
     
205. +       }
     
206. +       kfree(info->data);
     
207. +}
     
208. +
     
209. +static struct ipt_match udplimit_match
     
210. += { { NULL, NULL }, "udplimit", &match, &check, &destroy, THIS_MODULE };
     
211. +
     
212. +static int __init init(void)
     
213. +{
     
214. +       /* NULL if ip_conntrack not a module */
     
215. +       if (ip_conntrack_module)
     
216. +               __MOD_INC_USE_COUNT(ip_conntrack_module);
     
217. +       return ipt_register_match(&udplimit_match);
     
218. +}
     
219. +
     
220. +static void __exit fini(void)
     
221. +{
     
222. +       ipt_unregister_match(&udplimit_match);
     
223. +       if (ip_conntrack_module)
     
224. +               __MOD_DEC_USE_COUNT(ip_conntrack_module);
     
225. +}
     
226. +
     
227. +module_init(init);
     
228. +module_exit(fini);
     
229. 
     
230.     dep_tristate '  Connection state match support' CONFIG_IP_NF_MATCH_STATE
     
231. $CONFIG_IP_NF_CONNTRACK $CONFIG_IP_NF_IPTABLES
     
232.     dep_tristate '  Connections/UDP limit match support'
     
233. CONFIG_IP_NF_MATCH_UDPLIMIT $CONFIG_IP_NF_IPTABLES
     
234. 
     
235. obj-$(CONFIG_IP_NF_MATCH_STATE) += ipt_state.o
     
236. obj-$(CONFIG_IP_NF_MATCH_UDPLIMIT) += ipt_udplimit.o
     
237. 
     
238. Author: Gerd Knorr
     
239.         Jan Du Caju (I just made a shameless copy
     
240.         of iplimit of Gerd Knorr ;-)
     
241. Status: ItWorksForMe[tm]
     
242. 
     
243. This adds CONFIG_IP_NF_MATCH_UDPLIMIT match allows you to restrict the
     
244. number of parallel UDP connections to a server per client IP address
     
245. (or address block).
     
246. 
     
247. Examples:
     
248. 
     
249. # allow 5 udp connections per client host
     
250. iptables -p udp -m udplimit --udplimit-above 5 -j REJECT
     
251. 
     
252. # you can also match the other way around:
     
253. iptables -p udp -m udplimit ! --udplimit-above 5 -j ACCEPT
     
254. 
     
255. # limit the nr of parallel http requests to 16 per class C sized
     
256. # network (24 bit netmask)
     
257. iptables -p udp --dport 161 -m udplimit --udplimit-above 16             \
     
258.         --iplimit-mask 24 -j REJECT
     
259. 
     
260. CONFIG_IP_NF_MATCH_STATE
     
261. Connections/UDP limit match support
     
262. CONFIG_IP_NF_MATCH_UDPLIMIT
     
263.   This match allows you to restrict the number of parallel UDP
     
264.   connections to a server per client IP address (or address block).
     
265. 
     
266.   If you want to compile it as a module, say M here and read
     
267.   Documentation/modules.txt.  If unsure, say `N'.
     
268. 
     
269. /* Shared library add-on to iptables to add state tracking support. */
     
270. #include
     
271. #include
     
272. #include
     
273. #include
     
274. #include
     
275. #include
     
276. #include
     
277. #include
     
278. #include
     
279. 
     
280. /* Function which prints out usage message. */
     
281. static void
     
282. help(void)
     
283. {
     
284.         printf(
     
285. "udplimit v%s options:\n"
     
286. "[!] --udplimit-above n         match if the number of existing udp connections
     
287. is (not) above n\n"
     
288. " --udplimit-mask n             group hosts using mask\n"
     
289. "\n", IPTABLES_VERSION);
     
290. }
     
291. 
     
292. static struct option opts[] = {
     
293.         { "udplimit-above", 1, 0, '1' },
     
294.         { "udplimit-mask",  1, 0, '2' },
     
295.         {0}
     
296. };
     
297. 
     
298. /* Initialize the match. */
     
299. static void
     
300. init(struct ipt_entry_match *m, unsigned int *nfcache)
     
301. {
     
302.         /* Can't cache this */
     
303.         *nfcache |= NFC_UNKNOWN;
     
304. }
     
305. 
     
306. /* Function which parses command options; returns true if it
     
307.    ate an option */
     
308. static int
     
309. parse(int c, char **argv, int invert, unsigned int *flags,
     
310.       const struct ipt_entry *entry,
     
311.       unsigned int *nfcache,
     
312.       struct ipt_entry_match **match)
     
313. {
     
314.         struct ipt_iplimit_info *info = (struct
     
315. ipt_iplimit_info*)(*match)->data;
     
316. 
     
317.         if (0 == (*flags & 2)) {
     
318.                 /* set default mask unless we've already seen a mask option */
     
319.                 info->mask = htonl(0xFFFFFFFF);
     
320.         }
     
321. 
     
322.         switch (c) {
     
323.         case '1':
     
324.                 check_inverse(optarg, &invert, &optind, 0);
     
325.                 info->limit = atoi(argv[optind-1]);
     
326.                 info->inverse = invert;
     
327.                 *flags |= 1;
     
328.                 break;
     
329. 
     
330.         case '2':
     
331.                 info->mask = htonl(0xFFFFFFFF << (32 - atoi(argv[optind-1])));
     
332.                 *flags |= 2;
     
333.                 break;
     
334. 
     
335.         default:
     
336.                 return 0;
     
337.         }
     
338. 
     
339.         return 1;
     
340. }
     
341. 
     
342. /* Final check */
     
343. static void final_check(unsigned int flags)
     
344. {
     
345.         if (!flags & 1)
     
346.                 exit_error(PARAMETER_PROBLEM, "You must specify
     
347. `--udplimit-above'");
     
348. }
     
349. 
     
350. static int
     
351. count_bits(u_int32_t mask)
     
352. {
     
353.         int i, bits;
     
354. 
     
355.         for (bits = 0, i = 31; i >= 0; i--) {
     
356.                 if (mask & htonl((u_int32_t)1 << i)) {
     
357.                         bits++;
     
358.                         continue;
     
359.                 }
     
360.                 break;
     
361.         }
     
362.         return bits;
     
363. }
     
364. 
     
365. /* Prints out the matchinfo. */
     
366. static void
     
367. print(const struct ipt_ip *ip,
     
368.       const struct ipt_entry_match *match,
     
369.       int numeric)
     
370. {
     
371.         struct ipt_iplimit_info *info = (struct ipt_iplimit_info*)match->data;
     
372. 
     
373.         printf("#conn/%d %s %d ", count_bits(info->mask),
     
374.                info->inverse ? "<" : ">", info->limit);
     
375. }
     
376. 
     
377. /* Saves the matchinfo in parsable form to stdout. */
     
378. static void save(const struct ipt_ip *ip, const struct ipt_entry_match *match)
     
379. {
     
380.         struct ipt_iplimit_info *info = (struct ipt_iplimit_info*)match->data;
     
381. 
     
382.         printf("%s--udplimit-above %d ",info->inverse ? "! " : "",info->limit);
     
383.         printf("--udplimit-mask %d ",count_bits(info->mask));
     
384. }
     
385. 
     
386. static struct iptables_match udplimit = {
     
387.         name:           "udplimit",
     
388.         version:        IPTABLES_VERSION,
     
389.         size:           IPT_ALIGN(sizeof(struct ipt_iplimit_info)),
     
390.         userspacesize:  offsetof(struct ipt_iplimit_info,data),
     
391.         help:           help,
     
392.         init:           init,
     
393.         parse:          parse,
     
394.         final_check:    final_check,
     
395.         print:          print,
     
396.         save:           save,
     
397.         extra_opts:     opts
     
398. };
     
399. 
     
400. void _init(void)
     
401. {
     
402.         register_match(&udplimit);
     
403. }