Changeset 3463


Ignore:
Timestamp:
2006-03-23T15:40:54+01:00 (11 years ago)
Author:
nbd
Message:

update ipp2p to 0.8.1rc1, add it to 2.6 as well

Location:
trunk/openwrt
Files:
1 added
4 edited
2 moved

Legend:

Unmodified
Added
Removed
  • trunk/openwrt/package/iptables/patches/01-ipp2p-0.8.1rc1.patch

    r3443 r3463  
    1 diff -urN iptables-1.2.11.old/extensions/libipt_ipp2p.c iptables-1.2.11/extensions/libipt_ipp2p.c 
    2 --- iptables-1.2.11.old/extensions/libipt_ipp2p.c       1970-01-01 01:00:00.000000000 +0100 
    3 +++ iptables-1.2.11/extensions/libipt_ipp2p.c   2005-03-12 00:50:27.000000000 +0100 
    4 @@ -0,0 +1,455 @@ 
     1diff -urN iptables.old/extensions/Makefile iptables.dev/extensions/Makefile 
     2--- iptables.old/extensions/Makefile    2005-07-20 04:22:56.000000000 +0200 
     3+++ iptables.dev/extensions/Makefile    2006-03-23 14:42:28.000000000 +0100 
     4@@ -8,6 +8,10 @@ 
     5 PF_EXT_SLIB:=ah addrtype comment connlimit connmark conntrack dscp ecn esp hashlimit helper icmp iprange length limit mac mark multiport owner physdev pkttype realm rpc sctp standard state tcp tcpmss tos ttl udp unclean CLASSIFY CONNMARK DNAT DSCP ECN LOG MARK MASQUERADE MIRROR NETMAP NFQUEUE NOTRACK REDIRECT REJECT SAME SNAT TARPIT TCPMSS TOS TRACE TTL ULOG 
     6 PF6_EXT_SLIB:=eui64 hl icmpv6 length limit mac mark multiport owner physdev standard tcp udp HL LOG NFQUEUE MARK TRACE 
     7  
     8+ 
     9+# ipp2p 
     10+PF_EXT_SLIB += ipp2p 
     11+ 
     12 # Optionals 
     13 PF_EXT_SLIB_OPTS:=$(foreach T,$(wildcard extensions/.*-test),$(shell KERNEL_DIR=$(KERNEL_DIR) $(T))) 
     14 PF6_EXT_SLIB_OPTS:=$(foreach T,$(wildcard extensions/.*-test6),$(shell KERNEL_DIR=$(KERNEL_DIR) $(T))) 
     15diff -urN iptables.old/extensions/libipt_ipp2p.c iptables.dev/extensions/libipt_ipp2p.c 
     16--- iptables.old/extensions/libipt_ipp2p.c      1970-01-01 01:00:00.000000000 +0100 
     17+++ iptables.dev/extensions/libipt_ipp2p.c      2006-03-23 14:43:26.000000000 +0100 
     18@@ -0,0 +1,401 @@ 
    519+ 
    620+#include <stdio.h> 
     
    1529+#include <linux/netfilter_ipv4/ipt_ipp2p.h> 
    1630+ 
    17 + 
    18 + 
    19 + 
    2031+static void 
    2132+help(void) 
     
    2435+    "IPP2P v%s options:\n" 
    2536+    " --ipp2p  Grab all known p2p packets\n" 
    26 +    " --ipp2p-data     Identify all known p2p download commands (obsolete)\n\n" 
    2737+    " --edk            [TCP&UDP]       All known eDonkey/eMule/Overnet packets\n" 
    2838+    " --dc             [TCP]           All known Direct Connect packets\n" 
     
    3040+    " --gnu            [TCP&UDP]       All known Gnutella packets\n" 
    3141+    " --bit            [TCP&UDP]       All known BitTorrent packets\n" 
    32 +    " --apple  [TCP]           All known AppleJuice packets (beta - just a few tests until now)\n" 
    33 +    " --winmx  [TCP]           All known WinMX (beta - need feedback)\n" 
    34 +    " --soul           [TCP]           All known SoulSeek (beta - need feedback!)\n" 
    35 +    " --ares           [TCP]           All known Ares - use with DROP only (beta - need feedback!)\n\n" 
    36 +    " --edk-data       [TCP]           eDonkey/eMule/Overnet download commands (obsolete)\n" 
    37 +    " --dc-data        [TCP]           Direct Connect download command (obsolete)\n" 
    38 +    " --kazaa-data     [TCP]           KaZaA download command (obsolete)\n" 
    39 +    " --gnu-data       [TCP]           Gnutella download command (obsolete)\n" 
     42+    " --apple  [TCP]           All known AppleJuice packets\n" 
     43+    " --winmx  [TCP]           All known WinMX\n" 
     44+    " --soul           [TCP]           All known SoulSeek\n" 
     45+    " --ares           [TCP]           All known Ares\n\n" 
     46+    " EXPERIMENTAL protocols (please send feedback to: ipp2p@ipp2p.org) :\n" 
     47+    " --mute           [TCP]           All known Mute packets\n" 
     48+    " --waste  [TCP]           All known Waste packets\n" 
     49+    " --xdcc           [TCP]           All known XDCC packets (only xdcc login)\n\n" 
     50+    " DEBUG SUPPPORT, use only if you know why\n" 
     51+    " --debug          Generate kernel debug output, THIS WILL SLOW DOWN THE FILTER\n" 
    4052+    "\nNote that the follwing options will have the same meaning:\n" 
    41 +    " '--ipp2p' is equal to '--edk --dc --kazaa --gnu'\n" 
    42 +    " '--ipp2p-data' is equal to '--edk-data --dc-data --kazaa-data --gnu-data'\n" 
     53+    " '--ipp2p' is equal to '--edk --dc --kazaa --gnu --bit --apple --winmx --soul --ares'\n" 
    4354+    "\nIPP2P was intended for TCP only. Due to increasing usage of UDP we needed to change this.\n" 
    4455+    "You can now use -p udp to search UDP packets only or without -p switch to search UDP and TCP packets.\n" 
     
    5162+} 
    5263+ 
    53 +                                                            
    54 + 
    5564+static struct option opts[] = { 
    5665+        { "ipp2p", 0, 0, '1' }, 
    5766+        { "edk", 0, 0, '2' },   
    58 +        { "ipp2p-data", 0, 0, '3' },            
    59 +        { "kazaa-data", 0, 0, '4' }, 
    60 +        { "edk-data", 0, 0, '5' },      
    61 +        { "dc-data", 0, 0, '6' }, 
    6267+       { "dc", 0, 0, '7' }, 
    63 +       { "gnu-data", 0, 0, '8' },       
    6468+       { "gnu", 0, 0, '9' }, 
    6569+       { "kazaa", 0, 0, 'a' }, 
     
    6973+       { "winmx", 0, 0, 'e' },  
    7074+       { "ares", 0, 0, 'f' }, 
    71 +       { "debug", 0, 0, 'g' }, 
     75+       { "mute", 0, 0, 'g' }, 
     76+       { "waste", 0, 0, 'h' }, 
     77+       { "xdcc", 0, 0, 'i' }, 
     78+       { "debug", 0, 0, 'j' }, 
    7279+        {0} 
    7380+}; 
     
    103110+                               "ipp2p: `--ipp2p' may only be " 
    104111+                               "specified once!"); 
    105 +           if ((*flags & SHORT_HAND_DATA) == SHORT_HAND_DATA) 
     112+/*         if ((*flags & SHORT_HAND_DATA) == SHORT_HAND_DATA) 
    106113+                   exit_error(PARAMETER_PROBLEM, 
    107114+                               "ipp2p: `--ipp2p-data' may only be " 
    108 +                               "specified alone!"); 
     115+                               "specified alone!");*/ 
    109116+           if ((*flags) != 0) 
    110117+                   exit_error(PARAMETER_PROBLEM, 
     
    125132+                               "ipp2p: `--ipp2p' may only be " 
    126133+                               "specified alone!"); 
    127 +           if ((*flags & SHORT_HAND_DATA) == SHORT_HAND_DATA) 
     134+/*         if ((*flags & SHORT_HAND_DATA) == SHORT_HAND_DATA) 
    128135+                   exit_error(PARAMETER_PROBLEM, 
    129136+                               "ipp2p: `--ipp2p-data' may only be " 
    130 +                               "specified alone!"); 
     137+                               "specified alone!");*/ 
    131138+            if ((*flags & IPP2P_DATA_EDK) == IPP2P_DATA_EDK) 
    132139+            exit_error(PARAMETER_PROBLEM, 
     
    137144+           break; 
    138145+ 
    139 +       case '3':               /*cmd: ipp2p-data*/ 
    140 +           if ((*flags & SHORT_HAND_DATA) == SHORT_HAND_DATA) 
    141 +                   exit_error(PARAMETER_PROBLEM, 
    142 +                               "ipp2p: `--ipp2p-data' may only be " 
    143 +                               "specified once!"); 
    144 +           if ((*flags & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P) 
    145 +                   exit_error(PARAMETER_PROBLEM, 
    146 +                               "ipp2p: `--ipp2p' may only be " 
    147 +                               "specified alone!"); 
    148 +           if ((*flags) != 0) 
    149 +                   exit_error(PARAMETER_PROBLEM, 
    150 +                               "ipp2p: `--ipp2p-data' may only be " 
    151 +                               "specified alone!"); 
    152 +           if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!"); 
    153 +           *flags += SHORT_HAND_DATA; 
    154 +           info->cmd = *flags;      
    155 +           break; 
    156 + 
    157 +        case '4':              /*cmd: kazaa-data*/ 
    158 +            if ((*flags & IPP2P_DATA_KAZAA) == IPP2P_DATA_KAZAA) 
    159 +            exit_error(PARAMETER_PROBLEM, 
    160 +                                "ipp2p: `--kazaa-data' may only be " 
    161 +                                "specified once!"); 
    162 +           if ((*flags & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P) 
    163 +                   exit_error(PARAMETER_PROBLEM, 
    164 +                               "ipp2p: `--ipp2p' may only be " 
    165 +                               "specified alone!"); 
    166 +           if ((*flags & SHORT_HAND_DATA) == SHORT_HAND_DATA) 
    167 +                   exit_error(PARAMETER_PROBLEM, 
    168 +                               "ipp2p: `--ipp2p-data' may only be " 
    169 +                               "specified alone!"); 
    170 +            if ((*flags & IPP2P_KAZAA) == IPP2P_KAZAA) 
    171 +            exit_error(PARAMETER_PROBLEM, 
    172 +                                "ipp2p: use `--kazaa' OR `--kazaa-data' but not both of them!"); 
    173 +           if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!"); 
    174 +            *flags += IPP2P_DATA_KAZAA; 
    175 +           info->cmd = *flags; 
    176 +           break; 
    177 + 
    178 +       case '5':               /*cmd: edk-data*/ 
    179 +            if ((*flags & IPP2P_DATA_EDK) == IPP2P_DATA_EDK) 
    180 +            exit_error(PARAMETER_PROBLEM, 
    181 +                                "ipp2p: `--edk-data' may only be " 
    182 +                                "specified once!"); 
    183 +           if ((*flags & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P) 
    184 +                   exit_error(PARAMETER_PROBLEM, 
    185 +                               "ipp2p: `--ipp2p' may only be " 
    186 +                               "specified alone!"); 
    187 +           if ((*flags & SHORT_HAND_DATA) == SHORT_HAND_DATA) 
    188 +                   exit_error(PARAMETER_PROBLEM, 
    189 +                               "ipp2p: `--ipp2p-data' may only be " 
    190 +                               "specified alone!"); 
    191 +            if ((*flags & IPP2P_EDK) == IPP2P_EDK) 
    192 +            exit_error(PARAMETER_PROBLEM, 
    193 +                                "ipp2p: use `--edk' OR `--edk-data' but not both of them!"); 
    194 +           if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!"); 
    195 +            *flags += IPP2P_DATA_EDK; 
    196 +           info->cmd = *flags; 
    197 +           break;                                                                                                                                                                                                                       
    198 + 
    199 +       case '6':               /*cmd: dc-data*/ 
    200 +            if ((*flags & IPP2P_DATA_DC) == IPP2P_DATA_DC) 
    201 +            exit_error(PARAMETER_PROBLEM, 
    202 +                                "ipp2p: `--dc-data' may only be " 
    203 +                                "specified once!"); 
    204 +           if ((*flags & SHORT_HAND_DATA) == SHORT_HAND_DATA) 
    205 +                   exit_error(PARAMETER_PROBLEM, 
    206 +                               "ipp2p: `--ipp2p-data' may only be " 
    207 +                               "specified alone!"); 
    208 +           if ((*flags & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P) 
    209 +                   exit_error(PARAMETER_PROBLEM, 
    210 +                               "ipp2p: `--ipp2p' may only be " 
    211 +                               "specified alone!"); 
    212 +            if ((*flags & IPP2P_DC) == IPP2P_DC) 
    213 +            exit_error(PARAMETER_PROBLEM, 
    214 +                                "ipp2p: use `--dc' OR `--dc-data' but not both of them!"); 
    215 +           if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!"); 
    216 +            *flags += IPP2P_DATA_DC; 
    217 +           info->cmd = *flags; 
    218 +           break;                                                                                                                                                                                                                       
    219146+ 
    220147+       case '7':               /*cmd: dc*/ 
     
    227154+                               "ipp2p: `--ipp2p' may only be " 
    228155+                               "specified alone!"); 
    229 +           if ((*flags & SHORT_HAND_DATA) == SHORT_HAND_DATA) 
     156+/*         if ((*flags & SHORT_HAND_DATA) == SHORT_HAND_DATA) 
    230157+                   exit_error(PARAMETER_PROBLEM, 
    231158+                               "ipp2p: `--ipp2p-data' may only be " 
    232 +                               "specified alone!"); 
     159+                               "specified alone!");*/ 
    233160+            if ((*flags & IPP2P_DATA_DC) == IPP2P_DATA_DC) 
    234161+            exit_error(PARAMETER_PROBLEM, 
     
    237164+            *flags += IPP2P_DC; 
    238165+           info->cmd = *flags; 
    239 +           break;                                                                                                                                                                                                                       
    240 + 
    241 + 
    242 +       case '8':               /*cmd: gnu-data*/ 
    243 +            if ((*flags & IPP2P_DATA_GNU) == IPP2P_DATA_GNU) 
    244 +            exit_error(PARAMETER_PROBLEM, 
    245 +                                "ipp2p: `--gnu-data' may only be " 
    246 +                                "specified once!"); 
    247 +           if ((*flags & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P) 
    248 +                   exit_error(PARAMETER_PROBLEM, 
    249 +                               "ipp2p: `--ipp2p' may only be " 
    250 +                               "specified alone!"); 
    251 +           if ((*flags & SHORT_HAND_DATA) == SHORT_HAND_DATA) 
    252 +                   exit_error(PARAMETER_PROBLEM, 
    253 +                               "ipp2p: `--ipp2p-data' may only be " 
    254 +                               "specified alone!"); 
    255 +            if ((*flags & IPP2P_GNU) == IPP2P_GNU) 
    256 +            exit_error(PARAMETER_PROBLEM, 
    257 +                                "ipp2p: use `--gnu' OR `--gnu-data' but not both of them!"); 
    258 +           if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!"); 
    259 +            *flags += IPP2P_DATA_GNU; 
    260 +           info->cmd = *flags; 
    261 +           break;                                                                                                                                                                                                                       
     166+           break; 
     167+ 
    262168+ 
    263169+       case '9':               /*cmd: gnu*/ 
     
    266172+                                "ipp2p: `--gnu' may only be " 
    267173+                                "specified once!"); 
    268 +           if ((*flags & SHORT_HAND_DATA) == SHORT_HAND_DATA) 
     174+/*         if ((*flags & SHORT_HAND_DATA) == SHORT_HAND_DATA) 
    269175+                   exit_error(PARAMETER_PROBLEM, 
    270176+                               "ipp2p: `--ipp2p-data' may only be " 
    271 +                               "specified alone!"); 
     177+                               "specified alone!");*/ 
    272178+           if ((*flags & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P) 
    273179+                   exit_error(PARAMETER_PROBLEM, 
     
    280186+            *flags += IPP2P_GNU; 
    281187+           info->cmd = *flags; 
    282 +           break;                                                                                                                                                                                                                       
     188+           break; 
    283189+ 
    284190+       case 'a':               /*cmd: kazaa*/ 
     
    287193+                                "ipp2p: `--kazaa' may only be " 
    288194+                                "specified once!"); 
    289 +           if ((*flags & SHORT_HAND_DATA) == SHORT_HAND_DATA) 
     195+/*         if ((*flags & SHORT_HAND_DATA) == SHORT_HAND_DATA) 
    290196+                   exit_error(PARAMETER_PROBLEM, 
    291197+                               "ipp2p: `--ipp2p-data' may only be " 
    292 +                               "specified alone!"); 
     198+                               "specified alone!");*/ 
    293199+           if ((*flags & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P) 
    294200+                   exit_error(PARAMETER_PROBLEM, 
     
    308214+                                "ipp2p: `--bit' may only be " 
    309215+                                "specified once!"); 
     216+           if ((*flags & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P) 
     217+                   exit_error(PARAMETER_PROBLEM, 
     218+                               "ipp2p: `--ipp2p' may only be " 
     219+                               "specified alone!"); 
    310220+           if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!"); 
    311221+            *flags += IPP2P_BIT; 
     
    318228+                                "ipp2p: `--apple' may only be " 
    319229+                                "specified once!"); 
     230+           if ((*flags & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P) 
     231+                   exit_error(PARAMETER_PROBLEM, 
     232+                               "ipp2p: `--ipp2p' may only be " 
     233+                               "specified alone!"); 
    320234+           if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!"); 
    321235+            *flags += IPP2P_APPLE; 
     
    329243+                                "ipp2p: `--soul' may only be " 
    330244+                                "specified once!"); 
     245+           if ((*flags & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P) 
     246+                   exit_error(PARAMETER_PROBLEM, 
     247+                               "ipp2p: `--ipp2p' may only be " 
     248+                               "specified alone!"); 
    331249+           if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!"); 
    332250+            *flags += IPP2P_SOUL; 
     
    340258+                                "ipp2p: `--winmx' may only be " 
    341259+                                "specified once!"); 
     260+           if ((*flags & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P) 
     261+                   exit_error(PARAMETER_PROBLEM, 
     262+                               "ipp2p: `--ipp2p' may only be " 
     263+                               "specified alone!"); 
    342264+           if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!"); 
    343265+            *flags += IPP2P_WINMX; 
     
    350272+                                "ipp2p: `--ares' may only be " 
    351273+                                "specified once!"); 
     274+           if ((*flags & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P) 
     275+                   exit_error(PARAMETER_PROBLEM, 
     276+                               "ipp2p: `--ipp2p' may only be " 
     277+                               "specified alone!"); 
    352278+           if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!"); 
    353279+            *flags += IPP2P_ARES; 
    354280+           info->cmd = *flags; 
    355281+           break;                                                                                                                                                                                                                       
    356 + 
    357 +       case 'g':               /*cmd: debug*/ 
     282+        
     283+       case 'g':               /*cmd: mute*/ 
     284+            if ((*flags & IPP2P_MUTE) == IPP2P_MUTE) 
     285+            exit_error(PARAMETER_PROBLEM, 
     286+                                "ipp2p: `--mute' may only be " 
     287+                                "specified once!"); 
     288+           if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!"); 
     289+            *flags += IPP2P_MUTE; 
     290+           info->cmd = *flags; 
     291+           break;                                                                                                                                                                                                                       
     292+       case 'h':               /*cmd: waste*/ 
     293+            if ((*flags & IPP2P_WASTE) == IPP2P_WASTE) 
     294+            exit_error(PARAMETER_PROBLEM, 
     295+                                "ipp2p: `--waste' may only be " 
     296+                                "specified once!"); 
     297+           if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!"); 
     298+            *flags += IPP2P_WASTE; 
     299+           info->cmd = *flags; 
     300+           break;                                                                                                                                                                                                                       
     301+       case 'i':               /*cmd: xdcc*/ 
     302+            if ((*flags & IPP2P_XDCC) == IPP2P_XDCC) 
     303+            exit_error(PARAMETER_PROBLEM, 
     304+                                "ipp2p: `--ares' may only be " 
     305+                                "specified once!"); 
     306+           if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!"); 
     307+            *flags += IPP2P_XDCC; 
     308+           info->cmd = *flags; 
     309+           break;                                                                                                                                                                                                                       
     310+ 
     311+       case 'j':               /*cmd: debug*/ 
    358312+           if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!"); 
    359313+           info->debug = 1; 
     
    361315+ 
    362316+       default: 
    363 +            exit_error(PARAMETER_PROBLEM, 
    364 +           "\nipp2p-parameter problem: for ipp2p usage type: iptables -m ipp2p --help\n"); 
     317+//            exit_error(PARAMETER_PROBLEM, 
     318+//         "\nipp2p-parameter problem: for ipp2p usage type: iptables -m ipp2p --help\n"); 
    365319+           return 0; 
    366320+    } 
     
    388342+    printf("ipp2p v%s", IPP2P_VERSION); 
    389343+    if ((info->cmd & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P) printf(" --ipp2p"); 
    390 +    if ((info->cmd & SHORT_HAND_DATA) == SHORT_HAND_DATA) printf(" --ipp2p-data"); 
     344+//    if ((info->cmd & SHORT_HAND_DATA) == SHORT_HAND_DATA) printf(" --ipp2p-data"); 
    391345+    if ((info->cmd & IPP2P_KAZAA) == IPP2P_KAZAA) printf(" --kazaa"); 
    392 +    if ((info->cmd & IPP2P_DATA_KAZAA) == IPP2P_DATA_KAZAA) printf(" --kazaa-data"); 
    393 +    if ((info->cmd & IPP2P_DATA_GNU) == IPP2P_DATA_GNU) printf(" --gnu-data"); 
     346+//    if ((info->cmd & IPP2P_DATA_KAZAA) == IPP2P_DATA_KAZAA) printf(" --kazaa-data"); 
     347+//    if ((info->cmd & IPP2P_DATA_GNU) == IPP2P_DATA_GNU) printf(" --gnu-data"); 
    394348+    if ((info->cmd & IPP2P_GNU) == IPP2P_GNU) printf(" --gnu"); 
    395349+    if ((info->cmd & IPP2P_EDK) == IPP2P_EDK) printf(" --edk"); 
    396 +    if ((info->cmd & IPP2P_DATA_EDK) == IPP2P_DATA_EDK) printf(" --edk-data"); 
    397 +    if ((info->cmd & IPP2P_DATA_DC) == IPP2P_DATA_DC) printf(" --dc-data"); 
     350+//    if ((info->cmd & IPP2P_DATA_EDK) == IPP2P_DATA_EDK) printf(" --edk-data"); 
     351+//    if ((info->cmd & IPP2P_DATA_DC) == IPP2P_DATA_DC) printf(" --dc-data"); 
    398352+    if ((info->cmd & IPP2P_DC) == IPP2P_DC) printf(" --dc"); 
    399353+    if ((info->cmd & IPP2P_BIT) == IPP2P_BIT) printf(" --bit"); 
     
    402356+    if ((info->cmd & IPP2P_WINMX) == IPP2P_WINMX) printf(" --winmx"); 
    403357+    if ((info->cmd & IPP2P_ARES) == IPP2P_ARES) printf(" --ares"); 
     358+    if ((info->cmd & IPP2P_MUTE) == IPP2P_MUTE) printf(" --mute"); 
     359+    if ((info->cmd & IPP2P_WASTE) == IPP2P_WASTE) printf(" --waste"); 
     360+    if ((info->cmd & IPP2P_XDCC) == IPP2P_XDCC) printf(" --xdcc"); 
    404361+    if (info->debug != 0) printf(" --debug"); 
    405362+    printf(" "); 
     
    414371+     
    415372+    if ((info->cmd & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P) printf("--ipp2p "); 
    416 +    if ((info->cmd & SHORT_HAND_DATA) == SHORT_HAND_DATA) printf("--ipp2p-data "); 
     373+//    if ((info->cmd & SHORT_HAND_DATA) == SHORT_HAND_DATA) printf("--ipp2p-data "); 
    417374+    if ((info->cmd & IPP2P_KAZAA) == IPP2P_KAZAA) printf("--kazaa "); 
    418 +    if ((info->cmd & IPP2P_DATA_KAZAA) == IPP2P_DATA_KAZAA) printf("--kazaa-data "); 
    419 +    if ((info->cmd & IPP2P_DATA_GNU) == IPP2P_DATA_GNU) printf("--gnu-data "); 
     375+//    if ((info->cmd & IPP2P_DATA_KAZAA) == IPP2P_DATA_KAZAA) printf("--kazaa-data "); 
     376+//    if ((info->cmd & IPP2P_DATA_GNU) == IPP2P_DATA_GNU) printf("--gnu-data "); 
    420377+    if ((info->cmd & IPP2P_GNU) == IPP2P_GNU) printf("--gnu "); 
    421378+    if ((info->cmd & IPP2P_EDK) == IPP2P_EDK) printf("--edk "); 
    422 +    if ((info->cmd & IPP2P_DATA_EDK) == IPP2P_DATA_EDK) printf("--edk-data "); 
    423 +    if ((info->cmd & IPP2P_DATA_DC) == IPP2P_DATA_DC) printf("--dc-data "); 
     379+//    if ((info->cmd & IPP2P_DATA_EDK) == IPP2P_DATA_EDK) printf("--edk-data "); 
     380+//    if ((info->cmd & IPP2P_DATA_DC) == IPP2P_DATA_DC) printf("--dc-data "); 
    424381+    if ((info->cmd & IPP2P_DC) == IPP2P_DC) printf("--dc "); 
    425382+    if ((info->cmd & IPP2P_BIT) == IPP2P_BIT) printf("--bit "); 
     
    428385+    if ((info->cmd & IPP2P_WINMX) == IPP2P_WINMX) printf("--winmx "); 
    429386+    if ((info->cmd & IPP2P_ARES) == IPP2P_ARES) printf("--ares "); 
     387+    if ((info->cmd & IPP2P_MUTE) == IPP2P_MUTE) printf(" --mute"); 
     388+    if ((info->cmd & IPP2P_WASTE) == IPP2P_WASTE) printf(" --waste"); 
     389+    if ((info->cmd & IPP2P_XDCC) == IPP2P_XDCC) printf(" --xdcc"); 
    430390+    if (info->debug != 0) printf("--debug "); 
    431391+} 
     
    458418+} 
    459419+ 
    460 diff -urN iptables-1.2.11.old/extensions/Makefile iptables-1.2.11/extensions/Makefile 
    461 --- iptables-1.2.11.old/extensions/Makefile     2004-06-17 12:22:54.000000000 +0200 
    462 +++ iptables-1.2.11/extensions/Makefile 2005-03-12 00:50:12.000000000 +0100 
    463 @@ -8,6 +8,10 @@ 
    464  PF_EXT_SLIB:=ah connlimit connmark conntrack dscp ecn esp helper icmp iprange length limit mac mark multiport owner physdev pkttype realm rpc sctp standard state tcp tcpmss tos ttl udp unclean CLASSIFY CONNMARK DNAT DSCP ECN LOG MARK MASQUERADE MIRROR NETMAP NOTRACK REDIRECT REJECT SAME SNAT TARPIT TCPMSS TOS TRACE TTL ULOG 
    465  PF6_EXT_SLIB:=eui64 hl icmpv6 length limit mac mark multiport owner standard tcp udp HL LOG MARK TRACE 
    466   
    467 + 
    468 +# ipp2p 
    469 +PF_EXT_SLIB += ipp2p 
    470 + 
    471  # Optionals 
    472  PF_EXT_SLIB_OPTS:=$(foreach T,$(wildcard extensions/.*-test),$(shell KERNEL_DIR=$(KERNEL_DIR) $(T))) 
    473  PF6_EXT_SLIB_OPTS:=$(foreach T,$(wildcard extensions/.*-test6),$(shell KERNEL_DIR=$(KERNEL_DIR) $(T))) 
    474 diff -urN iptables-1.2.11.old/include/linux/netfilter_ipv4/ipt_ipp2p.h iptables-1.2.11/include/linux/netfilter_ipv4/ipt_ipp2p.h 
    475 --- iptables-1.2.11.old/include/linux/netfilter_ipv4/ipt_ipp2p.h        1970-01-01 01:00:00.000000000 +0100 
    476 +++ iptables-1.2.11/include/linux/netfilter_ipv4/ipt_ipp2p.h    2005-03-12 00:50:46.000000000 +0100 
    477 @@ -0,0 +1,29 @@ 
     420diff -urN iptables.old/include/linux/netfilter_ipv4/ipt_ipp2p.h iptables.dev/include/linux/netfilter_ipv4/ipt_ipp2p.h 
     421--- iptables.old/include/linux/netfilter_ipv4/ipt_ipp2p.h       1970-01-01 01:00:00.000000000 +0100 
     422+++ iptables.dev/include/linux/netfilter_ipv4/ipt_ipp2p.h       2006-03-23 14:44:26.000000000 +0100 
     423@@ -0,0 +1,31 @@ 
    478424+#ifndef __IPT_IPP2P_H 
    479425+#define __IPT_IPP2P_H 
    480 +#define IPP2P_VERSION "0.7.4" 
     426+#define IPP2P_VERSION "0.8.1_rc1" 
    481427+ 
    482428+struct ipt_p2p_info { 
     
    488434+ 
    489435+#define SHORT_HAND_IPP2P       1 /* --ipp2p switch*/ 
    490 +#define SHORT_HAND_DATA                4 /* --ipp2p-data switch*/ 
     436+//#define SHORT_HAND_DATA              4 /* --ipp2p-data switch*/ 
    491437+#define SHORT_HAND_NONE                5 /* no short hand*/ 
    492438+ 
    493 +#define IPP2P_EDK              2 
    494 +#define IPP2P_DATA_KAZAA       8 
    495 +#define IPP2P_DATA_EDK         16 
    496 +#define IPP2P_DATA_DC          32 
    497 +#define IPP2P_DC               64 
    498 +#define IPP2P_DATA_GNU         128 
    499 +#define IPP2P_GNU              256 
    500 +#define IPP2P_KAZAA            512 
    501 +#define IPP2P_BIT              1024 
    502 +#define IPP2P_APPLE            2048 
    503 +#define IPP2P_SOUL             4096 
    504 +#define IPP2P_WINMX            8192 
    505 +#define IPP2P_ARES             16384 
    506 + 
     439+#define IPP2P_EDK              (1 << 1) 
     440+#define IPP2P_DATA_KAZAA       (1 << 2) 
     441+#define IPP2P_DATA_EDK         (1 << 3) 
     442+#define IPP2P_DATA_DC          (1 << 4) 
     443+#define IPP2P_DC               (1 << 5) 
     444+#define IPP2P_DATA_GNU         (1 << 6) 
     445+#define IPP2P_GNU              (1 << 7) 
     446+#define IPP2P_KAZAA            (1 << 8) 
     447+#define IPP2P_BIT              (1 << 9) 
     448+#define IPP2P_APPLE            (1 << 10) 
     449+#define IPP2P_SOUL             (1 << 11) 
     450+#define IPP2P_WINMX            (1 << 12) 
     451+#define IPP2P_ARES             (1 << 13) 
     452+#define IPP2P_MUTE             (1 << 14) 
     453+#define IPP2P_WASTE            (1 << 15) 
     454+#define IPP2P_XDCC             (1 << 16) 
  • trunk/openwrt/target/linux/aruba-2.6/config

    r3422 r3463  
    320320# CONFIG_IP_NF_MATCH_LAYER7_DEBUG is not set 
    321321CONFIG_IP_NF_MATCH_MULTIPORT=m 
     322CONFIG_IP_NF_MATCH_IPP2P=m 
    322323CONFIG_IP_NF_MATCH_TOS=m 
    323324CONFIG_IP_NF_MATCH_TIME=m 
  • trunk/openwrt/target/linux/aruba-2.6/config-ramdisk

    r3422 r3463  
    322322# CONFIG_IP_NF_MATCH_LAYER7_DEBUG is not set 
    323323CONFIG_IP_NF_MATCH_MULTIPORT=m 
     324CONFIG_IP_NF_MATCH_IPP2P=m 
    324325CONFIG_IP_NF_MATCH_TOS=m 
    325326CONFIG_IP_NF_MATCH_TIME=m 
  • trunk/openwrt/target/linux/brcm-2.6/config

    r3422 r3463  
    22# Automatically generated make config: don't edit 
    33# Linux kernel version: 2.6.16 
    4 # Tue Mar 21 00:25:31 2006 
     4# Thu Mar 23 15:31:19 2006 
    55# 
    66CONFIG_MIPS=y 
     
    276276CONFIG_NET_IPGRE=m 
    277277# CONFIG_NET_IPGRE_BROADCAST is not set 
     278CONFIG_IPSEC_NAT_TRAVERSAL=y 
    278279# CONFIG_IP_MROUTE is not set 
    279280# CONFIG_ARPD is not set 
    280281# CONFIG_SYN_COOKIES is not set 
    281 CONFIG_IPSEC_NAT_TRAVERSAL=y 
    282282# CONFIG_INET_AH is not set 
    283283# CONFIG_INET_ESP is not set 
     
    361361# CONFIG_IP_NF_MATCH_LAYER7_DEBUG is not set 
    362362CONFIG_IP_NF_MATCH_MULTIPORT=m 
     363CONFIG_IP_NF_MATCH_IPP2P=m 
    363364CONFIG_IP_NF_MATCH_TOS=m 
    364365CONFIG_IP_NF_MATCH_TIME=m 
  • trunk/openwrt/target/linux/generic-2.4/patches/601-netfilter_ipp2p_0.8.1rc1.patch

    r3405 r3463  
    1 diff -urN linux-2.4.29.old/include/linux/netfilter_ipv4/ipt_ipp2p.h linux-2.4.29/include/linux/netfilter_ipv4/ipt_ipp2p.h 
    2 --- linux-2.4.29.old/include/linux/netfilter_ipv4/ipt_ipp2p.h   1970-01-01 01:00:00.000000000 +0100 
    3 +++ linux-2.4.29/include/linux/netfilter_ipv4/ipt_ipp2p.h       2005-03-12 00:44:17.000000000 +0100 
    4 @@ -0,0 +1,29 @@ 
     1diff -urN linux.old/include/linux/netfilter_ipv4/ipt_ipp2p.h linux.dev/include/linux/netfilter_ipv4/ipt_ipp2p.h 
     2--- linux.old/include/linux/netfilter_ipv4/ipt_ipp2p.h  1970-01-01 01:00:00.000000000 +0100 
     3+++ linux.dev/include/linux/netfilter_ipv4/ipt_ipp2p.h  2006-03-23 14:37:56.000000000 +0100 
     4@@ -0,0 +1,31 @@ 
    55+#ifndef __IPT_IPP2P_H 
    66+#define __IPT_IPP2P_H 
    7 +#define IPP2P_VERSION "0.7.4" 
     7+#define IPP2P_VERSION "0.8.1_rc1" 
    88+ 
    99+struct ipt_p2p_info { 
     
    1515+ 
    1616+#define SHORT_HAND_IPP2P       1 /* --ipp2p switch*/ 
    17 +#define SHORT_HAND_DATA                4 /* --ipp2p-data switch*/ 
     17+//#define SHORT_HAND_DATA              4 /* --ipp2p-data switch*/ 
    1818+#define SHORT_HAND_NONE                5 /* no short hand*/ 
    1919+ 
    20 +#define IPP2P_EDK              2 
    21 +#define IPP2P_DATA_KAZAA       8 
    22 +#define IPP2P_DATA_EDK         16 
    23 +#define IPP2P_DATA_DC          32 
    24 +#define IPP2P_DC               64 
    25 +#define IPP2P_DATA_GNU         128 
    26 +#define IPP2P_GNU              256 
    27 +#define IPP2P_KAZAA            512 
    28 +#define IPP2P_BIT              1024 
    29 +#define IPP2P_APPLE            2048 
    30 +#define IPP2P_SOUL             4096 
    31 +#define IPP2P_WINMX            8192 
    32 +#define IPP2P_ARES             16384 
    33 + 
    34 diff -urN linux-2.4.29.old/net/ipv4/netfilter/Config.in linux-2.4.29/net/ipv4/netfilter/Config.in 
    35 --- linux-2.4.29.old/net/ipv4/netfilter/Config.in       2005-03-12 00:40:38.000000000 +0100 
    36 +++ linux-2.4.29/net/ipv4/netfilter/Config.in   2005-03-12 00:42:57.000000000 +0100 
    37 @@ -26,6 +26,7 @@ 
     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 -urN linux.old/net/ipv4/netfilter/Config.in linux.dev/net/ipv4/netfilter/Config.in 
     37--- linux.old/net/ipv4/netfilter/Config.in      2006-03-23 14:35:20.000000000 +0100 
     38+++ linux.dev/net/ipv4/netfilter/Config.in      2006-03-23 14:35:58.000000000 +0100 
     39@@ -29,6 +29,7 @@ 
    3840   dep_tristate '  TOS match support' CONFIG_IP_NF_MATCH_TOS $CONFIG_IP_NF_IPTABLES 
    3941   dep_tristate '  recent match support' CONFIG_IP_NF_MATCH_RECENT $CONFIG_IP_NF_IPTABLES 
     
    4345   dep_tristate '  DSCP match support' CONFIG_IP_NF_MATCH_DSCP $CONFIG_IP_NF_IPTABLES 
    4446   
    45 diff -urN linux-2.4.29.old/net/ipv4/netfilter/ipt_ipp2p.c linux-2.4.29/net/ipv4/netfilter/ipt_ipp2p.c 
    46 --- linux-2.4.29.old/net/ipv4/netfilter/ipt_ipp2p.c     1970-01-01 01:00:00.000000000 +0100 
    47 +++ linux-2.4.29/net/ipv4/netfilter/ipt_ipp2p.c 2005-03-12 00:44:02.000000000 +0100 
    48 @@ -0,0 +1,661 @@ 
     47diff -urN linux.old/net/ipv4/netfilter/Makefile linux.dev/net/ipv4/netfilter/Makefile 
     48--- linux.old/net/ipv4/netfilter/Makefile       2006-03-23 14:35:20.000000000 +0100 
     49+++ linux.dev/net/ipv4/netfilter/Makefile       2006-03-23 14:35:58.000000000 +0100 
     50@@ -76,6 +76,7 @@ 
     51 obj-$(CONFIG_IP_NF_MATCH_LIMIT) += ipt_limit.o 
     52 obj-$(CONFIG_IP_NF_MATCH_MARK) += ipt_mark.o 
     53 obj-$(CONFIG_IP_NF_MATCH_MAC) += ipt_mac.o 
     54+obj-$(CONFIG_IP_NF_MATCH_IPP2P) += ipt_ipp2p.o 
     55  
     56 obj-$(CONFIG_IP_NF_MATCH_PKTTYPE) += ipt_pkttype.o 
     57 obj-$(CONFIG_IP_NF_MATCH_MULTIPORT) += ipt_multiport.o 
     58diff -urN linux.old/net/ipv4/netfilter/ipt_ipp2p.c linux.dev/net/ipv4/netfilter/ipt_ipp2p.c 
     59--- linux.old/net/ipv4/netfilter/ipt_ipp2p.c    1970-01-01 01:00:00.000000000 +0100 
     60+++ linux.dev/net/ipv4/netfilter/ipt_ipp2p.c    2006-03-23 14:37:18.000000000 +0100 
     61@@ -0,0 +1,868 @@ 
    4962+#if defined(MODVERSIONS) 
    5063+#include <linux/modversions.h> 
     
    5467+#include <linux/version.h> 
    5568+#include <linux/netfilter_ipv4/ipt_ipp2p.h> 
    56 +//#include "ipt_ipp2p.h" 
    5769+#include <net/tcp.h> 
    5870+#include <net/udp.h> 
     
    6274+#define get_u32(X,O)  (*(__u32 *)(X + O)) 
    6375+ 
    64 +MODULE_AUTHOR("Eicke Friedrich <ipp2p@ipp2p.org>"); 
     76+MODULE_AUTHOR("Eicke Friedrich/Klaus Degner <ipp2p@ipp2p.org>"); 
    6577+MODULE_DESCRIPTION("An extension to iptables to identify P2P traffic."); 
    6678+MODULE_LICENSE("GPL"); 
     
    7486+    t += 8; 
    7587+ 
    76 +    switch (t[0]) { 
    77 +    case 0xe3: {       /*edonkey*/ 
    78 +       switch (t[1]) { 
    79 +                       /* e3 9a + 16Bytes Hash | size == 26 */ 
    80 +       case 0x9a: if (packet_len == 26) return ((IPP2P_EDK * 100) + 1); 
    81 +                       /* e3 96 xx yy zz kk | size == 14 | server status request */ 
    82 +       case 0x96: if (packet_len == 14) return ((IPP2P_EDK * 100) + 2); 
    83 +                       /* e3 a2 | size == 10 or 14 <-- recheck*/ 
    84 +       } 
    85 +    } 
    86 + 
    87 +    case 0xc5: {       /*emule*/ 
    88 +       switch (t[1]) { 
    89 +                       /* c5 91 xx yy | size == 12 (8+4) | xx != 0x00  -- xx yy queue rating */ 
    90 +       case 0x91: if ((packet_len == 12) && (t[2] != 0x00)) return ((IPP2P_EDK * 100) + 3); 
    91 +                       /* c5 90 xx ..  yy | size == 26 (8+2+16) | xx .. yy == hash  -- file ping */ 
    92 +       case 0x90: if ((packet_len == 26) && (t[2] != 0x00)) return ((IPP2P_EDK * 100) + 4); 
    93 +                       /* c5 92 | size == 10 (8+2) -- file not found */ 
    94 +       case 0x92: if (packet_len == 10) return ((IPP2P_EDK * 100) + 5); 
    95 +                       /* c5 93 | size == 10 (8+2) -- queue full */ 
    96 +       case 0x93: if (packet_len == 10) return ((IPP2P_EDK * 100) + 6); 
    97 +       } 
    98 +    } 
    99 + 
    100 +    case 0xe4: {       /*kad*/ 
    101 +       switch (t[1]) { 
    102 +                       /* e4 50 | size == 12 */ 
    103 +           case 0x50: if (packet_len == 12) return ((IPP2P_EDK * 100) + 7); 
    104 +                       /* e4 58 | size == 14 */ 
    105 +           case 0x58: if ((packet_len == 14) && (t[2] != 0x00)) return ((IPP2P_EDK * 100) + 8); 
    106 +                       /* e4 59 | size == 10 */ 
    107 +           case 0x59: if (packet_len == 10) return ((IPP2P_EDK * 100) + 9); 
    108 +                       /* e4 30 .. | t[18] == 0x01 | size > 26 | --> search */ 
    109 +           case 0x30: if ((packet_len > 26) && (t[18] == 0x01)) return ((IPP2P_EDK * 100) + 10); 
    110 +                       /* e4 28 .. 00 | t[68] == 0x00 | size > 76 */ 
    111 +           case 0x28: if ((packet_len > 76) && (t[68] == 0x00)) return ((IPP2P_EDK * 100) + 11); 
    112 +                       /* e4 20 .. | size == 43 */ 
    113 +           case 0x20: if ((packet_len == 43) && (t[2] != 0x00) && (t[34] != 0x00)) return ((IPP2P_EDK * 100) + 12); 
    114 +                       /* e4 00 .. 00 | size == 35 ? */ 
    115 +           case 0x00: if ((packet_len == 35) && (t[26] == 0x00)) return ((IPP2P_EDK * 100) + 13); 
    116 +                       /* e4 10 .. 00 | size == 35 ? */ 
    117 +           case 0x10: if ((packet_len == 35) && (t[26] == 0x00)) return ((IPP2P_EDK * 100) + 14); 
    118 +                       /* e4 18 .. 00 | size == 35 ? */ 
    119 +           case 0x18: if ((packet_len == 35) && (t[26] == 0x00)) return ((IPP2P_EDK * 100) + 15); 
    120 +                       /* e4 40 .. | t[18] == 0x01 | t[19] == 0x00 | size > 40 */ 
    121 +           case 0x40: if ((packet_len > 40) && (t[18] == 0x01) && (t[19] == 0x00)) return ((IPP2P_EDK * 100) + 16); 
    122 +       } 
    123 +    } 
    124 +     
    125 +    default: return 0; 
    126 +    } /* end of switch (t[0]) */ 
     88+       switch (t[0]) { 
     89+               case 0xe3:  
     90+               {       /*edonkey*/ 
     91+                       switch (t[1])  
     92+                       { 
     93+                               /* client -> server status request */ 
     94+                               case 0x96:  
     95+                                       if (packet_len == 14) return ((IPP2P_EDK * 100) + 50); 
     96+                                       break; 
     97+                               /* server -> client status request */ 
     98+                               case 0x97: if (packet_len == 42) return ((IPP2P_EDK * 100) + 51); 
     99+                                       break; 
     100+                                               /* server description request */ 
     101+                                               /* e3 2a ff f0 .. | size == 6 */ 
     102+                               case 0xa2: if ( (packet_len == 14) && ( get_u16(t,2) == __constant_htons(0xfff0) ) ) return ((IPP2P_EDK * 100) + 52); 
     103+                                       break; 
     104+                                               /* server description response */ 
     105+                                               /* e3 a3 ff f0 ..  | size > 40 && size < 200 */ 
     106+                               //case 0xa3: return ((IPP2P_EDK * 100) + 53); 
     107+                               //      break; 
     108+                               case 0x9a: if (packet_len==26) return ((IPP2P_EDK * 100) + 54); 
     109+                                       break; 
     110+ 
     111+                               case 0x92: if (packet_len==18) return ((IPP2P_EDK * 100) + 55); 
     112+                                       break; 
     113+                       } 
     114+                       break; 
     115+               } 
     116+               case 0xe4:  
     117+               { 
     118+                       switch (t[1])  
     119+                       { 
     120+                                               /* e4 20 .. | size == 43 */ 
     121+                               case 0x20: if ((packet_len == 43) && (t[2] != 0x00) && (t[34] != 0x00)) return ((IPP2P_EDK * 100) + 60); 
     122+                                       break; 
     123+                                               /* e4 00 .. 00 | size == 35 ? */ 
     124+                               case 0x00: if ((packet_len == 35) && (t[26] == 0x00)) return ((IPP2P_EDK * 100) + 61); 
     125+                                       break; 
     126+                                               /* e4 10 .. 00 | size == 35 ? */ 
     127+                               case 0x10: if ((packet_len == 35) && (t[26] == 0x00)) return ((IPP2P_EDK * 100) + 62); 
     128+                                       break; 
     129+                                               /* e4 18 .. 00 | size == 35 ? */ 
     130+                               case 0x18: if ((packet_len == 35) && (t[26] == 0x00)) return ((IPP2P_EDK * 100) + 63); 
     131+                                       break; 
     132+                                               /* e4 52 .. | size = 44 */ 
     133+                               case 0x52: if (packet_len == 44 ) return ((IPP2P_EDK * 100) + 64); 
     134+                                       break; 
     135+                                               /* e4 58 .. | size == 6 */ 
     136+                               case 0x58: if (packet_len == 14 ) return ((IPP2P_EDK * 100) + 65); 
     137+                                       break; 
     138+                                               /* e4 59 .. | size == 2 */ 
     139+                               case 0x59: if (packet_len == 10 )return ((IPP2P_EDK * 100) + 66); 
     140+                                       break; 
     141+                                       /* e4 28 .. | packet_len == 52,77,102,127... */ 
     142+                               case 0x28: if (((packet_len-52) % 25) == 0) return ((IPP2P_EDK * 100) + 67); 
     143+                                       break; 
     144+                                       /* e4 50 xx xx | size == 4 */ 
     145+                               case 0x50: if (packet_len == 12) return ((IPP2P_EDK * 100) + 68); 
     146+                                       break; 
     147+                                       /* e4 40 xx xx | size == 48 */ 
     148+                               case 0x40: if (packet_len == 56) return ((IPP2P_EDK * 100) + 69); 
     149+                                       break; 
     150+                       } 
     151+                       break; 
     152+               } 
     153+       } /* end of switch (t[0]) */ 
     154+    return 0; 
    127155+}/*udp_search_edk*/ 
    128156+ 
     
    135163+    t += 8; 
    136164+     
    137 +    if (memcmp(t, "GND", 3) == 0) return ((IPP2P_GNU * 100) + 1); 
    138 +    if (memcmp(t, "GNUTELLA ", 9) == 0) return ((IPP2P_GNU * 100) + 2); 
     165+    if (memcmp(t, "GND", 3) == 0) return ((IPP2P_GNU * 100) + 51); 
     166+    if (memcmp(t, "GNUTELLA ", 9) == 0) return ((IPP2P_GNU * 100) + 52); 
    139167+    return 0; 
    140168+}/*udp_search_gnu*/ 
     
    149177+    if (t[packet_len-1] == 0x00){ 
    150178+       t += (packet_len - 6); 
    151 +       if (memcmp(t, "KaZaA", 5) == 0) return (IPP2P_KAZAA * 100); 
    152 +    } 
     179+       if (memcmp(t, "KaZaA", 5) == 0) return (IPP2P_KAZAA * 100 +50); 
     180+    } 
     181+     
    153182+    return 0; 
    154183+}/*udp_search_kazaa*/ 
    155184+ 
     185+/*Search for UDP DirectConnect commands*/ 
     186+int 
     187+udp_search_directconnect (unsigned char *haystack, int packet_len) 
     188+{ 
     189+    unsigned char *t = haystack; 
     190+    if ((*(t + 8) == 0x24) && (*(t + packet_len - 1) == 0x7c)) { 
     191+       t+=8; 
     192+       if (memcmp(t, "SR ", 3) == 0)                   return ((IPP2P_DC * 100) + 60); 
     193+       if (memcmp(t, "Ping ", 5) == 0)                 return ((IPP2P_DC * 100) + 61); 
     194+    } 
     195+    return 0; 
     196+}/*udp_search_directconnect*/ 
     197+ 
     198+ 
    156199+ 
    157200+/*Search for UDP BitTorrent commands*/ 
     
    159202+udp_search_bit (unsigned char *haystack, int packet_len) 
    160203+{ 
    161 +    unsigned char *t = haystack; 
    162 +     
    163 +    /* packet_len has to be 24 */ 
    164 +    if (packet_len != 24) return 0; 
    165 + 
    166 +    t += 8;     
    167 + 
    168 +    /* ^ 00 00 04 17 27 10 19 80 */ 
    169 +    if ((ntohl(get_u32(t, 0)) == 0x00000417) && (ntohl(get_u32(t, 4)) == 0x27101980)) return (IPP2P_BIT * 100); 
     204+       switch(packet_len) 
     205+       { 
     206+               case 24: 
     207+                       /* ^ 00 00 04 17 27 10 19 80 */ 
     208+                       if ((ntohl(get_u32(haystack, 8)) == 0x00000417) && (ntohl(get_u32(haystack, 12)) == 0x27101980))  
     209+                               return (IPP2P_BIT * 100 + 50); 
     210+                       break; 
     211+               case 44: 
     212+                       if (get_u32(haystack, 16) == __constant_htonl(0x00000400) && get_u32(haystack, 36) == __constant_htonl(0x00000104))  
     213+                               return (IPP2P_BIT * 100 + 51); 
     214+                       if (get_u32(haystack, 16) == __constant_htonl(0x00000400)) 
     215+                               return (IPP2P_BIT * 100 + 61); 
     216+                       break; 
     217+               case 65: 
     218+                       if (get_u32(haystack, 16) == __constant_htonl(0x00000404) && get_u32(haystack, 36) == __constant_htonl(0x00000104))  
     219+                               return (IPP2P_BIT * 100 + 52); 
     220+                       if (get_u32(haystack, 16) == __constant_htonl(0x00000404)) 
     221+                               return (IPP2P_BIT * 100 + 62); 
     222+                       break; 
     223+               case 67: 
     224+                       if (get_u32(haystack, 16) == __constant_htonl(0x00000406) && get_u32(haystack, 36) == __constant_htonl(0x00000104))  
     225+                               return (IPP2P_BIT * 100 + 53); 
     226+                       if (get_u32(haystack, 16) == __constant_htonl(0x00000406)) 
     227+                               return (IPP2P_BIT * 100 + 63); 
     228+                       break; 
     229+               case 211: 
     230+                       if (get_u32(haystack, 8) == __constant_htonl(0x00000405))  
     231+                               return (IPP2P_BIT * 100 + 54); 
     232+                       break; 
     233+               case 29: 
     234+                       if ((get_u32(haystack, 8) == __constant_htonl(0x00000401)))  
     235+                               return (IPP2P_BIT * 100 + 55); 
     236+                       break; 
     237+               case 52: 
     238+                       if (get_u32(haystack,8)  == __constant_htonl(0x00000827) && 
     239+                       get_u32(haystack,12) == __constant_htonl(0x37502950)) 
     240+                               return (IPP2P_BIT * 100 + 80); 
     241+                       break; 
     242+               default: 
     243+                       /* this packet does not have a constant size */ 
     244+                       if (packet_len >= 40 && get_u32(haystack, 16) == __constant_htonl(0x00000402) && get_u32(haystack, 36) == __constant_htonl(0x00000104))  
     245+                               return (IPP2P_BIT * 100 + 56); 
     246+                       break; 
     247+       } 
     248+     
     249+       /* some extra-bitcomet rules: 
     250+       * "d1:" [a|r] "d2:id20:" 
     251+       */ 
     252+       if (packet_len > 30 && get_u8(haystack, 8) == 'd' && get_u8(haystack, 9) == '1' && get_u8(haystack, 10) == ':' ) 
     253+       { 
     254+               if (get_u8(haystack, 11) == 'a' || get_u8(haystack, 11) == 'r') 
     255+               { 
     256+                       if (memcmp(haystack+12,"d2:id20:",8)==0) 
     257+                               return (IPP2P_BIT * 100 + 57); 
     258+               } 
     259+       } 
     260+     
     261+#if 0 
     262+       /* bitlord rules */ 
     263+       /* packetlen must be bigger than 40 */ 
     264+       /* first 4 bytes are zero */ 
     265+       if (packet_len > 40 && get_u32(haystack, 8) == 0x00000000) 
     266+       { 
     267+               /* first rule: 00 00 00 00 01 00 00 xx xx xx xx 00 00 00 00*/ 
     268+               if (get_u32(haystack, 12) == 0x00000000 &&  
     269+                   get_u32(haystack, 16) == 0x00010000 && 
     270+                   get_u32(haystack, 24) == 0x00000000 ) 
     271+                       return (IPP2P_BIT * 100 + 71); 
     272+                        
     273+               /* 00 01 00 00 0d 00 00 xx xx xx xx 00 00 00 00*/ 
     274+               if (get_u32(haystack, 12) == 0x00000001 &&  
     275+                   get_u32(haystack, 16) == 0x000d0000 && 
     276+                   get_u32(haystack, 24) == 0x00000000 ) 
     277+                       return (IPP2P_BIT * 100 + 71); 
     278+                
     279+                    
     280+       } 
     281+#endif 
    170282+ 
    171283+    return 0; 
     
    175287+ 
    176288+/*Search for Ares commands*/ 
    177 +int 
    178 +search_ares (unsigned char *haystack, int packet_len, int head_len) 
    179 +{ 
    180 +    unsigned char *t = haystack; 
    181 +    t += head_len; 
    182 + 
    183 +    if ((packet_len - head_len) == 6){ /* possible connect command*/ 
    184 +       if ((t[0] == 0x03) && (t[1] == 0x00) && (t[2] == 0x5a) && (t[3] == 0x04) && (t[4] == 0x03) && (t[5] == 0x05)) 
    185 +           return ((IPP2P_ARES * 100) + 1);                    /* found connect packet: 03 00 5a 04 03 05 */ 
    186 +    } 
    187 +    if ((packet_len - head_len) == 60){        /* possible download command*/ 
    188 +       if ((t[59] == 0x0a) && (t[58] == 0x0a)){ 
     289+//#define IPP2P_DEBUG_ARES 
     290+int 
     291+search_ares (const unsigned char *payload, const u16 plen) 
     292+//int search_ares (unsigned char *haystack, int packet_len, int head_len) 
     293+{ 
     294+//     const unsigned char *t = haystack + head_len; 
     295+        
     296+       /* all ares packets start with  */ 
     297+       if (payload[1] == 0 && (plen - payload[0]) == 3) 
     298+       { 
     299+               switch (payload[2]) 
     300+               { 
     301+                       case 0x5a: 
     302+                               /* ares connect */ 
     303+                               if ( plen == 6 && payload[5] == 0x05 ) return ((IPP2P_ARES * 100) + 1); 
     304+                               break; 
     305+                       case 0x09: 
     306+                               /* ares search, min 3 chars --> 14 bytes 
     307+                                * lets define a search can be up to 30 chars --> max 34 bytes 
     308+                                */ 
     309+                               if ( plen >= 14 && plen <= 34 ) return ((IPP2P_ARES * 100) + 1); 
     310+                               break; 
     311+#ifdef IPP2P_DEBUG_ARES 
     312+                       default: 
     313+                       printk(KERN_DEBUG "Unknown Ares command %x recognized, len: %u \n", (unsigned int) payload[2],plen); 
     314+#endif /* IPP2P_DEBUG_ARES */ 
     315+               } 
     316+       } 
     317+ 
     318+#if 0           
     319+       /* found connect packet: 03 00 5a 04 03 05 */ 
     320+       /* new version ares 1.8: 03 00 5a xx xx 05 */ 
     321+    if ((plen) == 6){  /* possible connect command*/ 
     322+       if ((payload[0] == 0x03) && (payload[1] == 0x00) && (payload[2] == 0x5a) && (payload[5] == 0x05)) 
     323+           return ((IPP2P_ARES * 100) + 1); 
     324+    } 
     325+    if ((plen) == 60){ /* possible download command*/ 
     326+       if ((payload[59] == 0x0a) && (payload[58] == 0x0a)){ 
    189327+           if (memcmp(t, "PUSH SHA1:", 10) == 0) /* found download command */ 
    190328+               return ((IPP2P_ARES * 100) + 2); 
    191329+       } 
    192330+    } 
     331+#endif 
     332+ 
    193333+    return 0; 
    194334+} /*search_ares*/ 
    195335+ 
    196 + 
    197336+/*Search for SoulSeek commands*/ 
    198337+int 
    199 +search_soul (unsigned char *haystack, int packet_len, int head_len) 
    200 +{ 
    201 +    unsigned char *t = haystack; 
    202 +    t += head_len; 
    203 + 
    204 +    if (get_u16(t, 0) == (packet_len - head_len - 4)){ 
    205 +           /* xx xx 00 00 yy zz 00 00 .. | xx = sizeof(payload) - 4 */ 
    206 +       if ((get_u16(t,2) == 0x0000) &&(t[4] != 0x00) && (get_u16(t,6) == 0x0000)) 
    207 +           return ((IPP2P_SOUL * 100) + 1); 
    208 +    } else { 
    209 +           /* 00 00 00 00 00 00 00 00 + sizeof(payload) == 8*/ 
    210 +       if (((packet_len - head_len) == 8) && (get_u32(t, 0) == 0x00000000) && (get_u32(t, 4) == 0x00000000)) 
    211 +           return ((IPP2P_SOUL * 100) + 2); 
    212 +    } 
    213 +     
    214 +    /* 01 xx 00 00 00 yy .. zz 00 00 00 .. | xx == sizeof(nick) | yy .. zz == nick */ 
    215 +    if ((t[0] == 0x01) && (t[2] == 0x00) && (get_u16(t,3) == 0x0000) && ((packet_len - head_len) > ((get_u8(t,1))+6)) &&  
    216 +       (t[(get_u8(t,1))+4] != 0x00) && (t[(get_u8(t,1))+5] == 0x01) && (t[(get_u8(t,1))+6] == 0x00)) 
    217 +           return ((IPP2P_SOUL * 100) + 3); 
     338+search_soul (const unsigned char *payload, const u16 plen) 
     339+{ 
     340+//#define IPP2P_DEBUG_SOUL 
     341+    /* match: xx xx xx xx | xx = sizeof(payload) - 4 */ 
     342+    if (get_u32(payload, 0) == (plen - 4)){ 
     343+       const __u32 m=get_u32(payload, 4); 
     344+       /* match 00 yy yy 00, yy can be everything */ 
     345+        if ( get_u8(payload, 4) == 0x00 && get_u8(payload, 7) == 0x00 ) 
     346+       { 
     347+#ifdef IPP2P_DEBUG_SOUL 
     348+       printk(KERN_DEBUG "0: Soulseek command 0x%x recognized\n",get_u32(payload, 4)); 
     349+#endif /* IPP2P_DEBUG_SOUL */ 
     350+               return ((IPP2P_SOUL * 100) + 1); 
     351+       } 
     352+        
     353+        /* next match: 01 yy 00 00 | yy can be everything */ 
     354+        if ( get_u8(payload, 4) == 0x01 && get_u16(payload, 6) == 0x0000 ) 
     355+       { 
     356+#ifdef IPP2P_DEBUG_SOUL 
     357+       printk(KERN_DEBUG "1: Soulseek command 0x%x recognized\n",get_u16(payload, 4)); 
     358+#endif /* IPP2P_DEBUG_SOUL */ 
     359+               return ((IPP2P_SOUL * 100) + 2); 
     360+       } 
     361+        
     362+       /* 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 */ 
     363+       /* try to do this in an intelligent way */ 
     364+       /* get all small commandos */ 
     365+       switch(m) 
     366+       { 
     367+               case 7: 
     368+               case 9: 
     369+               case 22: 
     370+               case 23: 
     371+               case 26: 
     372+               case 28: 
     373+               case 50: 
     374+               case 51: 
     375+               case 60: 
     376+               case 91: 
     377+               case 92: 
     378+               case 1001: 
     379+#ifdef IPP2P_DEBUG_SOUL 
     380+               printk(KERN_DEBUG "2: Soulseek command 0x%x recognized\n",get_u16(payload, 4)); 
     381+#endif /* IPP2P_DEBUG_SOUL */ 
     382+               return ((IPP2P_SOUL * 100) + 3); 
     383+       } 
     384+        
     385+       if (m > 0 && m < 6 )  
     386+       { 
     387+#ifdef IPP2P_DEBUG_SOUL 
     388+               printk(KERN_DEBUG "3: Soulseek command 0x%x recognized\n",get_u16(payload, 4)); 
     389+#endif /* IPP2P_DEBUG_SOUL */ 
     390+               return ((IPP2P_SOUL * 100) + 4); 
     391+       } 
     392+       if (m > 12 && m < 19 ) 
     393+       { 
     394+#ifdef IPP2P_DEBUG_SOUL 
     395+               printk(KERN_DEBUG "4: Soulseek command 0x%x recognized\n",get_u16(payload, 4)); 
     396+#endif /* IPP2P_DEBUG_SOUL */ 
     397+               return ((IPP2P_SOUL * 100) + 5); 
     398+       } 
     399+ 
     400+       if (m > 34 && m < 38 ) 
     401+       { 
     402+#ifdef IPP2P_DEBUG_SOUL 
     403+               printk(KERN_DEBUG "5: Soulseek command 0x%x recognized\n",get_u16(payload, 4)); 
     404+#endif /* IPP2P_DEBUG_SOUL */ 
     405+               return ((IPP2P_SOUL * 100) + 6); 
     406+       } 
     407+ 
     408+       if (m > 39 && m < 47 ) 
     409+       { 
     410+#ifdef IPP2P_DEBUG_SOUL 
     411+               printk(KERN_DEBUG "6: Soulseek command 0x%x recognized\n",get_u16(payload, 4)); 
     412+#endif /* IPP2P_DEBUG_SOUL */ 
     413+               return ((IPP2P_SOUL * 100) + 7); 
     414+       } 
     415+ 
     416+       if (m > 61 && m < 70 )  
     417+       { 
     418+#ifdef IPP2P_DEBUG_SOUL 
     419+               printk(KERN_DEBUG "7: Soulseek command 0x%x recognized\n",get_u16(payload, 4)); 
     420+#endif /* IPP2P_DEBUG_SOUL */ 
     421+               return ((IPP2P_SOUL * 100) + 8); 
     422+       } 
     423+ 
     424+#ifdef IPP2P_DEBUG_SOUL 
     425+       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); 
     426+#endif /* IPP2P_DEBUG_SOUL */ 
     427+    } 
     428+        
     429+       /* match 14 00 00 00 01 yy 00 00 00 STRING(YY) 01 00 00 00 00 46|50 00 00 00 00 */ 
     430+       /* without size at the beginning !!! */ 
     431+       if ( get_u32(payload, 0) == 0x14 && get_u8(payload, 4) == 0x01 ) 
     432+       { 
     433+               __u32 y=get_u32(payload, 5); 
     434+               /* we need 19 chars + string */ 
     435+               if ( (y + 19) <= (plen) ) 
     436+               { 
     437+                       const unsigned char *w=payload+9+y; 
     438+                       if (get_u32(w, 0) == 0x01 && ( get_u16(w, 4) == 0x4600 || get_u16(w, 4) == 0x5000) && get_u32(w, 6) == 0x00); 
     439+#ifdef IPP2P_DEBUG_SOUL 
     440+                       printk(KERN_DEBUG "Soulssek special client command recognized\n"); 
     441+#endif /* IPP2P_DEBUG_SOUL */ 
     442+                       return ((IPP2P_SOUL * 100) + 9); 
     443+               } 
     444+       } 
    218445+    return 0; 
    219446+} 
     
    222449+/*Search for WinMX commands*/ 
    223450+int 
    224 +search_winmx (unsigned char *haystack, int packet_len, int head_len) 
    225 +{ 
    226 +    unsigned char *t = haystack; 
    227 +    int c; 
    228 +    t += head_len; 
    229 + 
    230 +    if (((packet_len - head_len) == 4) && (memcmp(t, "SEND", 4) == 0))  return ((IPP2P_WINMX * 100) + 1); 
    231 +    if (((packet_len - head_len) == 3) && (memcmp(t, "GET", 3) == 0))  return ((IPP2P_WINMX * 100) + 2); 
    232 +    if (packet_len < (head_len + 10)) return 0; 
    233 + 
    234 +    if ((memcmp(t, "SEND", 4) == 0) || (memcmp(t, "GET", 3) == 0)){ 
    235 +        c = head_len + 4; 
    236 +       t += 4; 
    237 +       while (c < packet_len - 5) { 
    238 +           if ((t[0] == 0x20) && (t[1] == 0x22)){ 
    239 +               c += 2; 
    240 +               t += 2; 
    241 +               while (c < packet_len - 2) { 
    242 +                   if ((t[0] == 0x22) && (t[1] == 0x20)) return ((IPP2P_WINMX * 100) + 3); 
    243 +                   t++; 
    244 +                   c++; 
     451+search_winmx (const unsigned char *payload, const u16 plen) 
     452+{ 
     453+//#define IPP2P_DEBUG_WINMX 
     454+    if (((plen) == 4) && (memcmp(payload, "SEND", 4) == 0))  return ((IPP2P_WINMX * 100) + 1); 
     455+    if (((plen) == 3) && (memcmp(payload, "GET", 3) == 0))  return ((IPP2P_WINMX * 100) + 2); 
     456+    //if (packet_len < (head_len + 10)) return 0; 
     457+    if (plen < 10) return 0; 
     458+     
     459+    if ((memcmp(payload, "SEND", 4) == 0) || (memcmp(payload, "GET", 3) == 0)){ 
     460+        u16 c=4; 
     461+        const u16 end=plen-2; 
     462+        u8 count=0; 
     463+        while (c < end) 
     464+        { 
     465+               if (payload[c]== 0x20 && payload[c+1] == 0x22) 
     466+               { 
     467+                       c++; 
     468+                       count++; 
     469+                       if (count>=2) return ((IPP2P_WINMX * 100) + 3); 
     470+               } 
     471+               c++; 
     472+        } 
     473+    } 
     474+     
     475+    if ( plen == 149 && payload[0] == '8' ) 
     476+    { 
     477+#ifdef IPP2P_DEBUG_WINMX 
     478+       printk(KERN_INFO "maybe WinMX\n"); 
     479+#endif 
     480+       if (get_u32(payload,17) == 0 && get_u32(payload,21) == 0 && get_u32(payload,25) == 0 && 
     481+//         get_u32(payload,33) == __constant_htonl(0x71182b1a) && get_u32(payload,37) == __constant_htonl(0x05050000) && 
     482+//         get_u32(payload,133) == __constant_htonl(0x31097edf) && get_u32(payload,145) == __constant_htonl(0xdcb8f792)) 
     483+           get_u16(payload,39) == 0 && get_u16(payload,135) == __constant_htons(0x7edf) && get_u16(payload,147) == __constant_htons(0xf792)) 
     484+            
     485+       { 
     486+#ifdef IPP2P_DEBUG_WINMX 
     487+               printk(KERN_INFO "got WinMX\n"); 
     488+#endif 
     489+               return ((IPP2P_WINMX * 100) + 4); 
     490+       } 
     491+    } 
     492+    return 0; 
     493+} /*search_winmx*/ 
     494+ 
     495+ 
     496+/*Search for appleJuice commands*/ 
     497+int 
     498+search_apple (const unsigned char *payload, const u16 plen) 
     499+{ 
     500+    if ( (plen > 7) && (payload[6] == 0x0d) && (payload[7] == 0x0a) && (memcmp(payload, "ajprot", 6) == 0))  return (IPP2P_APPLE * 100); 
     501+     
     502+    return 0; 
     503+} 
     504+ 
     505+ 
     506+/*Search for BitTorrent commands*/ 
     507+int 
     508+search_bittorrent (const unsigned char *payload, const u16 plen) 
     509+{ 
     510+    if (plen > 20) 
     511+    { 
     512+       /* test for match 0x13+"BitTorrent protocol" */ 
     513+       if (payload[0] == 0x13)  
     514+       { 
     515+               if (memcmp(payload+1, "BitTorrent protocol", 19) == 0) return (IPP2P_BIT * 100); 
     516+       } 
     517+        
     518+       /* get tracker commandos, all starts with GET / 
     519+       * then it can follow: scrape| announce 
     520+       * and then ?hash_info= 
     521+       */ 
     522+       if (memcmp(payload,"GET /",5) == 0) 
     523+       { 
     524+               /* message scrape */ 
     525+               if ( memcmp(payload+5,"scrape?info_hash=",17)==0 ) return (IPP2P_BIT * 100 + 1); 
     526+               /* message announce */ 
     527+               if ( memcmp(payload+5,"announce?info_hash=",19)==0 ) return (IPP2P_BIT * 100 + 2); 
     528+       } 
     529+    }  
     530+    else  
     531+    { 
     532+       /* bitcomet encryptes the first packet, so we have to detect another  
     533+        * one later in the flow */ 
     534+        /* first try failed, too many missdetections */ 
     535+       //if ( size == 5 && get_u32(t,0) == __constant_htonl(1) && t[4] < 3) return (IPP2P_BIT * 100 + 3); 
     536+        
     537+       /* second try: block request packets */ 
     538+       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); 
     539+    } 
     540+ 
     541+    return 0; 
     542+} 
     543+ 
     544+ 
     545+ 
     546+/*check for Kazaa get command*/ 
     547+int 
     548+search_kazaa (const unsigned char *payload, const u16 plen) 
     549+ 
     550+{ 
     551+    if ((payload[plen-2] == 0x0d) && (payload[plen-1] == 0x0a) && memcmp(payload, "GET /.hash=", 11) == 0) 
     552+       return (IPP2P_DATA_KAZAA * 100); 
     553+ 
     554+    return 0; 
     555+} 
     556+ 
     557+ 
     558+/*check for gnutella get command*/ 
     559+int 
     560+search_gnu (const unsigned char *payload, const u16 plen) 
     561+{ 
     562+    if ((payload[plen-2] == 0x0d) && (payload[plen-1] == 0x0a)) 
     563+    { 
     564+       if (memcmp(payload, "GET /get/", 9) == 0)       return ((IPP2P_DATA_GNU * 100) + 1); 
     565+       if (memcmp(payload, "GET /uri-res/", 13) == 0) return ((IPP2P_DATA_GNU * 100) + 2);  
     566+    } 
     567+    return 0; 
     568+} 
     569+ 
     570+ 
     571+/*check for gnutella get commands and other typical data*/ 
     572+int 
     573+search_all_gnu (const unsigned char *payload, const u16 plen) 
     574+{ 
     575+     
     576+    if ((payload[plen-2] == 0x0d) && (payload[plen-1] == 0x0a)) 
     577+    { 
     578+        
     579+       if (memcmp(payload, "GNUTELLA CONNECT/", 17) == 0) return ((IPP2P_GNU * 100) + 1); 
     580+       if (memcmp(payload, "GNUTELLA/", 9) == 0) return ((IPP2P_GNU * 100) + 2);     
     581+     
     582+     
     583+       if ((memcmp(payload, "GET /get/", 9) == 0) || (memcmp(payload, "GET /uri-res/", 13) == 0)) 
     584+       {         
     585+               u16 c=8; 
     586+               const u16 end=plen-22; 
     587+               while (c < end) { 
     588+                       if ( payload[c] == 0x0a && payload[c+1] == 0x0d && ((memcmp(&payload[c+2], "X-Gnutella-", 11) == 0) || (memcmp(&payload[c+2], "X-Queue:", 8) == 0)))  
     589+                               return ((IPP2P_GNU * 100) + 3); 
     590+                       c++; 
    245591+               } 
    246 +           } 
    247 +           t++; 
    248 +           c++; 
    249 +       }     
    250 +    } 
    251 +    return 0; 
    252 +} /*search_winmx*/ 
    253 + 
    254 + 
    255 +/*Search for appleJuice commands*/ 
    256 +int 
    257 +search_apple (unsigned char *haystack, int packet_len, int head_len) 
    258 +{ 
    259 +    unsigned char *t = haystack; 
    260 +    t += head_len; 
    261 +     
    262 +    if ((memcmp(t, "ajprot", 6) == 0) && (t[6] == 0x0d) && (t[7] == 0x0a))  return (IPP2P_APPLE * 100); 
    263 +     
    264 +    return 0; 
    265 +} 
    266 + 
    267 + 
    268 +/*Search for BitTorrent commands*/ 
    269 +int 
    270 +search_bittorrent (unsigned char *haystack, int packet_len, int head_len) 
    271 +{ 
    272 + 
    273 +    unsigned char *t = haystack; 
    274 +    if (*(haystack+head_len) != 0x13) return 0; /*Bail out of first byte != 0x13*/ 
    275 +     
    276 +    t += head_len + 1; 
    277 +     
    278 +    if (memcmp(t, "BitTorrent protocol", 19) == 0) return (IPP2P_BIT * 100); 
    279 +    return 0; 
    280 +} 
    281 + 
    282 + 
    283 + 
    284 +/*check for Kazaa get command*/ 
    285 +int 
    286 +search_kazaa (unsigned char *haystack, int packet_len, int head_len) 
    287 +{ 
    288 +    unsigned char *t = haystack; 
    289 + 
    290 +    if (!((*(haystack + packet_len - 2) == 0x0d) && (*(haystack + packet_len - 1) == 0x0a))) return 0;     
    291 + 
    292 +    t += head_len; 
    293 +    if (memcmp(t, "GET /.hash=", 11) == 0) 
    294 +       return (IPP2P_DATA_KAZAA * 100); 
    295 +    else 
    296 +       return 0; 
    297 +} 
    298 + 
    299 + 
    300 +/*check for gnutella get command*/ 
    301 +int 
    302 +search_gnu (unsigned char *haystack, int packet_len, int head_len) 
    303 +{ 
    304 +    unsigned char *t = haystack; 
    305 + 
    306 +    if (!((*(haystack + packet_len - 2) == 0x0d) && (*(haystack + packet_len - 1) == 0x0a))) return 0;     
    307 + 
    308 +    t += head_len; 
    309 +    if (memcmp(t, "GET /get/", 9) == 0)        return ((IPP2P_DATA_GNU * 100) + 1); 
    310 +    if (memcmp(t, "GET /uri-res/", 13) == 0) return ((IPP2P_DATA_GNU * 100) + 2);  
    311 +     
    312 +    return 0; 
    313 +} 
    314 + 
    315 + 
    316 +/*check for gnutella get commands and other typical data*/ 
    317 +int 
    318 +search_all_gnu (unsigned char *haystack, int packet_len, int head_len) 
    319 +{ 
    320 +    unsigned char *t = haystack; 
    321 +    int c;     
    322 + 
    323 +    if (!((*(haystack + packet_len - 2) == 0x0d) && (*(haystack + packet_len - 1) == 0x0a))) return 0; 
    324 + 
    325 +    t += head_len; 
    326 + 
    327 +    if (memcmp(t, "GNUTELLA CONNECT/", 17) == 0) return ((IPP2P_GNU * 100) + 1); 
    328 +    if (memcmp(t, "GNUTELLA/", 9) == 0) return ((IPP2P_GNU * 100) + 2);     
    329 + 
    330 +    if ((memcmp(t, "GET /get/", 9) == 0) || (memcmp(t, "GET /uri-res/", 13) == 0)) 
    331 +    {         
    332 +        c = head_len + 8; 
    333 +       t += 8; 
    334 +       while (c < packet_len - 22) { 
    335 +           if ((t[0] == 0x0d) && (t[1] == 0x0a)) { 
    336 +                   t += 2; 
    337 +                   c += 2; 
    338 +                   if ((memcmp(t, "X-Gnutella-", 11) == 0) || (memcmp(t, "X-Queue:", 8) == 0)) return ((IPP2P_GNU * 100) + 3); 
    339 +           } else { 
    340 +               t++; 
    341 +               c++; 
    342 +           }     
    343592+       } 
    344593+    } 
     
    349598+/*check for KaZaA download commands and other typical data*/ 
    350599+int 
    351 +search_all_kazaa (unsigned char *haystack, int packet_len, int head_len) 
    352 +{ 
    353 +    unsigned char *t = haystack; 
    354 +    int c;     
    355 + 
    356 +    if (!((*(haystack + packet_len - 2) == 0x0d) && (*(haystack + packet_len - 1) == 0x0a))) return 0; 
    357 + 
    358 +    t += head_len; 
    359 +    if (memcmp(t, "GIVE ", 5) == 0) return ((IPP2P_KAZAA * 100) + 1); 
    360 +     
    361 +    if (memcmp(t, "GET /", 5) == 0) { 
    362 +        c = head_len + 8; 
    363 +       t += 8; 
    364 +       while (c < packet_len - 22) { 
    365 +           if ((t[0] == 0x0d) && (t[1] == 0x0a)) { 
    366 +                   t += 2; 
    367 +                   c += 2; 
    368 +                   if ( memcmp(t, "X-Kazaa-Username: ", 18) == 0 ) return ((IPP2P_KAZAA * 100) + 2); 
    369 +                   if ( memcmp(t, "User-Agent: PeerEnabler/", 24) == 0 ) return ((IPP2P_KAZAA * 100) + 3); 
    370 +           } else { 
    371 +               t++; 
    372 +               c++; 
    373 +           }     
    374 +       } 
    375 +    } 
    376 +     
     600+search_all_kazaa (const unsigned char *payload, const u16 plen) 
     601+{ 
     602+    if ((payload[plen-2] == 0x0d) && (payload[plen-1] == 0x0a)) 
     603+    { 
     604+ 
     605+       if (memcmp(payload, "GIVE ", 5) == 0) return ((IPP2P_KAZAA * 100) + 1); 
     606+     
     607+       if (memcmp(payload, "GET /", 5) == 0) { 
     608+               u16 c = 8; 
     609+               const u16 end=plen-22; 
     610+               while (c < end) { 
     611+                       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))) 
     612+                               return ((IPP2P_KAZAA * 100) + 2); 
     613+                       c++; 
     614+               } 
     615+       } 
     616+    } 
    377617+    return 0; 
    378618+} 
     
    380620+/*fast check for edonkey file segment transfer command*/ 
    381621+int 
    382 +search_edk (unsigned char *haystack, int packet_len, int head_len) 
    383 +{ 
    384 +    if (*(haystack+head_len) != 0xe3)  
     622+search_edk (const unsigned char *payload, const u16 plen) 
     623+{ 
     624+    if (payload[0] != 0xe3)  
    385625+       return 0; 
    386626+    else { 
    387 +       if (*(haystack+head_len+5) == 0x47)  
     627+       if (payload[5] == 0x47)  
    388628+           return (IPP2P_DATA_EDK * 100); 
    389629+       else     
     
    396636+/*intensive but slower search for some edonkey packets including size-check*/ 
    397637+int 
    398 +search_all_edk (unsigned char *haystack, int packet_len, int head_len) 
    399 +{ 
    400 +    unsigned char *t = haystack; 
    401 +    int cmd; 
    402 +     
    403 +    if (*(haystack+head_len) == 0xd4) { 
    404 +       t += head_len;   
    405 +       cmd = get_u16(t, 1);     
    406 +       if (cmd == (packet_len - head_len - 5)) { 
    407 +           switch (t[5]) { 
    408 +               case 0x82: return ((IPP2P_EDK * 100) + 42); 
    409 +               case 0x15: return ((IPP2P_EDK * 100) + 43); 
    410 +               default: return 0; 
    411 +           } 
    412 +       } 
    413 +       return 0;     
    414 +    } 
    415 +     
    416 +     
    417 +    if (*(haystack+head_len) == 0xc5) {        /*search for additional eMule packets*/ 
    418 +       t += head_len;   
    419 +       cmd = get_u16(t, 1);     
    420 + 
    421 +       if (cmd == (packet_len - head_len - 5)) { 
    422 +           switch (t[5]) { 
    423 +               case 0x01: return ((IPP2P_EDK * 100) + 30); 
    424 +               case 0x02: return ((IPP2P_EDK * 100) + 31); 
    425 +               case 0x60: return ((IPP2P_EDK * 100) + 32); 
    426 +               case 0x81: return ((IPP2P_EDK * 100) + 33); 
    427 +               case 0x82: return ((IPP2P_EDK * 100) + 34); 
    428 +               case 0x85: return ((IPP2P_EDK * 100) + 35); 
    429 +               case 0x86: return ((IPP2P_EDK * 100) + 36); 
    430 +               case 0x87: return ((IPP2P_EDK * 100) + 37); 
    431 +               case 0x40: return ((IPP2P_EDK * 100) + 38); 
    432 +               case 0x92: return ((IPP2P_EDK * 100) + 39); 
    433 +               case 0x93: return ((IPP2P_EDK * 100) + 40); 
    434 +               case 0x12: return ((IPP2P_EDK * 100) + 41); 
    435 +               default: return 0; 
    436 +           } 
    437 +       } 
    438 +        
    439 +       return 0; 
    440 +    } 
    441 + 
    442 + 
    443 +    if (*(haystack+head_len) != 0xe3)  
     638+search_all_edk (const unsigned char *payload, const u16 plen) 
     639+{ 
     640+    if (payload[0] != 0xe3)  
    444641+       return 0; 
    445642+    else { 
    446 +       t += head_len;   
    447 +       cmd = get_u16(t, 1); 
    448 +       if (cmd == (packet_len - head_len - 5)) { 
    449 +           switch (t[5]) { 
     643+       //t += head_len;         
     644+       const u16 cmd = get_u16(payload, 1); 
     645+       if (cmd == (plen - 5)) { 
     646+           switch (payload[5]) { 
    450647+               case 0x01: return ((IPP2P_EDK * 100) + 1);      /*Client: hello or Server:hello*/ 
    451 +               case 0x50: return ((IPP2P_EDK * 100) + 2);      /*Client: file status*/ 
    452 +               case 0x16: return ((IPP2P_EDK * 100) + 3);      /*Client: search*/ 
    453 +               case 0x58: return ((IPP2P_EDK * 100) + 4);      /*Client: file request*/ 
    454 +               case 0x48: return ((IPP2P_EDK * 100) + 5);      /*???*/ 
    455 +               case 0x54: return ((IPP2P_EDK * 100) + 6);      /*???*/ 
    456 +               case 0x47: return ((IPP2P_EDK * 100) + 7);      /*Client: file segment request*/ 
    457 +               case 0x46: return ((IPP2P_EDK * 100) + 8);      /*Client: download segment*/ 
    458648+               case 0x4c: return ((IPP2P_EDK * 100) + 9);      /*Client: Hello-Answer*/ 
    459 +               case 0x4f: return ((IPP2P_EDK * 100) + 10);     /*Client: file status request*/ 
    460 +               case 0x59: return ((IPP2P_EDK * 100) + 11);     /*Client: file request answer*/ 
    461 +               case 0x65: return ((IPP2P_EDK * 100) + 12);     /*Client: ???*/ 
    462 +               case 0x66: return ((IPP2P_EDK * 100) + 13);     /*Client: ???*/ 
    463 +               case 0x51: return ((IPP2P_EDK * 100) + 14);     /*Client: ???*/ 
    464 +               case 0x52: return ((IPP2P_EDK * 100) + 15);     /*Client: ???*/ 
    465 +               case 0x4d: return ((IPP2P_EDK * 100) + 16);     /*Client: ???*/ 
    466 +               case 0x5c: return ((IPP2P_EDK * 100) + 17);     /*Client: ???*/ 
    467 +               case 0x38: return ((IPP2P_EDK * 100) + 18);     /*Client: ???*/ 
    468 +               case 0x69: return ((IPP2P_EDK * 100) + 19);     /*Client: ???*/ 
    469 +               case 0x19: return ((IPP2P_EDK * 100) + 20);     /*Client: ???*/ 
    470 +               case 0x42: return ((IPP2P_EDK * 100) + 21);     /*Client: ???*/ 
    471 +               case 0x34: return ((IPP2P_EDK * 100) + 22);     /*Client: ???*/ 
    472 +               case 0x94: return ((IPP2P_EDK * 100) + 23);     /*Client: ???*/ 
    473 +               case 0x1c: return ((IPP2P_EDK * 100) + 24);     /*Client: ???*/ 
    474 +               case 0x6a: return ((IPP2P_EDK * 100) + 25);     /*Client: ???*/ 
    475 +               default: return 0; 
    476649+           } 
    477 +       } else { 
    478 +           if (cmd > packet_len - head_len - 5) { 
    479 +               if ((t[3] == 0x00) && (t[4] == 0x00)) { 
    480 +                   if (t[5] == 0x01) return ((IPP2P_EDK * 100) + 26); 
    481 +                   if (t[5] == 0x4c) return ((IPP2P_EDK * 100) + 27); 
    482 +               }  
    483 +               return 0; 
    484 +                
    485 +           }   /*non edk packet*/ 
    486 +           if (t[cmd+5] == 0xe3) return ((IPP2P_EDK * 100) + 28);/*found another edk-command*/ 
    487 +           if (t[cmd+5] == 0xc5) return ((IPP2P_EDK * 100) + 29);/*found an emule-command*/         
    488 +           return 0; 
    489 +       } 
    490 +    } 
     650+       } 
     651+       return 0; 
     652+     } 
    491653+} 
    492654+ 
     
    494656+/*fast check for Direct Connect send command*/ 
    495657+int 
    496 +search_dc (unsigned char *haystack, int packet_len, int head_len) 
    497 +{ 
    498 +    unsigned char *t = haystack; 
    499 + 
    500 +    if (*(haystack+head_len) != 0x24 )  
     658+search_dc (const unsigned char *payload, const u16 plen) 
     659+{ 
     660+ 
     661+    if (payload[0] != 0x24 )  
    501662+       return 0; 
    502663+    else { 
    503 +       t += head_len + 1; 
    504 +        if (memcmp(t, "Send|", 5) == 0) 
     664+       if (memcmp(&payload[1], "Send|", 5) == 0) 
    505665+           return (IPP2P_DATA_DC * 100); 
    506666+       else 
     
    513673+/*intensive but slower check for all direct connect packets*/ 
    514674+int 
    515 +search_all_dc (unsigned char *haystack, int packet_len, int head_len) 
    516 +{ 
    517 +    unsigned char *t = haystack; 
    518 + 
    519 +    if ((*(haystack + head_len) == 0x24) && (*(haystack + packet_len - 1) == 0x7c)) { 
    520 +       t += head_len + 1; 
    521 +       if (memcmp(t, "Lock ", 5) == 0)  return ((IPP2P_DC * 100) + 1); /*hub: hello*/ 
    522 +       if (memcmp(t, "Key ", 4) == 0)   return ((IPP2P_DC * 100) + 2); /*client: hello*/ 
    523 +       if (memcmp(t, "Hello ", 6) == 0) return ((IPP2P_DC * 100) + 3); /*hub:connected*/ 
    524 +       if (memcmp(t, "MyNick ", 7) == 0) return ((IPP2P_DC * 100) + 4); /*client-client: hello*/ 
    525 +       if (memcmp(t, "Search ", 7) == 0) return ((IPP2P_DC * 100) + 5); /*client: search*/ 
    526 +       if (memcmp(t, "Send", 4) == 0)   return ((IPP2P_DC * 100) + 6); /*client: start download*/ 
     675+search_all_dc (const unsigned char *payload, const u16 plen) 
     676+{ 
     677+//    unsigned char *t = haystack; 
     678+ 
     679+    if (payload[0] == 0x24 && payload[plen-1] == 0x7c)  
     680+    { 
     681+       const unsigned char *t=&payload[1]; 
     682+               /* Client-Hub-Protocol */ 
     683+       if (memcmp(t, "Lock ", 5) == 0)                 return ((IPP2P_DC * 100) + 1); 
     684+       /* Client-Client-Protocol, some are already recognized by client-hub (like lock) */ 
     685+       if (memcmp(t, "MyNick ", 7) == 0)               return ((IPP2P_DC * 100) + 38);  
     686+    } 
     687+    return 0; 
     688+} 
     689+ 
     690+/*check for mute*/ 
     691+int 
     692+search_mute (const unsigned char *payload, const u16 plen) 
     693+{ 
     694+       if ( plen == 209 || plen == 345 || plen == 473 || plen == 609 || plen == 1121 ) 
     695+       { 
     696+               //printk(KERN_DEBUG "size hit: %u",size); 
     697+               if (memcmp(payload,"PublicKey: ",11) == 0 ) 
     698+               {  
     699+                       return ((IPP2P_MUTE * 100) + 0); 
     700+                        
     701+/*                     if (memcmp(t+size-14,"\x0aEndPublicKey\x0a",14) == 0) 
     702+                       { 
     703+                               printk(KERN_DEBUG "end pubic key hit: %u",size); 
     704+                                
     705+                       }*/ 
     706+               } 
     707+       } 
    527708+       return 0; 
    528 +    } else 
     709+} 
     710+ 
     711+ 
     712+/* check for xdcc */ 
     713+int 
     714+search_xdcc (const unsigned char *payload, const u16 plen) 
     715+{ 
     716+       /* search in small packets only */ 
     717+       if (plen > 20 && plen < 200 && payload[plen-1] == 0x0a && payload[plen-2] == 0x0d && memcmp(payload,"PRIVMSG ",8) == 0) 
     718+       { 
     719+                
     720+               u16 x=10; 
     721+               const u16 end=plen - 13; 
     722+                
     723+               /* is seems to be a irc private massage, chedck for xdcc command */ 
     724+               while (x < end) 
     725+               { 
     726+                       if (payload[x] == ':') 
     727+                       { 
     728+                               if ( memcmp(&payload[x+1],"xdcc send #",11) == 0 ) 
     729+                                       return ((IPP2P_XDCC * 100) + 0); 
     730+                       } 
     731+                       x++; 
     732+               } 
     733+       } 
     734+       return 0; 
     735+} 
     736+ 
     737+/* search for waste */ 
     738+int search_waste(const unsigned char *payload, const u16 plen) 
     739+{ 
     740+       if ( plen >= 8 && memcmp(payload,"GET.sha1:",9) == 0) 
     741+               return ((IPP2P_WASTE * 100) + 0); 
     742+ 
    529743+       return 0; 
    530744+} 
     
    535749+    __u8 short_hand;                   /*for fucntions included in short hands*/ 
    536750+    int packet_len; 
    537 +    int (*function_name) (unsigned char *, int, int); 
     751+    int (*function_name) (const unsigned char *, const u16); 
    538752+} matchlist[] = { 
    539 +    {IPP2P_EDK,SHORT_HAND_IPP2P,40, &search_all_edk}, 
    540 +    {IPP2P_DATA_KAZAA,SHORT_HAND_DATA,200, &search_kazaa}, 
    541 +    {IPP2P_DATA_EDK,SHORT_HAND_DATA,60, &search_edk}, 
    542 +    {IPP2P_DATA_DC,SHORT_HAND_DATA,26, &search_dc}, 
    543 +    {IPP2P_DC,SHORT_HAND_IPP2P,25, search_all_dc}, 
    544 +    {IPP2P_DATA_GNU,SHORT_HAND_DATA,40, &search_gnu}, 
    545 +    {IPP2P_GNU,SHORT_HAND_IPP2P,35, &search_all_gnu}, 
    546 +    {IPP2P_KAZAA,SHORT_HAND_IPP2P,35, &search_all_kazaa}, 
    547 +    {IPP2P_BIT,SHORT_HAND_NONE,40, &search_bittorrent}, 
    548 +    {IPP2P_APPLE,SHORT_HAND_NONE,20, &search_apple}, 
    549 +    {IPP2P_SOUL,SHORT_HAND_NONE,25, &search_soul}, 
    550 +    {IPP2P_WINMX,SHORT_HAND_NONE,20, &search_winmx}, 
    551 +    {IPP2P_ARES,SHORT_HAND_NONE,25, &search_ares}, 
     753+    {IPP2P_EDK,SHORT_HAND_IPP2P,20, &search_all_edk}, 
     754+//    {IPP2P_DATA_KAZAA,SHORT_HAND_DATA,200, &search_kazaa}, 
     755+//    {IPP2P_DATA_EDK,SHORT_HAND_DATA,60, &search_edk}, 
     756+//    {IPP2P_DATA_DC,SHORT_HAND_DATA,26, &search_dc}, 
     757+    {IPP2P_DC,SHORT_HAND_IPP2P,5, search_all_dc}, 
     758+//    {IPP2P_DATA_GNU,SHORT_HAND_DATA,40, &search_gnu}, 
     759+    {IPP2P_GNU,SHORT_HAND_IPP2P,5, &search_all_gnu}, 
     760+    {IPP2P_KAZAA,SHORT_HAND_IPP2P,5, &search_all_kazaa}, 
     761+    {IPP2P_BIT,SHORT_HAND_IPP2P,20, &search_bittorrent}, 
     762+    {IPP2P_APPLE,SHORT_HAND_IPP2P,5, &search_apple}, 
     763+    {IPP2P_SOUL,SHORT_HAND_IPP2P,5, &search_soul}, 
     764+    {IPP2P_WINMX,SHORT_HAND_IPP2P,2, &search_winmx}, 
     765+    {IPP2P_ARES,SHORT_HAND_IPP2P,5, &search_ares}, 
     766+    {IPP2P_MUTE,SHORT_HAND_NONE,200, &search_mute}, 
     767+    {IPP2P_WASTE,SHORT_HAND_NONE,5, &search_waste}, 
     768+    {IPP2P_XDCC,SHORT_HAND_NONE,5, &search_xdcc}, 
    552769+    {0,0,0,NULL} 
    553770+}; 
     
    561778+} udp_list[] = { 
    562779+    {IPP2P_KAZAA,SHORT_HAND_IPP2P,14, &udp_search_kazaa}, 
    563 +    {IPP2P_BIT,SHORT_HAND_NONE,23, &udp_search_bit}, 
     780+    {IPP2P_BIT,SHORT_HAND_IPP2P,23, &udp_search_bit}, 
    564781+    {IPP2P_GNU,SHORT_HAND_IPP2P,11, &udp_search_gnu}, 
    565782+    {IPP2P_EDK,SHORT_HAND_IPP2P,9, &udp_search_edk}, 
     783+    {IPP2P_DC,SHORT_HAND_IPP2P,12, &udp_search_directconnect},     
    566784+    {0,0,0,NULL} 
    567785+}; 
     
    586804+    struct iphdr *ip = skb->nh.iph; 
    587805+    int p2p_result = 0, i = 0; 
    588 +    int head_len; 
     806+//    int head_len; 
    589807+    int hlen = ntohs(ip->tot_len)-(ip->ihl*4); /*hlen = packet-data length*/ 
    590808+ 
     
    612830+           if (tcph->syn) return 0;  /*if SYN bit is set bail out*/ 
    613831+           if (tcph->rst) return 0;  /*if RST bit is set bail out*/ 
    614 +           head_len = tcph->doff * 4; /*get TCP-Header-Size*/ 
     832+            
     833+           haystack += tcph->doff * 4; /*get TCP-Header-Size*/ 
     834+           hlen -= tcph->doff * 4; 
    615835+           while (matchlist[i].command) { 
    616836+               if ((((info->cmd & matchlist[i].command) == matchlist[i].command) || 
    617837+                   ((info->cmd & matchlist[i].short_hand) == matchlist[i].short_hand)) && 
    618838+                   (hlen > matchlist[i].packet_len)) { 
    619 +                           p2p_result = matchlist[i].function_name(haystack, hlen, head_len); 
     839+                           p2p_result = matchlist[i].function_name(haystack, hlen); 
    620840+                           if (p2p_result)  
    621841+                           { 
     
    708928+ 
    709929+ 
    710 diff -urN linux-2.4.29.old/net/ipv4/netfilter/Makefile linux-2.4.29/net/ipv4/netfilter/Makefile 
    711 --- linux-2.4.29.old/net/ipv4/netfilter/Makefile        2005-03-12 00:40:38.000000000 +0100 
    712 +++ linux-2.4.29/net/ipv4/netfilter/Makefile    2005-03-12 00:42:57.000000000 +0100 
    713 @@ -67,6 +67,7 @@ 
    714  obj-$(CONFIG_IP_NF_MATCH_LIMIT) += ipt_limit.o 
    715  obj-$(CONFIG_IP_NF_MATCH_MARK) += ipt_mark.o 
    716  obj-$(CONFIG_IP_NF_MATCH_MAC) += ipt_mac.o 
    717 +obj-$(CONFIG_IP_NF_MATCH_IPP2P) += ipt_ipp2p.o 
    718   
    719  obj-$(CONFIG_IP_NF_MATCH_PKTTYPE) += ipt_pkttype.o 
    720  obj-$(CONFIG_IP_NF_MATCH_MULTIPORT) += ipt_multiport.o 
  • trunk/openwrt/target/linux/x86-2.6/config

    r3425 r3463  
    391391# CONFIG_IP_NF_MATCH_LAYER7_DEBUG is not set 
    392392CONFIG_IP_NF_MATCH_MULTIPORT=m 
     393CONFIG_IP_NF_MATCH_IPP2P=m 
    393394CONFIG_IP_NF_MATCH_TOS=m 
    394395CONFIG_IP_NF_MATCH_TIME=m 
Note: See TracChangeset for help on using the changeset viewer.