]> git.ipfire.org Git - people/pmueller/ipfire-2.x.git/blame - src/patches/linux-2.6.23.17-ipp2p-0.8.2-pomng.patch
projects / people / pmueller / ipfire-2.x.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Cleanup: remove 2.1 to 2.3 updater
[people/pmueller/ipfire-2.x.git] / src / patches / linux-2.6.23.17-ipp2p-0.8.2-pomng.patch
CommitLineData
4f1b7a27
AF		 1diff -Naur linux-2.6.23.17.org/include/linux/netfilter_ipv4/ipt_ipp2p.h linux-2.6.23.17/include/linux/netfilter_ipv4/ipt_ipp2p.h
2--- linux-2.6.23.17.org/include/linux/netfilter_ipv4/ipt_ipp2p.h 1970-01-01 00:00:00.000000000 +0000
3+++ linux-2.6.23.17/include/linux/netfilter_ipv4/ipt_ipp2p.h 2008-09-22 21:58:41.000000000 +0000
4@@ -0,0 +1,31 @@
5+#ifndef __IPT_IPP2P_H
6+#define __IPT_IPP2P_H
7+#define IPP2P_VERSION "0.8.2-pomng"
8+
9+struct ipt_p2p_info {
10+ int cmd;
11+ int debug;
12+};
13+
14+#endif //__IPT_IPP2P_H
15+
16+#define SHORT_HAND_IPP2P 1 /* --ipp2p switch*/
17+//#define SHORT_HAND_DATA 4 /* --ipp2p-data switch*/
18+#define SHORT_HAND_NONE 5 /* no short hand*/
19+
20+#define IPP2P_EDK (1 << 1)
21+#define IPP2P_DATA_KAZAA (1 << 2)
22+#define IPP2P_DATA_EDK (1 << 3)
23+#define IPP2P_DATA_DC (1 << 4)
24+#define IPP2P_DC (1 << 5)
25+#define IPP2P_DATA_GNU (1 << 6)
26+#define IPP2P_GNU (1 << 7)
27+#define IPP2P_KAZAA (1 << 8)
28+#define IPP2P_BIT (1 << 9)
29+#define IPP2P_APPLE (1 << 10)
30+#define IPP2P_SOUL (1 << 11)
31+#define IPP2P_WINMX (1 << 12)
32+#define IPP2P_ARES (1 << 13)
33+#define IPP2P_MUTE (1 << 14)
34+#define IPP2P_WASTE (1 << 15)
35+#define IPP2P_XDCC (1 << 16)
36diff -Naur linux-2.6.23.17.org/net/ipv4/netfilter/Kconfig linux-2.6.23.17/net/ipv4/netfilter/Kconfig
37--- linux-2.6.23.17.org/net/ipv4/netfilter/Kconfig 2008-02-26 00:14:28.000000000 +0000
38+++ linux-2.6.23.17/net/ipv4/netfilter/Kconfig 2008-09-22 21:58:41.000000000 +0000
39@@ -402,5 +402,15 @@
40 Allows altering the ARP packet payload: source and destination
41 hardware and network addresses.
42
43+config IP_NF_MATCH_IPP2P
44+ tristate 'IPP2P match support'
45+ depends on IP_NF_IPTABLES
46+ help
47+ This option makes possible to match some P2P packets
48+ therefore helps controlling such traffic.
49+
50+ If you want to compile it as a module, say M here and read
51+ <file:Documentation/modules.txt>. If unsure, say `N'.
52+
53 endmenu
54
55diff -Naur linux-2.6.23.17.org/net/ipv4/netfilter/Makefile linux-2.6.23.17/net/ipv4/netfilter/Makefile
56--- linux-2.6.23.17.org/net/ipv4/netfilter/Makefile 2008-02-26 00:14:28.000000000 +0000
57+++ linux-2.6.23.17/net/ipv4/netfilter/Makefile 2008-09-22 21:58:41.000000000 +0000
58@@ -45,6 +45,7 @@
59 obj-$(CONFIG_IP_NF_MATCH_OWNER) += ipt_owner.o
60 obj-$(CONFIG_IP_NF_MATCH_TOS) += ipt_tos.o
61 obj-$(CONFIG_IP_NF_MATCH_RECENT) += ipt_recent.o
62+obj-$(CONFIG_IP_NF_MATCH_IPP2P) += ipt_ipp2p.o
63 obj-$(CONFIG_IP_NF_MATCH_ECN) += ipt_ecn.o
64 obj-$(CONFIG_IP_NF_MATCH_AH) += ipt_ah.o
65 obj-$(CONFIG_IP_NF_MATCH_TTL) += ipt_ttl.o
66diff -Naur linux-2.6.23.17.org/net/ipv4/netfilter/ipt_ipp2p.c linux-2.6.23.17/net/ipv4/netfilter/ipt_ipp2p.c
67--- linux-2.6.23.17.org/net/ipv4/netfilter/ipt_ipp2p.c 1970-01-01 00:00:00.000000000 +0000
68+++ linux-2.6.23.17/net/ipv4/netfilter/ipt_ipp2p.c 2008-09-22 21:58:41.000000000 +0000
69@@ -0,0 +1,911 @@
70+#if defined(MODVERSIONS)
71+#include <linux/modversions.h>
72+#endif
73+#include <linux/module.h>
74+#include <linux/version.h>
75+#include <linux/netfilter_ipv4/ip_tables.h>
76+#include <linux/netfilter_ipv4/ipt_ipp2p.h>
77+#include <net/tcp.h>
78+#include <net/udp.h>
79+
80+#define get_u8(X,O) (*(__u8 *)(X + O))
81+#define get_u16(X,O) (*(__u16 *)(X + O))
82+#define get_u32(X,O) (*(__u32 *)(X + O))
83+
84+MODULE_AUTHOR("Eicke Friedrich/Klaus Degner <ipp2p@ipp2p.org>");
85+MODULE_DESCRIPTION("An extension to iptables to identify P2P traffic.");
86+MODULE_LICENSE("GPL");
87+
88+
89+/*Search for UDP eDonkey/eMule/Kad commands*/
90+int
91+udp_search_edk (unsigned char *haystack, int packet_len)
92+{
93+ unsigned char *t = haystack;
94+ t += 8;
95+
96+ switch (t[0]) {
97+ case 0xe3:
98+ { /*edonkey*/
99+ switch (t[1])
100+ {
101+ /* client -> server status request */
102+ case 0x96:
103+ if (packet_len == 14) return ((IPP2P_EDK * 100) + 50);
104+ break;
105+ /* server -> client status request */
106+ case 0x97: if (packet_len == 42) return ((IPP2P_EDK * 100) + 51);
107+ break;
108+ /* server description request */
109+ /* e3 2a ff f0 .. | size == 6 */
110+ case 0xa2: if ( (packet_len == 14) && ( get_u16(t,2) == __constant_htons(0xfff0) ) ) return ((IPP2P_EDK * 100) + 52);
111+ break;
112+ /* server description response */
113+ /* e3 a3 ff f0 .. | size > 40 && size < 200 */
114+ //case 0xa3: return ((IPP2P_EDK * 100) + 53);
115+ // break;
116+ case 0x9a: if (packet_len==26) return ((IPP2P_EDK * 100) + 54);
117+ break;
118+
119+ case 0x92: if (packet_len==18) return ((IPP2P_EDK * 100) + 55);
120+ break;
121+ }
122+ break;
123+ }
124+ case 0xe4:
125+ {
126+ switch (t[1])
127+ {
128+ /* e4 20 .. | size == 43 */
129+ case 0x20: if ((packet_len == 43) && (t[2] != 0x00) && (t[34] != 0x00)) return ((IPP2P_EDK * 100) + 60);
130+ break;
131+ /* e4 00 .. 00 | size == 35 ? */
132+ case 0x00: if ((packet_len == 35) && (t[26] == 0x00)) return ((IPP2P_EDK * 100) + 61);
133+ break;
134+ /* e4 10 .. 00 | size == 35 ? */
135+ case 0x10: if ((packet_len == 35) && (t[26] == 0x00)) return ((IPP2P_EDK * 100) + 62);
136+ break;
137+ /* e4 18 .. 00 | size == 35 ? */
138+ case 0x18: if ((packet_len == 35) && (t[26] == 0x00)) return ((IPP2P_EDK * 100) + 63);
139+ break;
140+ /* e4 52 .. | size = 44 */
141+ case 0x52: if (packet_len == 44 ) return ((IPP2P_EDK * 100) + 64);
142+ break;
143+ /* e4 58 .. | size == 6 */
144+ case 0x58: if (packet_len == 14 ) return ((IPP2P_EDK * 100) + 65);
145+ break;
146+ /* e4 59 .. | size == 2 */
147+ case 0x59: if (packet_len == 10 )return ((IPP2P_EDK * 100) + 66);
148+ break;
149+ /* e4 28 .. | packet_len == 52,77,102,127... */
150+ case 0x28: if (((packet_len-52) % 25) == 0) return ((IPP2P_EDK * 100) + 67);
151+ break;
152+ /* e4 50 xx xx | size == 4 */
153+ case 0x50: if (packet_len == 12) return ((IPP2P_EDK * 100) + 68);
154+ break;
155+ /* e4 40 xx xx | size == 48 */
156+ case 0x40: if (packet_len == 56) return ((IPP2P_EDK * 100) + 69);
157+ break;
158+ }
159+ break;
160+ }
161+ } /* end of switch (t[0]) */
162+ return 0;
163+}/*udp_search_edk*/
164+
165+
166+/*Search for UDP Gnutella commands*/
167+int
168+udp_search_gnu (unsigned char *haystack, int packet_len)
169+{
170+ unsigned char *t = haystack;
171+ t += 8;
172+
173+ if (memcmp(t, "GND", 3) == 0) return ((IPP2P_GNU * 100) + 51);
174+ if (memcmp(t, "GNUTELLA ", 9) == 0) return ((IPP2P_GNU * 100) + 52);
175+ return 0;
176+}/*udp_search_gnu*/
177+
178+
179+/*Search for UDP KaZaA commands*/
180+int
181+udp_search_kazaa (unsigned char *haystack, int packet_len)
182+{
183+ unsigned char *t = haystack;
184+
185+ if (t[packet_len-1] == 0x00){
186+ t += (packet_len - 6);
187+ if (memcmp(t, "KaZaA", 5) == 0) return (IPP2P_KAZAA * 100 +50);
188+ }
189+
190+ return 0;
191+}/*udp_search_kazaa*/
192+
193+/*Search for UDP DirectConnect commands*/
194+int
195+udp_search_directconnect (unsigned char *haystack, int packet_len)
196+{
197+ unsigned char *t = haystack;
198+ if ((*(t + 8) == 0x24) && (*(t + packet_len - 1) == 0x7c)) {
199+ t+=8;
200+ if (memcmp(t, "SR ", 3) == 0) return ((IPP2P_DC * 100) + 60);
201+ if (memcmp(t, "Ping ", 5) == 0) return ((IPP2P_DC * 100) + 61);
202+ }
203+ return 0;
204+}/*udp_search_directconnect*/
205+
206+
207+
208+/*Search for UDP BitTorrent commands*/
209+int
210+udp_search_bit (unsigned char *haystack, int packet_len)
211+{
212+ switch(packet_len)
213+ {
214+ case 24:
215+ /* ^ 00 00 04 17 27 10 19 80 */
216+ if ((ntohl(get_u32(haystack, 8)) == 0x00000417) && (ntohl(get_u32(haystack, 12)) == 0x27101980))
217+ return (IPP2P_BIT * 100 + 50);
218+ break;
219+ case 44:
220+ if (get_u32(haystack, 16) == __constant_htonl(0x00000400) && get_u32(haystack, 36) == __constant_htonl(0x00000104))
221+ return (IPP2P_BIT * 100 + 51);
222+ if (get_u32(haystack, 16) == __constant_htonl(0x00000400))
223+ return (IPP2P_BIT * 100 + 61);
224+ break;
225+ case 65:
226+ if (get_u32(haystack, 16) == __constant_htonl(0x00000404) && get_u32(haystack, 36) == __constant_htonl(0x00000104))
227+ return (IPP2P_BIT * 100 + 52);
228+ if (get_u32(haystack, 16) == __constant_htonl(0x00000404))
229+ return (IPP2P_BIT * 100 + 62);
230+ break;
231+ case 67:
232+ if (get_u32(haystack, 16) == __constant_htonl(0x00000406) && get_u32(haystack, 36) == __constant_htonl(0x00000104))
233+ return (IPP2P_BIT * 100 + 53);
234+ if (get_u32(haystack, 16) == __constant_htonl(0x00000406))
235+ return (IPP2P_BIT * 100 + 63);
236+ break;
237+ case 211:
238+ if (get_u32(haystack, 8) == __constant_htonl(0x00000405))
239+ return (IPP2P_BIT * 100 + 54);
240+ break;
241+ case 29:
242+ if ((get_u32(haystack, 8) == __constant_htonl(0x00000401)))
243+ return (IPP2P_BIT * 100 + 55);
244+ break;
245+ case 52:
246+ if (get_u32(haystack,8) == __constant_htonl(0x00000827) &&
247+ get_u32(haystack,12) == __constant_htonl(0x37502950))
248+ return (IPP2P_BIT * 100 + 80);
249+ break;
250+ default:
251+ /* this packet does not have a constant size */
252+ if (packet_len >= 40 && get_u32(haystack, 16) == __constant_htonl(0x00000402) && get_u32(haystack, 36) == __constant_htonl(0x00000104))
253+ return (IPP2P_BIT * 100 + 56);
254+ break;
255+ }
256+
257+ /* some extra-bitcomet rules:
258+ * "d1:" [a|r] "d2:id20:"
259+ */
260+ if (packet_len > 30 && get_u8(haystack, 8) == 'd' && get_u8(haystack, 9) == '1' && get_u8(haystack, 10) == ':' )
261+ {
262+ if (get_u8(haystack, 11) == 'a' || get_u8(haystack, 11) == 'r')
263+ {
264+ if (memcmp(haystack+12,"d2:id20:",8)==0)
265+ return (IPP2P_BIT * 100 + 57);
266+ }
267+ }
268+
269+#if 0
270+ /* bitlord rules */
271+ /* packetlen must be bigger than 40 */
272+ /* first 4 bytes are zero */
273+ if (packet_len > 40 && get_u32(haystack, 8) == 0x00000000)
274+ {
275+ /* first rule: 00 00 00 00 01 00 00 xx xx xx xx 00 00 00 00*/
276+ if (get_u32(haystack, 12) == 0x00000000 &&
277+ get_u32(haystack, 16) == 0x00010000 &&
278+ get_u32(haystack, 24) == 0x00000000 )
279+ return (IPP2P_BIT * 100 + 71);
280+
281+ /* 00 01 00 00 0d 00 00 xx xx xx xx 00 00 00 00*/
282+ if (get_u32(haystack, 12) == 0x00000001 &&
283+ get_u32(haystack, 16) == 0x000d0000 &&
284+ get_u32(haystack, 24) == 0x00000000 )
285+ return (IPP2P_BIT * 100 + 71);
286+
287+
288+ }
289+#endif
290+
291+ return 0;
292+}/*udp_search_bit*/
293+
294+
295+
296+/*Search for Ares commands*/
297+//#define IPP2P_DEBUG_ARES
298+int
299+search_ares (const unsigned char *payload, const u16 plen)
300+//int search_ares (unsigned char *haystack, int packet_len, int head_len)
301+{
302+// const unsigned char *t = haystack + head_len;
303+
304+ /* all ares packets start with */
305+ if (payload[1] == 0 && (plen - payload[0]) == 3)
306+ {
307+ switch (payload[2])
308+ {
309+ case 0x5a:
310+ /* ares connect */
311+ if ( plen == 6 && payload[5] == 0x05 ) return ((IPP2P_ARES * 100) + 1);
312+ break;
313+ case 0x09:
314+ /* ares search, min 3 chars --> 14 bytes
315+ * lets define a search can be up to 30 chars --> max 34 bytes
316+ */
317+ if ( plen >= 14 && plen <= 34 ) return ((IPP2P_ARES * 100) + 1);
318+ break;
319+#ifdef IPP2P_DEBUG_ARES
320+ default:
321+ printk(KERN_DEBUG "Unknown Ares command %x recognized, len: %u \n", (unsigned int) payload[2],plen);
322+#endif /* IPP2P_DEBUG_ARES */
323+ }
324+ }
325+
326+#if 0
327+ /* found connect packet: 03 00 5a 04 03 05 */
328+ /* new version ares 1.8: 03 00 5a xx xx 05 */
329+ if ((plen) == 6){ /* possible connect command*/
330+ if ((payload[0] == 0x03) && (payload[1] == 0x00) && (payload[2] == 0x5a) && (payload[5] == 0x05))
331+ return ((IPP2P_ARES * 100) + 1);
332+ }
333+ if ((plen) == 60){ /* possible download command*/
334+ if ((payload[59] == 0x0a) && (payload[58] == 0x0a)){
335+ if (memcmp(t, "PUSH SHA1:", 10) == 0) /* found download command */
336+ return ((IPP2P_ARES * 100) + 2);
337+ }
338+ }
339+#endif
340+
341+ return 0;
342+} /*search_ares*/
343+
344+/*Search for SoulSeek commands*/
345+int
346+search_soul (const unsigned char *payload, const u16 plen)
347+{
348+//#define IPP2P_DEBUG_SOUL
349+ /* match: xx xx xx xx | xx = sizeof(payload) - 4 */
350+ if (get_u32(payload, 0) == (plen - 4)){
351+ const __u32 m=get_u32(payload, 4);
352+ /* match 00 yy yy 00, yy can be everything */
353+ if ( get_u8(payload, 4) == 0x00 && get_u8(payload, 7) == 0x00 )
354+ {
355+#ifdef IPP2P_DEBUG_SOUL
356+ printk(KERN_DEBUG "0: Soulseek command 0x%x recognized\n",get_u32(payload, 4));
357+#endif /* IPP2P_DEBUG_SOUL */
358+ return ((IPP2P_SOUL * 100) + 1);
359+ }
360+
361+ /* next match: 01 yy 00 00 | yy can be everything */
362+ if ( get_u8(payload, 4) == 0x01 && get_u16(payload, 6) == 0x0000 )
363+ {
364+#ifdef IPP2P_DEBUG_SOUL
365+ printk(KERN_DEBUG "1: Soulseek command 0x%x recognized\n",get_u16(payload, 4));
366+#endif /* IPP2P_DEBUG_SOUL */
367+ return ((IPP2P_SOUL * 100) + 2);
368+ }
369+
370+ /* other soulseek commandos are: 1-5,7,9,13-18,22,23,26,28,35-37,40-46,50,51,60,62-69,91,92,1001 */
371+ /* try to do this in an intelligent way */
372+ /* get all small commandos */
373+ switch(m)
374+ {
375+ case 7:
376+ case 9:
377+ case 22:
378+ case 23:
379+ case 26:
380+ case 28:
381+ case 50:
382+ case 51:
383+ case 60:
384+ case 91:
385+ case 92:
386+ case 1001:
387+#ifdef IPP2P_DEBUG_SOUL
388+ printk(KERN_DEBUG "2: Soulseek command 0x%x recognized\n",get_u16(payload, 4));
389+#endif /* IPP2P_DEBUG_SOUL */
390+ return ((IPP2P_SOUL * 100) + 3);
391+ }
392+
393+ if (m > 0 && m < 6 )
394+ {
395+#ifdef IPP2P_DEBUG_SOUL
396+ printk(KERN_DEBUG "3: Soulseek command 0x%x recognized\n",get_u16(payload, 4));
397+#endif /* IPP2P_DEBUG_SOUL */
398+ return ((IPP2P_SOUL * 100) + 4);
399+ }
400+ if (m > 12 && m < 19 )
401+ {
402+#ifdef IPP2P_DEBUG_SOUL
403+ printk(KERN_DEBUG "4: Soulseek command 0x%x recognized\n",get_u16(payload, 4));
404+#endif /* IPP2P_DEBUG_SOUL */
405+ return ((IPP2P_SOUL * 100) + 5);
406+ }
407+
408+ if (m > 34 && m < 38 )
409+ {
410+#ifdef IPP2P_DEBUG_SOUL
411+ printk(KERN_DEBUG "5: Soulseek command 0x%x recognized\n",get_u16(payload, 4));
412+#endif /* IPP2P_DEBUG_SOUL */
413+ return ((IPP2P_SOUL * 100) + 6);
414+ }
415+
416+ if (m > 39 && m < 47 )
417+ {
418+#ifdef IPP2P_DEBUG_SOUL
419+ printk(KERN_DEBUG "6: Soulseek command 0x%x recognized\n",get_u16(payload, 4));
420+#endif /* IPP2P_DEBUG_SOUL */
421+ return ((IPP2P_SOUL * 100) + 7);
422+ }
423+
424+ if (m > 61 && m < 70 )
425+ {
426+#ifdef IPP2P_DEBUG_SOUL
427+ printk(KERN_DEBUG "7: Soulseek command 0x%x recognized\n",get_u16(payload, 4));
428+#endif /* IPP2P_DEBUG_SOUL */
429+ return ((IPP2P_SOUL * 100) + 8);
430+ }
431+
432+#ifdef IPP2P_DEBUG_SOUL
433+ printk(KERN_DEBUG "unknown SOULSEEK command: 0x%x, first 16 bit: 0x%x, first 8 bit: 0x%x ,soulseek ???\n",get_u32(payload, 4),get_u16(payload, 4) >> 16,get_u8(payload, 4) >> 24);
434+#endif /* IPP2P_DEBUG_SOUL */
435+ }
436+
437+ /* match 14 00 00 00 01 yy 00 00 00 STRING(YY) 01 00 00 00 00 46|50 00 00 00 00 */
438+ /* without size at the beginning !!! */
439+ if ( get_u32(payload, 0) == 0x14 && get_u8(payload, 4) == 0x01 )
440+ {
441+ __u32 y=get_u32(payload, 5);
442+ /* we need 19 chars + string */
443+ if ( (y + 19) <= (plen) )
444+ {
445+ const unsigned char *w=payload+9+y;
446+ if (get_u32(w, 0) == 0x01 && ( get_u16(w, 4) == 0x4600 || get_u16(w, 4) == 0x5000) && get_u32(w, 6) == 0x00);
447+#ifdef IPP2P_DEBUG_SOUL
448+ printk(KERN_DEBUG "Soulssek special client command recognized\n");
449+#endif /* IPP2P_DEBUG_SOUL */
450+ return ((IPP2P_SOUL * 100) + 9);
451+ }
452+ }
453+ return 0;
454+}
455+
456+
457+/*Search for WinMX commands*/
458+int
459+search_winmx (const unsigned char *payload, const u16 plen)
460+{
461+//#define IPP2P_DEBUG_WINMX
462+ if (((plen) == 4) && (memcmp(payload, "SEND", 4) == 0)) return ((IPP2P_WINMX * 100) + 1);
463+ if (((plen) == 3) && (memcmp(payload, "GET", 3) == 0)) return ((IPP2P_WINMX * 100) + 2);
464+ //if (packet_len < (head_len + 10)) return 0;
465+ if (plen < 10) return 0;
466+
467+ if ((memcmp(payload, "SEND", 4) == 0) || (memcmp(payload, "GET", 3) == 0)){
468+ u16 c=4;
469+ const u16 end=plen-2;
470+ u8 count=0;
471+ while (c < end)
472+ {
473+ if (payload[c]== 0x20 && payload[c+1] == 0x22)
474+ {
475+ c++;
476+ count++;
477+ if (count>=2) return ((IPP2P_WINMX * 100) + 3);
478+ }
479+ c++;
480+ }
481+ }
482+
483+ if ( plen == 149 && payload[0] == '8' )
484+ {
485+#ifdef IPP2P_DEBUG_WINMX
486+ printk(KERN_INFO "maybe WinMX\n");
487+#endif
488+ if (get_u32(payload,17) == 0 && get_u32(payload,21) == 0 && get_u32(payload,25) == 0 &&
489+// get_u32(payload,33) == __constant_htonl(0x71182b1a) && get_u32(payload,37) == __constant_htonl(0x05050000) &&
490+// get_u32(payload,133) == __constant_htonl(0x31097edf) && get_u32(payload,145) == __constant_htonl(0xdcb8f792))
491+ get_u16(payload,39) == 0 && get_u16(payload,135) == __constant_htons(0x7edf) && get_u16(payload,147) == __constant_htons(0xf792))
492+
493+ {
494+#ifdef IPP2P_DEBUG_WINMX
495+ printk(KERN_INFO "got WinMX\n");
496+#endif
497+ return ((IPP2P_WINMX * 100) + 4);
498+ }
499+ }
500+ return 0;
501+} /*search_winmx*/
502+
503+
504+/*Search for appleJuice commands*/
505+int
506+search_apple (const unsigned char *payload, const u16 plen)
507+{
508+ if ( (plen > 7) && (payload[6] == 0x0d) && (payload[7] == 0x0a) && (memcmp(payload, "ajprot", 6) == 0)) return (IPP2P_APPLE * 100);
509+
510+ return 0;
511+}
512+
513+
514+/*Search for BitTorrent commands*/
515+int
516+search_bittorrent (const unsigned char *payload, const u16 plen)
517+{
518+ if (plen > 20)
519+ {
520+ /* test for match 0x13+"BitTorrent protocol" */
521+ if (payload[0] == 0x13)
522+ {
523+ if (memcmp(payload+1, "BitTorrent protocol", 19) == 0) return (IPP2P_BIT * 100);
524+ }
525+
526+ /* get tracker commandos, all starts with GET /
527+ * then it can follow: scrape| announce
528+ * and then ?hash_info=
529+ */
530+ if (memcmp(payload,"GET /",5) == 0)
531+ {
532+ /* message scrape */
533+ if ( memcmp(payload+5,"scrape?info_hash=",17)==0 ) return (IPP2P_BIT * 100 + 1);
534+ /* message announce */
535+ if ( memcmp(payload+5,"announce?info_hash=",19)==0 ) return (IPP2P_BIT * 100 + 2);
536+ }
537+ }
538+ else
539+ {
540+ /* bitcomet encryptes the first packet, so we have to detect another
541+ * one later in the flow */
542+ /* first try failed, too many missdetections */
543+ //if ( size == 5 && get_u32(t,0) == __constant_htonl(1) && t[4] < 3) return (IPP2P_BIT * 100 + 3);
544+
545+ /* second try: block request packets */
546+ if ( plen == 17 && get_u32(payload,0) == __constant_htonl(0x0d) && payload[4] == 0x06 && get_u32(payload,13) == __constant_htonl(0x4000) ) return (IPP2P_BIT * 100 + 3);
547+ }
548+
549+ return 0;
550+}
551+
552+
553+
554+/*check for Kazaa get command*/
555+int
556+search_kazaa (const unsigned char *payload, const u16 plen)
557+
558+{
559+ if ((payload[plen-2] == 0x0d) && (payload[plen-1] == 0x0a) && memcmp(payload, "GET /.hash=", 11) == 0)
560+ return (IPP2P_DATA_KAZAA * 100);
561+
562+ return 0;
563+}
564+
565+
566+/*check for gnutella get command*/
567+int
568+search_gnu (const unsigned char *payload, const u16 plen)
569+{
570+ if ((payload[plen-2] == 0x0d) && (payload[plen-1] == 0x0a))
571+ {
572+ if (memcmp(payload, "GET /get/", 9) == 0) return ((IPP2P_DATA_GNU * 100) + 1);
573+ if (memcmp(payload, "GET /uri-res/", 13) == 0) return ((IPP2P_DATA_GNU * 100) + 2);
574+ }
575+ return 0;
576+}
577+
578+
579+/*check for gnutella get commands and other typical data*/
580+int
581+search_all_gnu (const unsigned char *payload, const u16 plen)
582+{
583+
584+ if ((payload[plen-2] == 0x0d) && (payload[plen-1] == 0x0a))
585+ {
586+
587+ if (memcmp(payload, "GNUTELLA CONNECT/", 17) == 0) return ((IPP2P_GNU * 100) + 1);
588+ if (memcmp(payload, "GNUTELLA/", 9) == 0) return ((IPP2P_GNU * 100) + 2);
589+
590+
591+ if ((memcmp(payload, "GET /get/", 9) == 0) || (memcmp(payload, "GET /uri-res/", 13) == 0))
592+ {
593+ u16 c=8;
594+ const u16 end=plen-22;
595+ while (c < end) {
596+ if ( payload[c] == 0x0a && payload[c+1] == 0x0d && ((memcmp(&payload[c+2], "X-Gnutella-", 11) == 0) || (memcmp(&payload[c+2], "X-Queue:", 8) == 0)))
597+ return ((IPP2P_GNU * 100) + 3);
598+ c++;
599+ }
600+ }
601+ }
602+ return 0;
603+}
604+
605+
606+/*check for KaZaA download commands and other typical data*/
607+int
608+search_all_kazaa (const unsigned char *payload, const u16 plen)
609+{
610+ if ((payload[plen-2] == 0x0d) && (payload[plen-1] == 0x0a))
611+ {
612+
613+ if (memcmp(payload, "GIVE ", 5) == 0) return ((IPP2P_KAZAA * 100) + 1);
614+
615+ if (memcmp(payload, "GET /", 5) == 0) {
616+ u16 c = 8;
617+ const u16 end=plen-22;
618+ while (c < end) {
619+ if ( payload[c] == 0x0a && payload[c+1] == 0x0d && ((memcmp(&payload[c+2], "X-Kazaa-Username: ", 18) == 0) || (memcmp(&payload[c+2], "User-Agent: PeerEnabler/", 24) == 0)))
620+ return ((IPP2P_KAZAA * 100) + 2);
621+ c++;
622+ }
623+ }
624+ }
625+ return 0;
626+}
627+
628+/*fast check for edonkey file segment transfer command*/
629+int
630+search_edk (const unsigned char *payload, const u16 plen)
631+{
632+ if (payload[0] != 0xe3)
633+ return 0;
634+ else {
635+ if (payload[5] == 0x47)
636+ return (IPP2P_DATA_EDK * 100);
637+ else
638+ return 0;
639+ }
640+}
641+
642+
643+
644+/*intensive but slower search for some edonkey packets including size-check*/
645+int
646+search_all_edk (const unsigned char *payload, const u16 plen)
647+{
648+ if (payload[0] != 0xe3)
649+ return 0;
650+ else {
651+ //t += head_len;
652+ const u16 cmd = get_u16(payload, 1);
653+ if (cmd == (plen - 5)) {
654+ switch (payload[5]) {
655+ case 0x01: return ((IPP2P_EDK * 100) + 1); /*Client: hello or Server:hello*/
656+ case 0x4c: return ((IPP2P_EDK * 100) + 9); /*Client: Hello-Answer*/
657+ }
658+ }
659+ return 0;
660+ }
661+}
662+
663+
664+/*fast check for Direct Connect send command*/
665+int
666+search_dc (const unsigned char *payload, const u16 plen)
667+{
668+
669+ if (payload[0] != 0x24 )
670+ return 0;
671+ else {
672+ if (memcmp(&payload[1], "Send|", 5) == 0)
673+ return (IPP2P_DATA_DC * 100);
674+ else
675+ return 0;
676+ }
677+
678+}
679+
680+
681+/*intensive but slower check for all direct connect packets*/
682+int
683+search_all_dc (const unsigned char *payload, const u16 plen)
684+{
685+// unsigned char *t = haystack;
686+
687+ if (payload[0] == 0x24 && payload[plen-1] == 0x7c)
688+ {
689+ const unsigned char *t=&payload[1];
690+ /* Client-Hub-Protocol */
691+ if (memcmp(t, "Lock ", 5) == 0) return ((IPP2P_DC * 100) + 1);
692+ /* Client-Client-Protocol, some are already recognized by client-hub (like lock) */
693+ if (memcmp(t, "MyNick ", 7) == 0) return ((IPP2P_DC * 100) + 38);
694+ }
695+ return 0;
696+}
697+
698+/*check for mute*/
699+int
700+search_mute (const unsigned char *payload, const u16 plen)
701+{
702+ if ( plen == 209 || plen == 345 || plen == 473 || plen == 609 || plen == 1121 )
703+ {
704+ //printk(KERN_DEBUG "size hit: %u",size);
705+ if (memcmp(payload,"PublicKey: ",11) == 0 )
706+ {
707+ return ((IPP2P_MUTE * 100) + 0);
708+
709+/* if (memcmp(t+size-14,"\x0aEndPublicKey\x0a",14) == 0)
710+ {
711+ printk(KERN_DEBUG "end pubic key hit: %u",size);
712+
713+ }*/
714+ }
715+ }
716+ return 0;
717+}
718+
719+
720+/* check for xdcc */
721+int
722+search_xdcc (const unsigned char *payload, const u16 plen)
723+{
724+ /* search in small packets only */
725+ if (plen > 20 && plen < 200 && payload[plen-1] == 0x0a && payload[plen-2] == 0x0d && memcmp(payload,"PRIVMSG ",8) == 0)
726+ {
727+
728+ u16 x=10;
729+ const u16 end=plen - 13;
730+
731+ /* is seems to be a irc private massage, chedck for xdcc command */
732+ while (x < end)
733+ {
734+ if (payload[x] == ':')
735+ {
736+ if ( memcmp(&payload[x+1],"xdcc send #",11) == 0 )
737+ return ((IPP2P_XDCC * 100) + 0);
738+ }
739+ x++;
740+ }
741+ }
742+ return 0;
743+}
744+
745+/* search for waste */
746+int search_waste(const unsigned char *payload, const u16 plen)
747+{
748+ if ( plen >= 8 && memcmp(payload,"GET.sha1:",9) == 0)
749+ return ((IPP2P_WASTE * 100) + 0);
750+
751+ return 0;
752+}
753+
754+
755+static struct {
756+ int command;
757+ __u8 short_hand; /*for fucntions included in short hands*/
758+ int packet_len;
759+ int (*function_name) (const unsigned char *, const u16);
760+} matchlist[] = {
761+ {IPP2P_EDK,SHORT_HAND_IPP2P,20, &search_all_edk},
762+// {IPP2P_DATA_KAZAA,SHORT_HAND_DATA,200, &search_kazaa},
763+// {IPP2P_DATA_EDK,SHORT_HAND_DATA,60, &search_edk},
764+// {IPP2P_DATA_DC,SHORT_HAND_DATA,26, &search_dc},
765+ {IPP2P_DC,SHORT_HAND_IPP2P,5, search_all_dc},
766+// {IPP2P_DATA_GNU,SHORT_HAND_DATA,40, &search_gnu},
767+ {IPP2P_GNU,SHORT_HAND_IPP2P,5, &search_all_gnu},
768+ {IPP2P_KAZAA,SHORT_HAND_IPP2P,5, &search_all_kazaa},
769+ {IPP2P_BIT,SHORT_HAND_IPP2P,20, &search_bittorrent},
770+ {IPP2P_APPLE,SHORT_HAND_IPP2P,5, &search_apple},
771+ {IPP2P_SOUL,SHORT_HAND_IPP2P,5, &search_soul},
772+ {IPP2P_WINMX,SHORT_HAND_IPP2P,2, &search_winmx},
773+ {IPP2P_ARES,SHORT_HAND_IPP2P,5, &search_ares},
774+ {IPP2P_MUTE,SHORT_HAND_NONE,200, &search_mute},
775+ {IPP2P_WASTE,SHORT_HAND_NONE,5, &search_waste},
776+ {IPP2P_XDCC,SHORT_HAND_NONE,5, &search_xdcc},
777+ {0,0,0,NULL}
778+};
779+
780+
781+static struct {
782+ int command;
783+ __u8 short_hand; /*for fucntions included in short hands*/
784+ int packet_len;
785+ int (*function_name) (unsigned char *, int);
786+} udp_list[] = {
787+ { IPP2P_KAZAA, SHORT_HAND_IPP2P, 14, &udp_search_kazaa},
788+ { IPP2P_BIT, SHORT_HAND_IPP2P, 23, &udp_search_bit},
789+ { IPP2P_GNU, SHORT_HAND_IPP2P, 11, &udp_search_gnu},
790+ { IPP2P_EDK, SHORT_HAND_IPP2P, 9, &udp_search_edk},
791+ { IPP2P_DC, SHORT_HAND_IPP2P, 12, &udp_search_directconnect},
792+ { 0, 0, 0, NULL }
793+};
794+
795+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)
796+static bool
797+#else
798+static int
799+#endif
800+match(const struct sk_buff *skb,
801+ const struct net_device *in,
802+ const struct net_device *out,
803+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,17)
804+ const struct xt_match *match,
805+#endif
806+ const void *matchinfo,
807+ int offset,
808+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
809+ const void *hdr,
810+ u_int16_t datalen,
811+#endif
812+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
813+ unsigned int protoff,
814+#endif
815+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)
816+ bool *hotdrop)
817+#else
818+ bool *hotdrop)
819+#endif
820+{
821+ const struct ipt_p2p_info *info = matchinfo;
822+ unsigned char *haystack;
823+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
824+ struct iphdr *ip = ip_hdr(skb);
825+#else
826+ struct iphdr *ip = skb->nh.iph;
827+#endif
828+ int p2p_result = 0, i = 0;
829+// int head_len;
830+ int hlen = ntohs(ip->tot_len)-(ip->ihl*4); /*hlen = packet-data length*/
831+
832+ /*must not be a fragment*/
833+ if (offset) {
834+ if (info->debug) printk("IPP2P.match: offset found %i \n",offset);
835+ return 0;
836+ }
837+
838+ /*make sure that skb is linear*/
839+ if(skb_is_nonlinear(skb)){
840+ if (info->debug) printk("IPP2P.match: nonlinear skb found\n");
841+ return 0;
842+ }
843+
844+
845+ haystack=(char *)ip+(ip->ihl*4); /*haystack = packet data*/
846+
847+ switch (ip->protocol){
848+ case IPPROTO_TCP: /*what to do with a TCP packet*/
849+ {
850+ struct tcphdr *tcph = (void *) ip + ip->ihl * 4;
851+
852+ if (tcph->fin) return 0; /*if FIN bit is set bail out*/
853+ if (tcph->syn) return 0; /*if SYN bit is set bail out*/
854+ if (tcph->rst) return 0; /*if RST bit is set bail out*/
855+
856+ haystack += tcph->doff * 4; /*get TCP-Header-Size*/
857+ hlen -= tcph->doff * 4;
858+ while (matchlist[i].command) {
859+ if ((((info->cmd & matchlist[i].command) == matchlist[i].command) ||
860+ ((info->cmd & matchlist[i].short_hand) == matchlist[i].short_hand)) &&
861+ (hlen > matchlist[i].packet_len)) {
862+ p2p_result = matchlist[i].function_name(haystack, hlen);
863+ if (p2p_result)
864+ {
865+ if (info->debug) printk("IPP2P.debug:TCP-match: %i from: %u.%u.%u.%u:%i to: %u.%u.%u.%u:%i Length: %i\n",
866+ p2p_result, NIPQUAD(ip->saddr),ntohs(tcph->source), NIPQUAD(ip->daddr),ntohs(tcph->dest),hlen);
867+ return p2p_result;
868+ }
869+ }
870+ i++;
871+ }
872+ return p2p_result;
873+ }
874+
875+ case IPPROTO_UDP: /*what to do with an UDP packet*/
876+ {
877+ struct udphdr *udph = (void *) ip + ip->ihl * 4;
878+
879+ while (udp_list[i].command){
880+ if ((((info->cmd & udp_list[i].command) == udp_list[i].command) ||
881+ ((info->cmd & udp_list[i].short_hand) == udp_list[i].short_hand)) &&
882+ (hlen > udp_list[i].packet_len)) {
883+ p2p_result = udp_list[i].function_name(haystack, hlen);
884+ if (p2p_result){
885+ if (info->debug) printk("IPP2P.debug:UDP-match: %i from: %u.%u.%u.%u:%i to: %u.%u.%u.%u:%i Length: %i\n",
886+ p2p_result, NIPQUAD(ip->saddr),ntohs(udph->source), NIPQUAD(ip->daddr),ntohs(udph->dest),hlen);
887+ return p2p_result;
888+ }
889+ }
890+ i++;
891+ }
892+ return p2p_result;
893+ }
894+
895+ default: return 0;
896+ }
897+}
898+
899+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)
900+static bool
901+#else
902+static int
903+#endif
904+checkentry(const char *tablename,
905+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
906+ const void *ip,
907+#else
908+ const struct ipt_ip *ip,
909+#endif
910+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,17)
911+ const struct xt_match *match,
912+#endif
913+ void *matchinfo,
914+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
915+ unsigned int matchsize,
916+#endif
917+ unsigned int hook_mask)
918+{
919+ /* Must specify -p tcp */
920+/* if (ip->proto != IPPROTO_TCP || (ip->invflags & IPT_INV_PROTO)) {
921+ * printk("ipp2p: Only works on TCP packets, use -p tcp\n");
922+ * return 0;
923+ * }*/
924+ return 1;
925+}
926+
927+
928+
929+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)
930+static struct xt_match ipp2p_match = {
931+#else
932+static struct ipt_match ipp2p_match = {
933+#endif
934+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
935+ { NULL, NULL },
936+ "ipp2p",
937+ &ipp2p_match,
938+ &ipp2p_checkentry,
939+ NULL,
940+ THIS_MODULE
941+#endif
942+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
943+ .name = "ipp2p",
944+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)
945+ .family = AF_INET,
946+#endif
947+ .match = &match,
948+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,17)
949+ .matchsize = sizeof(struct ipt_p2p_info),
950+#endif
951+ .checkentry = &checkentry,
952+ .me = THIS_MODULE,
953+#endif
954+};
955+
956+
957+static int __init init(void)
958+{
959+ printk(KERN_INFO "IPP2P v%s loading\n", IPP2P_VERSION);
960+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)
961+ return xt_register_match(&ipp2p_match);
962+#else
963+ return ipt_register_match(&ipp2p_match);
964+#endif
965+}
966+
967+static void __exit fini(void)
968+{
969+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)
970+ xt_unregister_match(&ipp2p_match);
971+#else
972+ ipt_unregister_match(&ipp2p_match);
973+#endif
974+ printk(KERN_INFO "IPP2P v%s unloaded\n", IPP2P_VERSION);
975+}
976+
977+module_init(init);
978+module_exit(fini);
979+
980+
Peter's tree of IPFire 2.x