mirror of
https://github.com/vincentmli/bpfire.git
synced 2026-04-09 18:45:54 +02:00
Kernel-Update und umfassende Arbeiten daran.
git-svn-id: http://svn.ipfire.org/svn/ipfire/trunk@365 ea5c0bd1-69bd-2848-81d8-4f18e57aeed8
This commit is contained in:
ms
@@ -97,6 +97,8 @@
|
||||
* inetutils-1.4.2
|
||||
* ipac-ng-1.31
|
||||
* ipaddr-1.2
|
||||
* ipp2p-0.8.2
|
||||
* ipp2p-0.8.2-iptables
|
||||
* iproute2-2.6.16-060323
|
||||
* iptables-1.3.5
|
||||
* iptraf-3.0.0
|
||||
@@ -125,7 +127,7 @@
|
||||
* libvorbis-1.1.2
|
||||
* libwww-perl-5.803
|
||||
* libxml2-2.6.26
|
||||
* linux-2.6.16.27-ipfire
|
||||
* linux-2.6.16.29-ipfire
|
||||
* linux-libc-headers-2.6.12.0
|
||||
* logrotate-3.7.1
|
||||
* logwatch_7.3.1
|
||||
|
||||
78
lfs/ipp2p
Normal file
78
lfs/ipp2p
Normal file
@@ -0,0 +1,78 @@
|
||||
###############################################################################
|
||||
# This file is part of the IPCop Firewall. #
|
||||
# #
|
||||
# IPCop is free software; you can redistribute it and/or modify #
|
||||
# it under the terms of the GNU General Public License as published by #
|
||||
# the Free Software Foundation; either version 2 of the License, or #
|
||||
# (at your option) any later version. #
|
||||
# #
|
||||
# IPCop is distributed in the hope that it will be useful, #
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of #
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
|
||||
# GNU General Public License for more details. #
|
||||
# #
|
||||
# You should have received a copy of the GNU General Public License #
|
||||
# along with IPCop; if not, write to the Free Software #
|
||||
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA #
|
||||
# #
|
||||
# Makefiles are based on LFSMake, which is #
|
||||
# Copyright (C) 2002 Rod Roard <rod@sunsetsystems.com> #
|
||||
# #
|
||||
###############################################################################
|
||||
|
||||
###############################################################################
|
||||
# Definitions
|
||||
###############################################################################
|
||||
|
||||
include Config
|
||||
|
||||
VER = 0.8.2
|
||||
|
||||
THISAPP = ipp2p-$(VER)
|
||||
DIR_APP = $(DIR_SRC)/$(THISAPP)
|
||||
|
||||
ifeq "$(SMP)" "1"
|
||||
TARGET = $(DIR_INFO)/$(THISAPP)-smp
|
||||
else
|
||||
ifeq "$(IPT)" "1"
|
||||
TARGET = $(DIR_INFO)/$(THISAPP)-iptables
|
||||
else
|
||||
TARGET = $(DIR_INFO)/$(THISAPP)
|
||||
endif
|
||||
endif
|
||||
|
||||
###############################################################################
|
||||
# Top-level Rules
|
||||
###############################################################################
|
||||
|
||||
install : $(TARGET)
|
||||
|
||||
check :
|
||||
|
||||
download :
|
||||
|
||||
md5 :
|
||||
|
||||
###############################################################################
|
||||
# Installation Details
|
||||
###############################################################################
|
||||
|
||||
$(TARGET) :
|
||||
@$(PREBUILD)
|
||||
@rm -rf $(DIR_APP) && mkdir -p $(DIR_APP)
|
||||
@cp -vf $(DIR_SRC)/src/ipp2p/* $(DIR_APP)
|
||||
cd $(DIR_SRC) && rm -rf iptables-*
|
||||
cd $(DIR_SRC) && tar xfj $(DIR_DL)/iptables-1.3.5.tar.bz2
|
||||
cd $(DIR_SRC) && ln -sf iptables-1.3.5 iptables
|
||||
cd $(DIR_APP) && make
|
||||
ifeq "$(SMP)" "1"
|
||||
cp -f $(DIR_APP)/ipt_ipp2p.ko /lib/modules/$(KVER)-smp/kernel/net/ipv4/netfilter
|
||||
else
|
||||
ifeq "$(IPT)" "1"
|
||||
cp -f $(DIR_APP)/libipt_ipp2p.o /lib/iptables
|
||||
else
|
||||
cp -f $(DIR_APP)/ipt_ipp2p.ko /lib/modules/$(KVER)/kernel/net/ipv4/netfilter
|
||||
endif
|
||||
endif
|
||||
@rm -rf $(DIR_APP) $(DIR_SRC)/iptables-*
|
||||
@$(POSTBUILD)
|
||||
24
lfs/linux
24
lfs/linux
@@ -27,7 +27,7 @@
|
||||
include Config
|
||||
|
||||
VER = 2.6.16
|
||||
PATCHLEVEL = 2.6.16.27
|
||||
PATCHLEVEL = 2.6.16.29
|
||||
|
||||
THISAPP = linux-$(VER)
|
||||
DL_FILE = $(THISAPP).tar.gz
|
||||
@@ -68,7 +68,7 @@ net4801.kernel.patch_2.4.31 = $(URL_IPFIRE)/net4801.kernel.patch_2.4.31
|
||||
netfilter-layer7-v2.6.tar.gz = $(URL_IPFIRE)/netfilter-layer7-v2.6.tar.gz
|
||||
|
||||
$(DL_FILE)_MD5 = 50695965725367f39007023feac5e256
|
||||
patch-$(PATCHLEVEL).gz_MD5 = 4b09dd018286850c20c0f051ced7b583
|
||||
patch-$(PATCHLEVEL).gz_MD5 = 1355ebc25ea57df398d20e1c1726ec9b
|
||||
openswan-2.4.7.kernel-2.6-natt.patch.gz_MD5 = 980d8bbdb29a761b7f5aa852f373df62
|
||||
openswan-2.4.7.kernel-2.6-klips.patch.gz_MD5 = 5df0ffa2453488a407a23fc4ea4af879
|
||||
patch-o-matic-ng-20061210.tar.bz2_MD5 = 76edac76301b45f89e467b41c8cf4393
|
||||
@@ -130,32 +130,18 @@ $(TARGET) : $(patsubst %,$(DIR_DL)/%,$(objects))
|
||||
cd $(DIR_SRC) && ln -sf iptables-1.3.5 iptables
|
||||
cd $(DIR_SRC) && rm -rf patch-o-matic*
|
||||
cd $(DIR_SRC) && tar xfj $(DIR_DL)/patch-o-matic-ng-20061210.tar.bz2
|
||||
|
||||
cd $(DIR_SRC)/patch-o-matic-ng* && \
|
||||
./runme --batch --kernel-path=$(ROOT)/usr/src/$(THISAPP)/ --iptables-path=$(ROOT)/usr/src/iptables/ \
|
||||
TARPIT h323-conntrack-nat cuseeme-nat \
|
||||
sip-conntrack-nat
|
||||
# rtsp-conntrack-nat quake3-conntrack-nat mms-conntrack-nat
|
||||
sip-conntrack-nat rtsp-conntrack-nat \
|
||||
mms-conntrack-nat #quake3-conntrack-nat
|
||||
|
||||
# cd $(DIR_SRC)/patch-o-matic* && yes 'y' | ./runme --kernel-path=$(DIR_APP) --iptables-path=$(ROOT)/usr/src/iptables/ pending
|
||||
# cd $(DIR_SRC)/patch-o-matic* && yes 'y' | ./runme --kernel-path=$(DIR_APP) --iptables-path=$(ROOT)/usr/src/iptables/ base
|
||||
# cd $(DIR_SRC)/patch-o-matic* && yes 'y' | ./runme --kernel-path=$(DIR_APP) --iptables-path=$(ROOT)/usr/src/iptables/ mms-conntrack-nat
|
||||
# cd $(DIR_SRC)/patch-o-matic* && yes 'y' | ./runme --kernel-path=$(DIR_APP) --iptables-path=$(ROOT)/usr/src/iptables/ pptp-conntrack-nat
|
||||
# cd $(DIR_SRC)/patch-o-matic* && yes 'y' | ./runme --kernel-path=$(DIR_APP) --iptables-path=$(ROOT)/usr/src/iptables/ rtsp-conntrack
|
||||
# cd $(DIR_SRC)/patch-o-matic* && yes 'y' | ./runme --kernel-path=$(DIR_APP) --iptables-path=$(ROOT)/usr/src/iptables/ quake3-conntrack-nat
|
||||
# cd $(DIR_SRC)/patch-o-matic* && yes 'y' | ./runme --kernel-path=$(DIR_APP) --iptables-path=$(ROOT)/usr/src/iptables/ ip_queue_vwmark
|
||||
# cd $(DIR_SRC)/patch-o-matic* && yes 'y' | ./runme --kernel-path=$(DIR_APP) --iptables-path=$(ROOT)/usr/src/iptables/ ipp2p
|
||||
# cd $(DIR_SRC)/patch-o-matic* && yes 'y' | ./runme --kernel-path=$(DIR_APP) --iptables-path=$(ROOT)/usr/src/iptables/ ipsec-01-output-hooks
|
||||
# cd $(DIR_SRC)/patch-o-matic* && yes 'y' | ./runme --kernel-path=$(DIR_APP) --iptables-path=$(ROOT)/usr/src/iptables/ ipsec-02-input-hooks
|
||||
# cd $(DIR_SRC)/patch-o-matic* && yes 'y' | ./runme --kernel-path=$(DIR_APP) --iptables-path=$(ROOT)/usr/src/iptables/ ipsec-03-policy-lookup
|
||||
# cd $(DIR_SRC)/patch-o-matic* && yes 'y' | ./runme --kernel-path=$(DIR_APP) --iptables-path=$(ROOT)/usr/src/iptables/ ipsec-04-policy-checks
|
||||
|
||||
# Layer7-patch
|
||||
cd $(DIR_SRC) && tar xzf $(DIR_DL)/netfilter-layer7-v2.6.tar.gz
|
||||
cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/netfilter-layer7-v2.6/for_older_kernels/kernel-2.6.13-2.6.16-layer7-2.2.patch
|
||||
|
||||
# ip_conntrack permissions from 440 to 444
|
||||
# cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/ip_conntrack_standalone-patch-for-ipfire.patch
|
||||
cd $(DIR_APP) && patch -Np0 < $(DIR_SRC)/src/patches/ip_conntrack_standalone-patch-for-ipfire.patch
|
||||
|
||||
ifeq "$(SMP)" ""
|
||||
# Only do this once on the non-SMP pass
|
||||
|
||||
3
make.sh
3
make.sh
@@ -325,6 +325,7 @@ buildipfire() {
|
||||
ipfiremake rp-pppoe
|
||||
ipfiremake unzip
|
||||
ipfiremake linux SMP=1
|
||||
ipfiremake ipp2p SMP=1
|
||||
# ipfiremake 3cp4218 PASS=SMP
|
||||
# ipfiremake amedyn PASS=SMP
|
||||
# ipfiremake cxacru PASS=SMP
|
||||
@@ -342,6 +343,7 @@ buildipfire() {
|
||||
# ipfiremake promise-sata-300-tx PASS=SMP
|
||||
ipfiremake zaptel PASS=S
|
||||
ipfiremake linux
|
||||
ipfiremake ipp2p
|
||||
# ipfiremake 3cp4218
|
||||
# ipfiremake amedyn
|
||||
# ipfiremake cxacru
|
||||
@@ -409,6 +411,7 @@ buildipfire() {
|
||||
ipfiremake ibod
|
||||
ipfiremake initscripts
|
||||
ipfiremake iptables
|
||||
ipfiremake ipp2p IPT=1
|
||||
ipfiremake ipac-ng
|
||||
ipfiremake ipaddr
|
||||
ipfiremake iptstate
|
||||
|
||||
71
src/ipp2p/Makefile
Normal file
71
src/ipp2p/Makefile
Normal file
@@ -0,0 +1,71 @@
|
||||
ifneq ($(KERNELRELEASE),)
|
||||
obj-m := ipt_ipp2p.o
|
||||
|
||||
else
|
||||
|
||||
KERNEL_SRC ?= $(firstword $(wildcard /lib/modules/$(shell uname -r)/build /usr/src/linux))
|
||||
ifeq ($(KERNEL_SRC),)
|
||||
$(error You need to define KERNEL_SRC)
|
||||
endif
|
||||
|
||||
ifneq ($wildcard $(KERNEL_SRC)/include/linux/modversions.h),)
|
||||
MODVERSIONS = -DMODVERSIONS
|
||||
endif
|
||||
|
||||
_KVER = $(strip $(shell cat $(KERNEL_SRC)/Makefile | grep -e '^VERSION' | cut -d"=" -f2))
|
||||
_KPL = $(strip $(shell cat $(KERNEL_SRC)/Makefile | grep -e '^PATCHLEVEL' | cut -d"=" -f2))
|
||||
_KSUB = $(strip $(shell cat $(KERNEL_SRC)/Makefile | grep -e '^SUBLEVEL' | cut -d"=" -f2))
|
||||
KERNEL_SERIES=$(_KVER).$(_KPL)
|
||||
|
||||
ifeq ($(KERNEL_SERIES), 2.6)
|
||||
TARGET=ipt_ipp2p.ko
|
||||
else
|
||||
TARGET=ipt_ipp2p.o
|
||||
endif
|
||||
|
||||
SED = sed
|
||||
IPTABLES_BIN = iptables
|
||||
|
||||
ifndef $(IPTABLES_SRC)
|
||||
IPTVER = \
|
||||
$(shell $(IPTABLES_BIN) --version | $(SED) -e 's/^iptables v//')
|
||||
IPTABLES_SRC = $(wildcard /usr/src/iptables-$(IPTVER))
|
||||
endif
|
||||
|
||||
ifeq ($(IPTABLES_SRC),)
|
||||
$(warning You need to install iptables sources and maybe set IPTABLES_SRC)
|
||||
endif
|
||||
|
||||
IPTABLES_INCLUDE = -I$(IPTABLES_SRC)/include
|
||||
|
||||
ifneq ($(IPTVER),)
|
||||
IPTABLES_VERSION = $(IPTVER)
|
||||
else
|
||||
IPTABLES_VERSION = $(shell cat $(IPTABLES_SRC)/Makefile | grep -e '^IPTABLES_VERSION:=' | cut -d"=" -f2)
|
||||
endif
|
||||
|
||||
IPTABLES_OPTION = -DIPTABLES_VERSION=\"$(IPTABLES_VERSION)\"
|
||||
|
||||
CC = gcc
|
||||
CFLAGS = -O2 -march=i586 -pipe -fomit-frame-pointer
|
||||
|
||||
|
||||
|
||||
all: modules libipt_ipp2p.so
|
||||
|
||||
modules: $(TARGET)
|
||||
|
||||
ipt_ipp2p.o: ipt_ipp2p.h ipt_ipp2p.c
|
||||
$(CC) $(CFLAGS) -I$(KERNEL_SRC)/include -c ipt_ipp2p.c -D__KERNEL__ -DMODULE $(MODVERSIONS)
|
||||
|
||||
ipt_ipp2p.ko: ipt_ipp2p.h ipt_ipp2p.c
|
||||
$(MAKE) -C $(KERNEL_SRC) SUBDIRS=$(PWD) modules
|
||||
|
||||
|
||||
libipt_ipp2p.so: libipt_ipp2p.c ipt_ipp2p.h
|
||||
$(CC) $(CFLAGS) $(IPTABLES_OPTION) $(IPTABLES_INCLUDE) -fPIC -c libipt_ipp2p.c
|
||||
ld -shared -o libipt_ipp2p.so libipt_ipp2p.o
|
||||
|
||||
clean:
|
||||
-rm -f *.o *.so *.ko .*.cmd *.mod.c
|
||||
endif
|
||||
895
src/ipp2p/ipt_ipp2p.c
Normal file
895
src/ipp2p/ipt_ipp2p.c
Normal file
@@ -0,0 +1,895 @@
|
||||
#if defined(MODVERSIONS)
|
||||
#include <linux/modversions.h>
|
||||
#endif
|
||||
#include <linux/module.h>
|
||||
#include <linux/netfilter_ipv4/ip_tables.h>
|
||||
#include <linux/version.h>
|
||||
//#include <linux/netfilter_ipv4/ipt_ipp2p.h>
|
||||
#include "ipt_ipp2p.h"
|
||||
#include <net/tcp.h>
|
||||
#include <net/udp.h>
|
||||
|
||||
#define get_u8(X,O) (*(__u8 *)(X + O))
|
||||
#define get_u16(X,O) (*(__u16 *)(X + O))
|
||||
#define get_u32(X,O) (*(__u32 *)(X + O))
|
||||
|
||||
MODULE_AUTHOR("Eicke Friedrich/Klaus Degner <ipp2p@ipp2p.org>");
|
||||
MODULE_DESCRIPTION("An extension to iptables to identify P2P traffic.");
|
||||
MODULE_LICENSE("GPL");
|
||||
|
||||
|
||||
/*Search for UDP eDonkey/eMule/Kad commands*/
|
||||
int
|
||||
udp_search_edk (unsigned char *haystack, int packet_len)
|
||||
{
|
||||
unsigned char *t = haystack;
|
||||
t += 8;
|
||||
|
||||
switch (t[0]) {
|
||||
case 0xe3:
|
||||
{ /*edonkey*/
|
||||
switch (t[1])
|
||||
{
|
||||
/* client -> server status request */
|
||||
case 0x96:
|
||||
if (packet_len == 14) return ((IPP2P_EDK * 100) + 50);
|
||||
break;
|
||||
/* server -> client status request */
|
||||
case 0x97: if (packet_len == 42) return ((IPP2P_EDK * 100) + 51);
|
||||
break;
|
||||
/* server description request */
|
||||
/* e3 2a ff f0 .. | size == 6 */
|
||||
case 0xa2: if ( (packet_len == 14) && ( get_u16(t,2) == __constant_htons(0xfff0) ) ) return ((IPP2P_EDK * 100) + 52);
|
||||
break;
|
||||
/* server description response */
|
||||
/* e3 a3 ff f0 .. | size > 40 && size < 200 */
|
||||
//case 0xa3: return ((IPP2P_EDK * 100) + 53);
|
||||
// break;
|
||||
case 0x9a: if (packet_len==26) return ((IPP2P_EDK * 100) + 54);
|
||||
break;
|
||||
|
||||
case 0x92: if (packet_len==18) return ((IPP2P_EDK * 100) + 55);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 0xe4:
|
||||
{
|
||||
switch (t[1])
|
||||
{
|
||||
/* e4 20 .. | size == 43 */
|
||||
case 0x20: if ((packet_len == 43) && (t[2] != 0x00) && (t[34] != 0x00)) return ((IPP2P_EDK * 100) + 60);
|
||||
break;
|
||||
/* e4 00 .. 00 | size == 35 ? */
|
||||
case 0x00: if ((packet_len == 35) && (t[26] == 0x00)) return ((IPP2P_EDK * 100) + 61);
|
||||
break;
|
||||
/* e4 10 .. 00 | size == 35 ? */
|
||||
case 0x10: if ((packet_len == 35) && (t[26] == 0x00)) return ((IPP2P_EDK * 100) + 62);
|
||||
break;
|
||||
/* e4 18 .. 00 | size == 35 ? */
|
||||
case 0x18: if ((packet_len == 35) && (t[26] == 0x00)) return ((IPP2P_EDK * 100) + 63);
|
||||
break;
|
||||
/* e4 52 .. | size = 44 */
|
||||
case 0x52: if (packet_len == 44 ) return ((IPP2P_EDK * 100) + 64);
|
||||
break;
|
||||
/* e4 58 .. | size == 6 */
|
||||
case 0x58: if (packet_len == 14 ) return ((IPP2P_EDK * 100) + 65);
|
||||
break;
|
||||
/* e4 59 .. | size == 2 */
|
||||
case 0x59: if (packet_len == 10 )return ((IPP2P_EDK * 100) + 66);
|
||||
break;
|
||||
/* e4 28 .. | packet_len == 52,77,102,127... */
|
||||
case 0x28: if (((packet_len-52) % 25) == 0) return ((IPP2P_EDK * 100) + 67);
|
||||
break;
|
||||
/* e4 50 xx xx | size == 4 */
|
||||
case 0x50: if (packet_len == 12) return ((IPP2P_EDK * 100) + 68);
|
||||
break;
|
||||
/* e4 40 xx xx | size == 48 */
|
||||
case 0x40: if (packet_len == 56) return ((IPP2P_EDK * 100) + 69);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
} /* end of switch (t[0]) */
|
||||
return 0;
|
||||
}/*udp_search_edk*/
|
||||
|
||||
|
||||
/*Search for UDP Gnutella commands*/
|
||||
int
|
||||
udp_search_gnu (unsigned char *haystack, int packet_len)
|
||||
{
|
||||
unsigned char *t = haystack;
|
||||
t += 8;
|
||||
|
||||
if (memcmp(t, "GND", 3) == 0) return ((IPP2P_GNU * 100) + 51);
|
||||
if (memcmp(t, "GNUTELLA ", 9) == 0) return ((IPP2P_GNU * 100) + 52);
|
||||
return 0;
|
||||
}/*udp_search_gnu*/
|
||||
|
||||
|
||||
/*Search for UDP KaZaA commands*/
|
||||
int
|
||||
udp_search_kazaa (unsigned char *haystack, int packet_len)
|
||||
{
|
||||
unsigned char *t = haystack;
|
||||
|
||||
if (t[packet_len-1] == 0x00){
|
||||
t += (packet_len - 6);
|
||||
if (memcmp(t, "KaZaA", 5) == 0) return (IPP2P_KAZAA * 100 +50);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}/*udp_search_kazaa*/
|
||||
|
||||
/*Search for UDP DirectConnect commands*/
|
||||
int
|
||||
udp_search_directconnect (unsigned char *haystack, int packet_len)
|
||||
{
|
||||
unsigned char *t = haystack;
|
||||
if ((*(t + 8) == 0x24) && (*(t + packet_len - 1) == 0x7c)) {
|
||||
t+=8;
|
||||
if (memcmp(t, "SR ", 3) == 0) return ((IPP2P_DC * 100) + 60);
|
||||
if (memcmp(t, "Ping ", 5) == 0) return ((IPP2P_DC * 100) + 61);
|
||||
}
|
||||
return 0;
|
||||
}/*udp_search_directconnect*/
|
||||
|
||||
|
||||
|
||||
/*Search for UDP BitTorrent commands*/
|
||||
int
|
||||
udp_search_bit (unsigned char *haystack, int packet_len)
|
||||
{
|
||||
switch(packet_len)
|
||||
{
|
||||
case 24:
|
||||
/* ^ 00 00 04 17 27 10 19 80 */
|
||||
if ((ntohl(get_u32(haystack, 8)) == 0x00000417) && (ntohl(get_u32(haystack, 12)) == 0x27101980))
|
||||
return (IPP2P_BIT * 100 + 50);
|
||||
break;
|
||||
case 44:
|
||||
if (get_u32(haystack, 16) == __constant_htonl(0x00000400) && get_u32(haystack, 36) == __constant_htonl(0x00000104))
|
||||
return (IPP2P_BIT * 100 + 51);
|
||||
if (get_u32(haystack, 16) == __constant_htonl(0x00000400))
|
||||
return (IPP2P_BIT * 100 + 61);
|
||||
break;
|
||||
case 65:
|
||||
if (get_u32(haystack, 16) == __constant_htonl(0x00000404) && get_u32(haystack, 36) == __constant_htonl(0x00000104))
|
||||
return (IPP2P_BIT * 100 + 52);
|
||||
if (get_u32(haystack, 16) == __constant_htonl(0x00000404))
|
||||
return (IPP2P_BIT * 100 + 62);
|
||||
break;
|
||||
case 67:
|
||||
if (get_u32(haystack, 16) == __constant_htonl(0x00000406) && get_u32(haystack, 36) == __constant_htonl(0x00000104))
|
||||
return (IPP2P_BIT * 100 + 53);
|
||||
if (get_u32(haystack, 16) == __constant_htonl(0x00000406))
|
||||
return (IPP2P_BIT * 100 + 63);
|
||||
break;
|
||||
case 211:
|
||||
if (get_u32(haystack, 8) == __constant_htonl(0x00000405))
|
||||
return (IPP2P_BIT * 100 + 54);
|
||||
break;
|
||||
case 29:
|
||||
if ((get_u32(haystack, 8) == __constant_htonl(0x00000401)))
|
||||
return (IPP2P_BIT * 100 + 55);
|
||||
break;
|
||||
case 52:
|
||||
if (get_u32(haystack,8) == __constant_htonl(0x00000827) &&
|
||||
get_u32(haystack,12) == __constant_htonl(0x37502950))
|
||||
return (IPP2P_BIT * 100 + 80);
|
||||
break;
|
||||
default:
|
||||
/* this packet does not have a constant size */
|
||||
if (packet_len >= 40 && get_u32(haystack, 16) == __constant_htonl(0x00000402) && get_u32(haystack, 36) == __constant_htonl(0x00000104))
|
||||
return (IPP2P_BIT * 100 + 56);
|
||||
break;
|
||||
}
|
||||
|
||||
/* some extra-bitcomet rules:
|
||||
* "d1:" [a|r] "d2:id20:"
|
||||
*/
|
||||
if (packet_len > 30 && get_u8(haystack, 8) == 'd' && get_u8(haystack, 9) == '1' && get_u8(haystack, 10) == ':' )
|
||||
{
|
||||
if (get_u8(haystack, 11) == 'a' || get_u8(haystack, 11) == 'r')
|
||||
{
|
||||
if (memcmp(haystack+12,"d2:id20:",8)==0)
|
||||
return (IPP2P_BIT * 100 + 57);
|
||||
}
|
||||
}
|
||||
|
||||
#if 0
|
||||
/* bitlord rules */
|
||||
/* packetlen must be bigger than 40 */
|
||||
/* first 4 bytes are zero */
|
||||
if (packet_len > 40 && get_u32(haystack, 8) == 0x00000000)
|
||||
{
|
||||
/* first rule: 00 00 00 00 01 00 00 xx xx xx xx 00 00 00 00*/
|
||||
if (get_u32(haystack, 12) == 0x00000000 &&
|
||||
get_u32(haystack, 16) == 0x00010000 &&
|
||||
get_u32(haystack, 24) == 0x00000000 )
|
||||
return (IPP2P_BIT * 100 + 71);
|
||||
|
||||
/* 00 01 00 00 0d 00 00 xx xx xx xx 00 00 00 00*/
|
||||
if (get_u32(haystack, 12) == 0x00000001 &&
|
||||
get_u32(haystack, 16) == 0x000d0000 &&
|
||||
get_u32(haystack, 24) == 0x00000000 )
|
||||
return (IPP2P_BIT * 100 + 71);
|
||||
|
||||
|
||||
}
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}/*udp_search_bit*/
|
||||
|
||||
|
||||
|
||||
/*Search for Ares commands*/
|
||||
//#define IPP2P_DEBUG_ARES
|
||||
int
|
||||
search_ares (const unsigned char *payload, const u16 plen)
|
||||
//int search_ares (unsigned char *haystack, int packet_len, int head_len)
|
||||
{
|
||||
// const unsigned char *t = haystack + head_len;
|
||||
|
||||
/* all ares packets start with */
|
||||
if (payload[1] == 0 && (plen - payload[0]) == 3)
|
||||
{
|
||||
switch (payload[2])
|
||||
{
|
||||
case 0x5a:
|
||||
/* ares connect */
|
||||
if ( plen == 6 && payload[5] == 0x05 ) return ((IPP2P_ARES * 100) + 1);
|
||||
break;
|
||||
case 0x09:
|
||||
/* ares search, min 3 chars --> 14 bytes
|
||||
* lets define a search can be up to 30 chars --> max 34 bytes
|
||||
*/
|
||||
if ( plen >= 14 && plen <= 34 ) return ((IPP2P_ARES * 100) + 1);
|
||||
break;
|
||||
#ifdef IPP2P_DEBUG_ARES
|
||||
default:
|
||||
printk(KERN_DEBUG "Unknown Ares command %x recognized, len: %u \n", (unsigned int) payload[2],plen);
|
||||
#endif /* IPP2P_DEBUG_ARES */
|
||||
}
|
||||
}
|
||||
|
||||
#if 0
|
||||
/* found connect packet: 03 00 5a 04 03 05 */
|
||||
/* new version ares 1.8: 03 00 5a xx xx 05 */
|
||||
if ((plen) == 6){ /* possible connect command*/
|
||||
if ((payload[0] == 0x03) && (payload[1] == 0x00) && (payload[2] == 0x5a) && (payload[5] == 0x05))
|
||||
return ((IPP2P_ARES * 100) + 1);
|
||||
}
|
||||
if ((plen) == 60){ /* possible download command*/
|
||||
if ((payload[59] == 0x0a) && (payload[58] == 0x0a)){
|
||||
if (memcmp(t, "PUSH SHA1:", 10) == 0) /* found download command */
|
||||
return ((IPP2P_ARES * 100) + 2);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
} /*search_ares*/
|
||||
|
||||
/*Search for SoulSeek commands*/
|
||||
int
|
||||
search_soul (const unsigned char *payload, const u16 plen)
|
||||
{
|
||||
//#define IPP2P_DEBUG_SOUL
|
||||
/* match: xx xx xx xx | xx = sizeof(payload) - 4 */
|
||||
if (get_u32(payload, 0) == (plen - 4)){
|
||||
const __u32 m=get_u32(payload, 4);
|
||||
/* match 00 yy yy 00, yy can be everything */
|
||||
if ( get_u8(payload, 4) == 0x00 && get_u8(payload, 7) == 0x00 )
|
||||
{
|
||||
#ifdef IPP2P_DEBUG_SOUL
|
||||
printk(KERN_DEBUG "0: Soulseek command 0x%x recognized\n",get_u32(payload, 4));
|
||||
#endif /* IPP2P_DEBUG_SOUL */
|
||||
return ((IPP2P_SOUL * 100) + 1);
|
||||
}
|
||||
|
||||
/* next match: 01 yy 00 00 | yy can be everything */
|
||||
if ( get_u8(payload, 4) == 0x01 && get_u16(payload, 6) == 0x0000 )
|
||||
{
|
||||
#ifdef IPP2P_DEBUG_SOUL
|
||||
printk(KERN_DEBUG "1: Soulseek command 0x%x recognized\n",get_u16(payload, 4));
|
||||
#endif /* IPP2P_DEBUG_SOUL */
|
||||
return ((IPP2P_SOUL * 100) + 2);
|
||||
}
|
||||
|
||||
/* 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 */
|
||||
/* try to do this in an intelligent way */
|
||||
/* get all small commandos */
|
||||
switch(m)
|
||||
{
|
||||
case 7:
|
||||
case 9:
|
||||
case 22:
|
||||
case 23:
|
||||
case 26:
|
||||
case 28:
|
||||
case 50:
|
||||
case 51:
|
||||
case 60:
|
||||
case 91:
|
||||
case 92:
|
||||
case 1001:
|
||||
#ifdef IPP2P_DEBUG_SOUL
|
||||
printk(KERN_DEBUG "2: Soulseek command 0x%x recognized\n",get_u16(payload, 4));
|
||||
#endif /* IPP2P_DEBUG_SOUL */
|
||||
return ((IPP2P_SOUL * 100) + 3);
|
||||
}
|
||||
|
||||
if (m > 0 && m < 6 )
|
||||
{
|
||||
#ifdef IPP2P_DEBUG_SOUL
|
||||
printk(KERN_DEBUG "3: Soulseek command 0x%x recognized\n",get_u16(payload, 4));
|
||||
#endif /* IPP2P_DEBUG_SOUL */
|
||||
return ((IPP2P_SOUL * 100) + 4);
|
||||
}
|
||||
if (m > 12 && m < 19 )
|
||||
{
|
||||
#ifdef IPP2P_DEBUG_SOUL
|
||||
printk(KERN_DEBUG "4: Soulseek command 0x%x recognized\n",get_u16(payload, 4));
|
||||
#endif /* IPP2P_DEBUG_SOUL */
|
||||
return ((IPP2P_SOUL * 100) + 5);
|
||||
}
|
||||
|
||||
if (m > 34 && m < 38 )
|
||||
{
|
||||
#ifdef IPP2P_DEBUG_SOUL
|
||||
printk(KERN_DEBUG "5: Soulseek command 0x%x recognized\n",get_u16(payload, 4));
|
||||
#endif /* IPP2P_DEBUG_SOUL */
|
||||
return ((IPP2P_SOUL * 100) + 6);
|
||||
}
|
||||
|
||||
if (m > 39 && m < 47 )
|
||||
{
|
||||
#ifdef IPP2P_DEBUG_SOUL
|
||||
printk(KERN_DEBUG "6: Soulseek command 0x%x recognized\n",get_u16(payload, 4));
|
||||
#endif /* IPP2P_DEBUG_SOUL */
|
||||
return ((IPP2P_SOUL * 100) + 7);
|
||||
}
|
||||
|
||||
if (m > 61 && m < 70 )
|
||||
{
|
||||
#ifdef IPP2P_DEBUG_SOUL
|
||||
printk(KERN_DEBUG "7: Soulseek command 0x%x recognized\n",get_u16(payload, 4));
|
||||
#endif /* IPP2P_DEBUG_SOUL */
|
||||
return ((IPP2P_SOUL * 100) + 8);
|
||||
}
|
||||
|
||||
#ifdef IPP2P_DEBUG_SOUL
|
||||
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);
|
||||
#endif /* IPP2P_DEBUG_SOUL */
|
||||
}
|
||||
|
||||
/* match 14 00 00 00 01 yy 00 00 00 STRING(YY) 01 00 00 00 00 46|50 00 00 00 00 */
|
||||
/* without size at the beginning !!! */
|
||||
if ( get_u32(payload, 0) == 0x14 && get_u8(payload, 4) == 0x01 )
|
||||
{
|
||||
__u32 y=get_u32(payload, 5);
|
||||
/* we need 19 chars + string */
|
||||
if ( (y + 19) <= (plen) )
|
||||
{
|
||||
const unsigned char *w=payload+9+y;
|
||||
if (get_u32(w, 0) == 0x01 && ( get_u16(w, 4) == 0x4600 || get_u16(w, 4) == 0x5000) && get_u32(w, 6) == 0x00);
|
||||
#ifdef IPP2P_DEBUG_SOUL
|
||||
printk(KERN_DEBUG "Soulssek special client command recognized\n");
|
||||
#endif /* IPP2P_DEBUG_SOUL */
|
||||
return ((IPP2P_SOUL * 100) + 9);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*Search for WinMX commands*/
|
||||
int
|
||||
search_winmx (const unsigned char *payload, const u16 plen)
|
||||
{
|
||||
//#define IPP2P_DEBUG_WINMX
|
||||
if (((plen) == 4) && (memcmp(payload, "SEND", 4) == 0)) return ((IPP2P_WINMX * 100) + 1);
|
||||
if (((plen) == 3) && (memcmp(payload, "GET", 3) == 0)) return ((IPP2P_WINMX * 100) + 2);
|
||||
//if (packet_len < (head_len + 10)) return 0;
|
||||
if (plen < 10) return 0;
|
||||
|
||||
if ((memcmp(payload, "SEND", 4) == 0) || (memcmp(payload, "GET", 3) == 0)){
|
||||
u16 c=4;
|
||||
const u16 end=plen-2;
|
||||
u8 count=0;
|
||||
while (c < end)
|
||||
{
|
||||
if (payload[c]== 0x20 && payload[c+1] == 0x22)
|
||||
{
|
||||
c++;
|
||||
count++;
|
||||
if (count>=2) return ((IPP2P_WINMX * 100) + 3);
|
||||
}
|
||||
c++;
|
||||
}
|
||||
}
|
||||
|
||||
if ( plen == 149 && payload[0] == '8' )
|
||||
{
|
||||
#ifdef IPP2P_DEBUG_WINMX
|
||||
printk(KERN_INFO "maybe WinMX\n");
|
||||
#endif
|
||||
if (get_u32(payload,17) == 0 && get_u32(payload,21) == 0 && get_u32(payload,25) == 0 &&
|
||||
// get_u32(payload,33) == __constant_htonl(0x71182b1a) && get_u32(payload,37) == __constant_htonl(0x05050000) &&
|
||||
// get_u32(payload,133) == __constant_htonl(0x31097edf) && get_u32(payload,145) == __constant_htonl(0xdcb8f792))
|
||||
get_u16(payload,39) == 0 && get_u16(payload,135) == __constant_htons(0x7edf) && get_u16(payload,147) == __constant_htons(0xf792))
|
||||
|
||||
{
|
||||
#ifdef IPP2P_DEBUG_WINMX
|
||||
printk(KERN_INFO "got WinMX\n");
|
||||
#endif
|
||||
return ((IPP2P_WINMX * 100) + 4);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
} /*search_winmx*/
|
||||
|
||||
|
||||
/*Search for appleJuice commands*/
|
||||
int
|
||||
search_apple (const unsigned char *payload, const u16 plen)
|
||||
{
|
||||
if ( (plen > 7) && (payload[6] == 0x0d) && (payload[7] == 0x0a) && (memcmp(payload, "ajprot", 6) == 0)) return (IPP2P_APPLE * 100);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*Search for BitTorrent commands*/
|
||||
int
|
||||
search_bittorrent (const unsigned char *payload, const u16 plen)
|
||||
{
|
||||
if (plen > 20)
|
||||
{
|
||||
/* test for match 0x13+"BitTorrent protocol" */
|
||||
if (payload[0] == 0x13)
|
||||
{
|
||||
if (memcmp(payload+1, "BitTorrent protocol", 19) == 0) return (IPP2P_BIT * 100);
|
||||
}
|
||||
|
||||
/* get tracker commandos, all starts with GET /
|
||||
* then it can follow: scrape| announce
|
||||
* and then ?hash_info=
|
||||
*/
|
||||
if (memcmp(payload,"GET /",5) == 0)
|
||||
{
|
||||
/* message scrape */
|
||||
if ( memcmp(payload+5,"scrape?info_hash=",17)==0 ) return (IPP2P_BIT * 100 + 1);
|
||||
/* message announce */
|
||||
if ( memcmp(payload+5,"announce?info_hash=",19)==0 ) return (IPP2P_BIT * 100 + 2);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* bitcomet encryptes the first packet, so we have to detect another
|
||||
* one later in the flow */
|
||||
/* first try failed, too many missdetections */
|
||||
//if ( size == 5 && get_u32(t,0) == __constant_htonl(1) && t[4] < 3) return (IPP2P_BIT * 100 + 3);
|
||||
|
||||
/* second try: block request packets */
|
||||
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);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*check for Kazaa get command*/
|
||||
int
|
||||
search_kazaa (const unsigned char *payload, const u16 plen)
|
||||
|
||||
{
|
||||
if ((payload[plen-2] == 0x0d) && (payload[plen-1] == 0x0a) && memcmp(payload, "GET /.hash=", 11) == 0)
|
||||
return (IPP2P_DATA_KAZAA * 100);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*check for gnutella get command*/
|
||||
int
|
||||
search_gnu (const unsigned char *payload, const u16 plen)
|
||||
{
|
||||
if ((payload[plen-2] == 0x0d) && (payload[plen-1] == 0x0a))
|
||||
{
|
||||
if (memcmp(payload, "GET /get/", 9) == 0) return ((IPP2P_DATA_GNU * 100) + 1);
|
||||
if (memcmp(payload, "GET /uri-res/", 13) == 0) return ((IPP2P_DATA_GNU * 100) + 2);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*check for gnutella get commands and other typical data*/
|
||||
int
|
||||
search_all_gnu (const unsigned char *payload, const u16 plen)
|
||||
{
|
||||
|
||||
if ((payload[plen-2] == 0x0d) && (payload[plen-1] == 0x0a))
|
||||
{
|
||||
|
||||
if (memcmp(payload, "GNUTELLA CONNECT/", 17) == 0) return ((IPP2P_GNU * 100) + 1);
|
||||
if (memcmp(payload, "GNUTELLA/", 9) == 0) return ((IPP2P_GNU * 100) + 2);
|
||||
|
||||
|
||||
if ((memcmp(payload, "GET /get/", 9) == 0) || (memcmp(payload, "GET /uri-res/", 13) == 0))
|
||||
{
|
||||
u16 c=8;
|
||||
const u16 end=plen-22;
|
||||
while (c < end) {
|
||||
if ( payload[c] == 0x0a && payload[c+1] == 0x0d && ((memcmp(&payload[c+2], "X-Gnutella-", 11) == 0) || (memcmp(&payload[c+2], "X-Queue:", 8) == 0)))
|
||||
return ((IPP2P_GNU * 100) + 3);
|
||||
c++;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*check for KaZaA download commands and other typical data*/
|
||||
int
|
||||
search_all_kazaa (const unsigned char *payload, const u16 plen)
|
||||
{
|
||||
if ((payload[plen-2] == 0x0d) && (payload[plen-1] == 0x0a))
|
||||
{
|
||||
|
||||
if (memcmp(payload, "GIVE ", 5) == 0) return ((IPP2P_KAZAA * 100) + 1);
|
||||
|
||||
if (memcmp(payload, "GET /", 5) == 0) {
|
||||
u16 c = 8;
|
||||
const u16 end=plen-22;
|
||||
while (c < end) {
|
||||
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)))
|
||||
return ((IPP2P_KAZAA * 100) + 2);
|
||||
c++;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*fast check for edonkey file segment transfer command*/
|
||||
int
|
||||
search_edk (const unsigned char *payload, const u16 plen)
|
||||
{
|
||||
if (payload[0] != 0xe3)
|
||||
return 0;
|
||||
else {
|
||||
if (payload[5] == 0x47)
|
||||
return (IPP2P_DATA_EDK * 100);
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*intensive but slower search for some edonkey packets including size-check*/
|
||||
int
|
||||
search_all_edk (const unsigned char *payload, const u16 plen)
|
||||
{
|
||||
if (payload[0] != 0xe3)
|
||||
return 0;
|
||||
else {
|
||||
//t += head_len;
|
||||
const u16 cmd = get_u16(payload, 1);
|
||||
if (cmd == (plen - 5)) {
|
||||
switch (payload[5]) {
|
||||
case 0x01: return ((IPP2P_EDK * 100) + 1); /*Client: hello or Server:hello*/
|
||||
case 0x4c: return ((IPP2P_EDK * 100) + 9); /*Client: Hello-Answer*/
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*fast check for Direct Connect send command*/
|
||||
int
|
||||
search_dc (const unsigned char *payload, const u16 plen)
|
||||
{
|
||||
|
||||
if (payload[0] != 0x24 )
|
||||
return 0;
|
||||
else {
|
||||
if (memcmp(&payload[1], "Send|", 5) == 0)
|
||||
return (IPP2P_DATA_DC * 100);
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*intensive but slower check for all direct connect packets*/
|
||||
int
|
||||
search_all_dc (const unsigned char *payload, const u16 plen)
|
||||
{
|
||||
// unsigned char *t = haystack;
|
||||
|
||||
if (payload[0] == 0x24 && payload[plen-1] == 0x7c)
|
||||
{
|
||||
const unsigned char *t=&payload[1];
|
||||
/* Client-Hub-Protocol */
|
||||
if (memcmp(t, "Lock ", 5) == 0) return ((IPP2P_DC * 100) + 1);
|
||||
/* Client-Client-Protocol, some are already recognized by client-hub (like lock) */
|
||||
if (memcmp(t, "MyNick ", 7) == 0) return ((IPP2P_DC * 100) + 38);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*check for mute*/
|
||||
int
|
||||
search_mute (const unsigned char *payload, const u16 plen)
|
||||
{
|
||||
if ( plen == 209 || plen == 345 || plen == 473 || plen == 609 || plen == 1121 )
|
||||
{
|
||||
//printk(KERN_DEBUG "size hit: %u",size);
|
||||
if (memcmp(payload,"PublicKey: ",11) == 0 )
|
||||
{
|
||||
return ((IPP2P_MUTE * 100) + 0);
|
||||
|
||||
/* if (memcmp(t+size-14,"\x0aEndPublicKey\x0a",14) == 0)
|
||||
{
|
||||
printk(KERN_DEBUG "end pubic key hit: %u",size);
|
||||
|
||||
}*/
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* check for xdcc */
|
||||
int
|
||||
search_xdcc (const unsigned char *payload, const u16 plen)
|
||||
{
|
||||
/* search in small packets only */
|
||||
if (plen > 20 && plen < 200 && payload[plen-1] == 0x0a && payload[plen-2] == 0x0d && memcmp(payload,"PRIVMSG ",8) == 0)
|
||||
{
|
||||
|
||||
u16 x=10;
|
||||
const u16 end=plen - 13;
|
||||
|
||||
/* is seems to be a irc private massage, chedck for xdcc command */
|
||||
while (x < end)
|
||||
{
|
||||
if (payload[x] == ':')
|
||||
{
|
||||
if ( memcmp(&payload[x+1],"xdcc send #",11) == 0 )
|
||||
return ((IPP2P_XDCC * 100) + 0);
|
||||
}
|
||||
x++;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* search for waste */
|
||||
int search_waste(const unsigned char *payload, const u16 plen)
|
||||
{
|
||||
if ( plen >= 8 && memcmp(payload,"GET.sha1:",9) == 0)
|
||||
return ((IPP2P_WASTE * 100) + 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static struct {
|
||||
int command;
|
||||
__u8 short_hand; /*for fucntions included in short hands*/
|
||||
int packet_len;
|
||||
int (*function_name) (const unsigned char *, const u16);
|
||||
} matchlist[] = {
|
||||
{IPP2P_EDK,SHORT_HAND_IPP2P,20, &search_all_edk},
|
||||
// {IPP2P_DATA_KAZAA,SHORT_HAND_DATA,200, &search_kazaa},
|
||||
// {IPP2P_DATA_EDK,SHORT_HAND_DATA,60, &search_edk},
|
||||
// {IPP2P_DATA_DC,SHORT_HAND_DATA,26, &search_dc},
|
||||
{IPP2P_DC,SHORT_HAND_IPP2P,5, search_all_dc},
|
||||
// {IPP2P_DATA_GNU,SHORT_HAND_DATA,40, &search_gnu},
|
||||
{IPP2P_GNU,SHORT_HAND_IPP2P,5, &search_all_gnu},
|
||||
{IPP2P_KAZAA,SHORT_HAND_IPP2P,5, &search_all_kazaa},
|
||||
{IPP2P_BIT,SHORT_HAND_IPP2P,20, &search_bittorrent},
|
||||
{IPP2P_APPLE,SHORT_HAND_IPP2P,5, &search_apple},
|
||||
{IPP2P_SOUL,SHORT_HAND_IPP2P,5, &search_soul},
|
||||
{IPP2P_WINMX,SHORT_HAND_IPP2P,2, &search_winmx},
|
||||
{IPP2P_ARES,SHORT_HAND_IPP2P,5, &search_ares},
|
||||
{IPP2P_MUTE,SHORT_HAND_NONE,200, &search_mute},
|
||||
{IPP2P_WASTE,SHORT_HAND_NONE,5, &search_waste},
|
||||
{IPP2P_XDCC,SHORT_HAND_NONE,5, &search_xdcc},
|
||||
{0,0,0,NULL}
|
||||
};
|
||||
|
||||
|
||||
static struct {
|
||||
int command;
|
||||
__u8 short_hand; /*for fucntions included in short hands*/
|
||||
int packet_len;
|
||||
int (*function_name) (unsigned char *, int);
|
||||
} udp_list[] = {
|
||||
{IPP2P_KAZAA,SHORT_HAND_IPP2P,14, &udp_search_kazaa},
|
||||
{IPP2P_BIT,SHORT_HAND_IPP2P,23, &udp_search_bit},
|
||||
{IPP2P_GNU,SHORT_HAND_IPP2P,11, &udp_search_gnu},
|
||||
{IPP2P_EDK,SHORT_HAND_IPP2P,9, &udp_search_edk},
|
||||
{IPP2P_DC,SHORT_HAND_IPP2P,12, &udp_search_directconnect},
|
||||
{0,0,0,NULL}
|
||||
};
|
||||
|
||||
|
||||
static int
|
||||
match(const struct sk_buff *skb,
|
||||
const struct net_device *in,
|
||||
const struct net_device *out,
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,17)
|
||||
const struct xt_match *mymatch,
|
||||
const void *matchinfo,
|
||||
int offset,
|
||||
unsigned int myprotoff,
|
||||
#else
|
||||
const void *matchinfo,
|
||||
int offset,
|
||||
#endif
|
||||
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
|
||||
const void *hdr,
|
||||
u_int16_t datalen,
|
||||
#endif
|
||||
|
||||
int *hotdrop)
|
||||
{
|
||||
const struct ipt_p2p_info *info = matchinfo;
|
||||
unsigned char *haystack;
|
||||
struct iphdr *ip = skb->nh.iph;
|
||||
int p2p_result = 0, i = 0;
|
||||
// int head_len;
|
||||
int hlen = ntohs(ip->tot_len)-(ip->ihl*4); /*hlen = packet-data length*/
|
||||
|
||||
/*must not be a fragment*/
|
||||
if (offset) {
|
||||
if (info->debug) printk("IPP2P.match: offset found %i \n",offset);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*make sure that skb is linear*/
|
||||
if(skb_is_nonlinear(skb)){
|
||||
if (info->debug) printk("IPP2P.match: nonlinear skb found\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
haystack=(char *)ip+(ip->ihl*4); /*haystack = packet data*/
|
||||
|
||||
switch (ip->protocol){
|
||||
case IPPROTO_TCP: /*what to do with a TCP packet*/
|
||||
{
|
||||
struct tcphdr *tcph = (void *) ip + ip->ihl * 4;
|
||||
|
||||
if (tcph->fin) return 0; /*if FIN bit is set bail out*/
|
||||
if (tcph->syn) return 0; /*if SYN bit is set bail out*/
|
||||
if (tcph->rst) return 0; /*if RST bit is set bail out*/
|
||||
|
||||
haystack += tcph->doff * 4; /*get TCP-Header-Size*/
|
||||
hlen -= tcph->doff * 4;
|
||||
while (matchlist[i].command) {
|
||||
if ((((info->cmd & matchlist[i].command) == matchlist[i].command) ||
|
||||
((info->cmd & matchlist[i].short_hand) == matchlist[i].short_hand)) &&
|
||||
(hlen > matchlist[i].packet_len)) {
|
||||
p2p_result = matchlist[i].function_name(haystack, hlen);
|
||||
if (p2p_result)
|
||||
{
|
||||
if (info->debug) printk("IPP2P.debug:TCP-match: %i from: %u.%u.%u.%u:%i to: %u.%u.%u.%u:%i Length: %i\n",
|
||||
p2p_result, NIPQUAD(ip->saddr),ntohs(tcph->source), NIPQUAD(ip->daddr),ntohs(tcph->dest),hlen);
|
||||
return p2p_result;
|
||||
}
|
||||
}
|
||||
i++;
|
||||
}
|
||||
return p2p_result;
|
||||
}
|
||||
|
||||
case IPPROTO_UDP: /*what to do with an UDP packet*/
|
||||
{
|
||||
struct udphdr *udph = (void *) ip + ip->ihl * 4;
|
||||
|
||||
while (udp_list[i].command){
|
||||
if ((((info->cmd & udp_list[i].command) == udp_list[i].command) ||
|
||||
((info->cmd & udp_list[i].short_hand) == udp_list[i].short_hand)) &&
|
||||
(hlen > udp_list[i].packet_len)) {
|
||||
p2p_result = udp_list[i].function_name(haystack, hlen);
|
||||
if (p2p_result){
|
||||
if (info->debug) printk("IPP2P.debug:UDP-match: %i from: %u.%u.%u.%u:%i to: %u.%u.%u.%u:%i Length: %i\n",
|
||||
p2p_result, NIPQUAD(ip->saddr),ntohs(udph->source), NIPQUAD(ip->daddr),ntohs(udph->dest),hlen);
|
||||
return p2p_result;
|
||||
}
|
||||
}
|
||||
i++;
|
||||
}
|
||||
return p2p_result;
|
||||
}
|
||||
|
||||
default: return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
static int
|
||||
checkentry(const char *tablename,
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,17)
|
||||
const void *ip,
|
||||
const struct xt_match *mymatch,
|
||||
#else
|
||||
const struct ipt_ip *ip,
|
||||
#endif
|
||||
void *matchinfo,
|
||||
unsigned int matchsize,
|
||||
unsigned int hook_mask)
|
||||
{
|
||||
/* Must specify -p tcp */
|
||||
/* if (ip->proto != IPPROTO_TCP || (ip->invflags & IPT_INV_PROTO)) {
|
||||
* printk("ipp2p: Only works on TCP packets, use -p tcp\n");
|
||||
* return 0;
|
||||
* }*/
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
// TODO: find out what this structure is for (scheme taken
|
||||
// from kernel sources)
|
||||
// content seems to have a length of 8 bytes
|
||||
// (at least on my x86 machine)
|
||||
struct ipp2p_match_info {
|
||||
long int dunno_what_this_is_for;
|
||||
long int i_also_dunno_what_this_is_for;
|
||||
};
|
||||
|
||||
static struct ipt_match ipp2p_match = {
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
|
||||
{ NULL, NULL },
|
||||
"ipp2p",
|
||||
&match,
|
||||
&checkentry,
|
||||
NULL,
|
||||
THIS_MODULE
|
||||
#endif
|
||||
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)) && (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,17))
|
||||
.name = "ipp2p",
|
||||
.match = &match,
|
||||
.checkentry = &checkentry,
|
||||
.me = THIS_MODULE,
|
||||
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,17)
|
||||
.name = "ipp2p",
|
||||
.match = &match,
|
||||
.family = AF_INET,
|
||||
.matchsize = sizeof(struct ipp2p_match_info),
|
||||
.checkentry = &checkentry,
|
||||
.me = THIS_MODULE,
|
||||
#endif
|
||||
};
|
||||
|
||||
|
||||
static int __init init(void)
|
||||
{
|
||||
printk(KERN_INFO "IPP2P v%s loading\n", IPP2P_VERSION);
|
||||
return ipt_register_match(&ipp2p_match);
|
||||
}
|
||||
|
||||
static void __exit fini(void)
|
||||
{
|
||||
ipt_unregister_match(&ipp2p_match);
|
||||
printk(KERN_INFO "IPP2P v%s unloaded\n", IPP2P_VERSION);
|
||||
}
|
||||
|
||||
module_init(init);
|
||||
module_exit(fini);
|
||||
|
||||
|
||||
31
src/ipp2p/ipt_ipp2p.h
Normal file
31
src/ipp2p/ipt_ipp2p.h
Normal file
@@ -0,0 +1,31 @@
|
||||
#ifndef __IPT_IPP2P_H
|
||||
#define __IPT_IPP2P_H
|
||||
#define IPP2P_VERSION "0.8.2"
|
||||
|
||||
struct ipt_p2p_info {
|
||||
int cmd;
|
||||
int debug;
|
||||
};
|
||||
|
||||
#endif //__IPT_IPP2P_H
|
||||
|
||||
#define SHORT_HAND_IPP2P 1 /* --ipp2p switch*/
|
||||
//#define SHORT_HAND_DATA 4 /* --ipp2p-data switch*/
|
||||
#define SHORT_HAND_NONE 5 /* no short hand*/
|
||||
|
||||
#define IPP2P_EDK (1 << 1)
|
||||
#define IPP2P_DATA_KAZAA (1 << 2)
|
||||
#define IPP2P_DATA_EDK (1 << 3)
|
||||
#define IPP2P_DATA_DC (1 << 4)
|
||||
#define IPP2P_DC (1 << 5)
|
||||
#define IPP2P_DATA_GNU (1 << 6)
|
||||
#define IPP2P_GNU (1 << 7)
|
||||
#define IPP2P_KAZAA (1 << 8)
|
||||
#define IPP2P_BIT (1 << 9)
|
||||
#define IPP2P_APPLE (1 << 10)
|
||||
#define IPP2P_SOUL (1 << 11)
|
||||
#define IPP2P_WINMX (1 << 12)
|
||||
#define IPP2P_ARES (1 << 13)
|
||||
#define IPP2P_MUTE (1 << 14)
|
||||
#define IPP2P_WASTE (1 << 15)
|
||||
#define IPP2P_XDCC (1 << 16)
|
||||
401
src/ipp2p/libipt_ipp2p.c
Normal file
401
src/ipp2p/libipt_ipp2p.c
Normal file
@@ -0,0 +1,401 @@
|
||||
|
||||
#include <stdio.h>
|
||||
#include <netdb.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <getopt.h>
|
||||
#include <ctype.h>
|
||||
|
||||
#include <iptables.h>
|
||||
|
||||
#include "ipt_ipp2p.h"
|
||||
|
||||
static void
|
||||
help(void)
|
||||
{
|
||||
printf(
|
||||
"IPP2P v%s options:\n"
|
||||
" --ipp2p Grab all known p2p packets\n"
|
||||
" --edk [TCP&UDP] All known eDonkey/eMule/Overnet packets\n"
|
||||
" --dc [TCP] All known Direct Connect packets\n"
|
||||
" --kazaa [TCP&UDP] All known KaZaA packets\n"
|
||||
" --gnu [TCP&UDP] All known Gnutella packets\n"
|
||||
" --bit [TCP&UDP] All known BitTorrent packets\n"
|
||||
" --apple [TCP] All known AppleJuice packets\n"
|
||||
" --winmx [TCP] All known WinMX\n"
|
||||
" --soul [TCP] All known SoulSeek\n"
|
||||
" --ares [TCP] All known Ares\n\n"
|
||||
" EXPERIMENTAL protocols (please send feedback to: ipp2p@ipp2p.org) :\n"
|
||||
" --mute [TCP] All known Mute packets\n"
|
||||
" --waste [TCP] All known Waste packets\n"
|
||||
" --xdcc [TCP] All known XDCC packets (only xdcc login)\n\n"
|
||||
" DEBUG SUPPPORT, use only if you know why\n"
|
||||
" --debug Generate kernel debug output, THIS WILL SLOW DOWN THE FILTER\n"
|
||||
"\nNote that the follwing options will have the same meaning:\n"
|
||||
" '--ipp2p' is equal to '--edk --dc --kazaa --gnu --bit --apple --winmx --soul --ares'\n"
|
||||
"\nIPP2P was intended for TCP only. Due to increasing usage of UDP we needed to change this.\n"
|
||||
"You can now use -p udp to search UDP packets only or without -p switch to search UDP and TCP packets.\n"
|
||||
"\nSee README included with this package for more details or visit http://www.ipp2p.org\n"
|
||||
"\nExamples:\n"
|
||||
" iptables -A FORWARD -m ipp2p --ipp2p -j MARK --set-mark 0x01\n"
|
||||
" iptables -A FORWARD -p udp -m ipp2p --kazaa --bit -j DROP\n"
|
||||
" iptables -A FORWARD -p tcp -m ipp2p --edk --soul -j DROP\n\n"
|
||||
, IPP2P_VERSION);
|
||||
}
|
||||
|
||||
static struct option opts[] = {
|
||||
{ "ipp2p", 0, 0, '1' },
|
||||
{ "edk", 0, 0, '2' },
|
||||
{ "dc", 0, 0, '7' },
|
||||
{ "gnu", 0, 0, '9' },
|
||||
{ "kazaa", 0, 0, 'a' },
|
||||
{ "bit", 0, 0, 'b' },
|
||||
{ "apple", 0, 0, 'c' },
|
||||
{ "soul", 0, 0, 'd' },
|
||||
{ "winmx", 0, 0, 'e' },
|
||||
{ "ares", 0, 0, 'f' },
|
||||
{ "mute", 0, 0, 'g' },
|
||||
{ "waste", 0, 0, 'h' },
|
||||
{ "xdcc", 0, 0, 'i' },
|
||||
{ "debug", 0, 0, 'j' },
|
||||
{0}
|
||||
};
|
||||
|
||||
|
||||
|
||||
static void
|
||||
init(struct ipt_entry_match *m, unsigned int *nfcache)
|
||||
{
|
||||
struct ipt_p2p_info *info = (struct ipt_p2p_info *)m->data;
|
||||
|
||||
*nfcache |= NFC_UNKNOWN;
|
||||
|
||||
/*init the module with default values*/
|
||||
info->cmd = 0;
|
||||
info->debug = 0;
|
||||
|
||||
}
|
||||
|
||||
|
||||
static int
|
||||
parse(int c, char **argv, int invert, unsigned int *flags,
|
||||
const struct ipt_entry *entry,
|
||||
unsigned int *nfcache,
|
||||
struct ipt_entry_match **match)
|
||||
{
|
||||
struct ipt_p2p_info *info = (struct ipt_p2p_info *)(*match)->data;
|
||||
|
||||
switch (c) {
|
||||
case '1': /*cmd: ipp2p*/
|
||||
if ((*flags & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--ipp2p' may only be "
|
||||
"specified once!");
|
||||
/* if ((*flags & SHORT_HAND_DATA) == SHORT_HAND_DATA)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--ipp2p-data' may only be "
|
||||
"specified alone!");*/
|
||||
if ((*flags) != 0)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--ipp2p' may only be "
|
||||
"specified alone!");
|
||||
if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!");
|
||||
*flags += SHORT_HAND_IPP2P;
|
||||
info->cmd = *flags;
|
||||
break;
|
||||
|
||||
case '2': /*cmd: edk*/
|
||||
if ((*flags & IPP2P_EDK) == IPP2P_EDK)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--edk' may only be "
|
||||
"specified once");
|
||||
if ((*flags & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--ipp2p' may only be "
|
||||
"specified alone!");
|
||||
/* if ((*flags & SHORT_HAND_DATA) == SHORT_HAND_DATA)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--ipp2p-data' may only be "
|
||||
"specified alone!");*/
|
||||
if ((*flags & IPP2P_DATA_EDK) == IPP2P_DATA_EDK)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: use `--edk' OR `--edk-data' but not both of them!");
|
||||
if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!");
|
||||
*flags += IPP2P_EDK;
|
||||
info->cmd = *flags;
|
||||
break;
|
||||
|
||||
|
||||
case '7': /*cmd: dc*/
|
||||
if ((*flags & IPP2P_DC) == IPP2P_DC)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--dc' may only be "
|
||||
"specified once!");
|
||||
if ((*flags & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--ipp2p' may only be "
|
||||
"specified alone!");
|
||||
/* if ((*flags & SHORT_HAND_DATA) == SHORT_HAND_DATA)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--ipp2p-data' may only be "
|
||||
"specified alone!");*/
|
||||
if ((*flags & IPP2P_DATA_DC) == IPP2P_DATA_DC)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: use `--dc' OR `--dc-data' but not both of them!");
|
||||
if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!");
|
||||
*flags += IPP2P_DC;
|
||||
info->cmd = *flags;
|
||||
break;
|
||||
|
||||
|
||||
case '9': /*cmd: gnu*/
|
||||
if ((*flags & IPP2P_GNU) == IPP2P_GNU)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--gnu' may only be "
|
||||
"specified once!");
|
||||
/* if ((*flags & SHORT_HAND_DATA) == SHORT_HAND_DATA)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--ipp2p-data' may only be "
|
||||
"specified alone!");*/
|
||||
if ((*flags & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--ipp2p' may only be "
|
||||
"specified alone!");
|
||||
if ((*flags & IPP2P_DATA_GNU) == IPP2P_DATA_GNU)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: use `--gnu' OR `--gnu-data' but not both of them!");
|
||||
if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!");
|
||||
*flags += IPP2P_GNU;
|
||||
info->cmd = *flags;
|
||||
break;
|
||||
|
||||
case 'a': /*cmd: kazaa*/
|
||||
if ((*flags & IPP2P_KAZAA) == IPP2P_KAZAA)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--kazaa' may only be "
|
||||
"specified once!");
|
||||
/* if ((*flags & SHORT_HAND_DATA) == SHORT_HAND_DATA)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--ipp2p-data' may only be "
|
||||
"specified alone!");*/
|
||||
if ((*flags & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--ipp2p' may only be "
|
||||
"specified alone!");
|
||||
if ((*flags & IPP2P_DATA_KAZAA) == IPP2P_DATA_KAZAA)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: use `--kazaa' OR `--kazaa-data' but not both of them!");
|
||||
if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!");
|
||||
*flags += IPP2P_KAZAA;
|
||||
info->cmd = *flags;
|
||||
break;
|
||||
|
||||
case 'b': /*cmd: bit*/
|
||||
if ((*flags & IPP2P_BIT) == IPP2P_BIT)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--bit' may only be "
|
||||
"specified once!");
|
||||
if ((*flags & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--ipp2p' may only be "
|
||||
"specified alone!");
|
||||
if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!");
|
||||
*flags += IPP2P_BIT;
|
||||
info->cmd = *flags;
|
||||
break;
|
||||
|
||||
case 'c': /*cmd: apple*/
|
||||
if ((*flags & IPP2P_APPLE) == IPP2P_APPLE)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--apple' may only be "
|
||||
"specified once!");
|
||||
if ((*flags & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--ipp2p' may only be "
|
||||
"specified alone!");
|
||||
if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!");
|
||||
*flags += IPP2P_APPLE;
|
||||
info->cmd = *flags;
|
||||
break;
|
||||
|
||||
|
||||
case 'd': /*cmd: soul*/
|
||||
if ((*flags & IPP2P_SOUL) == IPP2P_SOUL)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--soul' may only be "
|
||||
"specified once!");
|
||||
if ((*flags & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--ipp2p' may only be "
|
||||
"specified alone!");
|
||||
if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!");
|
||||
*flags += IPP2P_SOUL;
|
||||
info->cmd = *flags;
|
||||
break;
|
||||
|
||||
|
||||
case 'e': /*cmd: winmx*/
|
||||
if ((*flags & IPP2P_WINMX) == IPP2P_WINMX)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--winmx' may only be "
|
||||
"specified once!");
|
||||
if ((*flags & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--ipp2p' may only be "
|
||||
"specified alone!");
|
||||
if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!");
|
||||
*flags += IPP2P_WINMX;
|
||||
info->cmd = *flags;
|
||||
break;
|
||||
|
||||
case 'f': /*cmd: ares*/
|
||||
if ((*flags & IPP2P_ARES) == IPP2P_ARES)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--ares' may only be "
|
||||
"specified once!");
|
||||
if ((*flags & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--ipp2p' may only be "
|
||||
"specified alone!");
|
||||
if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!");
|
||||
*flags += IPP2P_ARES;
|
||||
info->cmd = *flags;
|
||||
break;
|
||||
|
||||
case 'g': /*cmd: mute*/
|
||||
if ((*flags & IPP2P_MUTE) == IPP2P_MUTE)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--mute' may only be "
|
||||
"specified once!");
|
||||
if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!");
|
||||
*flags += IPP2P_MUTE;
|
||||
info->cmd = *flags;
|
||||
break;
|
||||
case 'h': /*cmd: waste*/
|
||||
if ((*flags & IPP2P_WASTE) == IPP2P_WASTE)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--waste' may only be "
|
||||
"specified once!");
|
||||
if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!");
|
||||
*flags += IPP2P_WASTE;
|
||||
info->cmd = *flags;
|
||||
break;
|
||||
case 'i': /*cmd: xdcc*/
|
||||
if ((*flags & IPP2P_XDCC) == IPP2P_XDCC)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"ipp2p: `--ares' may only be "
|
||||
"specified once!");
|
||||
if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!");
|
||||
*flags += IPP2P_XDCC;
|
||||
info->cmd = *flags;
|
||||
break;
|
||||
|
||||
case 'j': /*cmd: debug*/
|
||||
if (invert) exit_error(PARAMETER_PROBLEM, "ipp2p: invert [!] is not allowed!");
|
||||
info->debug = 1;
|
||||
break;
|
||||
|
||||
default:
|
||||
// exit_error(PARAMETER_PROBLEM,
|
||||
// "\nipp2p-parameter problem: for ipp2p usage type: iptables -m ipp2p --help\n");
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
final_check(unsigned int flags)
|
||||
{
|
||||
if (!flags)
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"\nipp2p-parameter problem: for ipp2p usage type: iptables -m ipp2p --help\n");
|
||||
}
|
||||
|
||||
|
||||
|
||||
static void
|
||||
print(const struct ipt_ip *ip,
|
||||
const struct ipt_entry_match *match,
|
||||
int numeric)
|
||||
{
|
||||
struct ipt_p2p_info *info = (struct ipt_p2p_info *)match->data;
|
||||
|
||||
printf("ipp2p v%s", IPP2P_VERSION);
|
||||
if ((info->cmd & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P) printf(" --ipp2p");
|
||||
// if ((info->cmd & SHORT_HAND_DATA) == SHORT_HAND_DATA) printf(" --ipp2p-data");
|
||||
if ((info->cmd & IPP2P_KAZAA) == IPP2P_KAZAA) printf(" --kazaa");
|
||||
// if ((info->cmd & IPP2P_DATA_KAZAA) == IPP2P_DATA_KAZAA) printf(" --kazaa-data");
|
||||
// if ((info->cmd & IPP2P_DATA_GNU) == IPP2P_DATA_GNU) printf(" --gnu-data");
|
||||
if ((info->cmd & IPP2P_GNU) == IPP2P_GNU) printf(" --gnu");
|
||||
if ((info->cmd & IPP2P_EDK) == IPP2P_EDK) printf(" --edk");
|
||||
// if ((info->cmd & IPP2P_DATA_EDK) == IPP2P_DATA_EDK) printf(" --edk-data");
|
||||
// if ((info->cmd & IPP2P_DATA_DC) == IPP2P_DATA_DC) printf(" --dc-data");
|
||||
if ((info->cmd & IPP2P_DC) == IPP2P_DC) printf(" --dc");
|
||||
if ((info->cmd & IPP2P_BIT) == IPP2P_BIT) printf(" --bit");
|
||||
if ((info->cmd & IPP2P_APPLE) == IPP2P_APPLE) printf(" --apple");
|
||||
if ((info->cmd & IPP2P_SOUL) == IPP2P_SOUL) printf(" --soul");
|
||||
if ((info->cmd & IPP2P_WINMX) == IPP2P_WINMX) printf(" --winmx");
|
||||
if ((info->cmd & IPP2P_ARES) == IPP2P_ARES) printf(" --ares");
|
||||
if ((info->cmd & IPP2P_MUTE) == IPP2P_MUTE) printf(" --mute");
|
||||
if ((info->cmd & IPP2P_WASTE) == IPP2P_WASTE) printf(" --waste");
|
||||
if ((info->cmd & IPP2P_XDCC) == IPP2P_XDCC) printf(" --xdcc");
|
||||
if (info->debug != 0) printf(" --debug");
|
||||
printf(" ");
|
||||
}
|
||||
|
||||
|
||||
|
||||
static void
|
||||
save(const struct ipt_ip *ip, const struct ipt_entry_match *match)
|
||||
{
|
||||
struct ipt_p2p_info *info = (struct ipt_p2p_info *)match->data;
|
||||
|
||||
if ((info->cmd & SHORT_HAND_IPP2P) == SHORT_HAND_IPP2P) printf("--ipp2p ");
|
||||
// if ((info->cmd & SHORT_HAND_DATA) == SHORT_HAND_DATA) printf("--ipp2p-data ");
|
||||
if ((info->cmd & IPP2P_KAZAA) == IPP2P_KAZAA) printf("--kazaa ");
|
||||
// if ((info->cmd & IPP2P_DATA_KAZAA) == IPP2P_DATA_KAZAA) printf("--kazaa-data ");
|
||||
// if ((info->cmd & IPP2P_DATA_GNU) == IPP2P_DATA_GNU) printf("--gnu-data ");
|
||||
if ((info->cmd & IPP2P_GNU) == IPP2P_GNU) printf("--gnu ");
|
||||
if ((info->cmd & IPP2P_EDK) == IPP2P_EDK) printf("--edk ");
|
||||
// if ((info->cmd & IPP2P_DATA_EDK) == IPP2P_DATA_EDK) printf("--edk-data ");
|
||||
// if ((info->cmd & IPP2P_DATA_DC) == IPP2P_DATA_DC) printf("--dc-data ");
|
||||
if ((info->cmd & IPP2P_DC) == IPP2P_DC) printf("--dc ");
|
||||
if ((info->cmd & IPP2P_BIT) == IPP2P_BIT) printf("--bit ");
|
||||
if ((info->cmd & IPP2P_APPLE) == IPP2P_APPLE) printf("--apple ");
|
||||
if ((info->cmd & IPP2P_SOUL) == IPP2P_SOUL) printf("--soul ");
|
||||
if ((info->cmd & IPP2P_WINMX) == IPP2P_WINMX) printf("--winmx ");
|
||||
if ((info->cmd & IPP2P_ARES) == IPP2P_ARES) printf("--ares ");
|
||||
if ((info->cmd & IPP2P_MUTE) == IPP2P_MUTE) printf(" --mute");
|
||||
if ((info->cmd & IPP2P_WASTE) == IPP2P_WASTE) printf(" --waste");
|
||||
if ((info->cmd & IPP2P_XDCC) == IPP2P_XDCC) printf(" --xdcc");
|
||||
if (info->debug != 0) printf("--debug ");
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
static
|
||||
struct iptables_match ipp2p=
|
||||
{
|
||||
.next = NULL,
|
||||
.name = "ipp2p",
|
||||
.version = IPTABLES_VERSION,
|
||||
.size = IPT_ALIGN(sizeof(struct ipt_p2p_info)),
|
||||
.userspacesize = IPT_ALIGN(sizeof(struct ipt_p2p_info)),
|
||||
.help = &help,
|
||||
.init = &init,
|
||||
.parse = &parse,
|
||||
.final_check = &final_check,
|
||||
.print = &print,
|
||||
.save = &save,
|
||||
.extra_opts = opts
|
||||
};
|
||||
|
||||
|
||||
|
||||
void _init(void)
|
||||
{
|
||||
register_match(&ipp2p);
|
||||
}
|
||||
|
||||
@@ -1,11 +1,11 @@
|
||||
--- linux-2.4.31/net/ipv4/netfilter/ip_conntrack_standalone.c~ 2006-05-16 09:48:56.555196560 +0200
|
||||
+++ linux-2.4.31/net/ipv4/netfilter/ip_conntrack_standalone.c 2006-05-16 10:07:04.000000000 +0200
|
||||
@@ -356,7 +356,7 @@
|
||||
if (ret < 0)
|
||||
goto cleanup_nothing;
|
||||
--- net/ipv4/netfilter/ip_conntrack_standalone.c~ 2006-12-12 01:50:40.000000000 +0000
|
||||
+++ net/ipv4/netfilter/ip_conntrack_standalone.c 2006-12-16 16:29:28.000000000 +0000
|
||||
@@ -804,7 +804,7 @@
|
||||
|
||||
- proc = proc_net_create("ip_conntrack", 0440, list_conntracks);
|
||||
+ proc = proc_net_create("ip_conntrack", 0444, list_conntracks);
|
||||
#ifdef CONFIG_PROC_FS
|
||||
ret = -ENOMEM;
|
||||
- proc = proc_net_fops_create("ip_conntrack", 0440, &ct_file_ops);
|
||||
+ proc = proc_net_fops_create("ip_conntrack", 0444, &ct_file_ops);
|
||||
if (!proc) goto cleanup_init;
|
||||
proc->owner = THIS_MODULE;
|
||||
|
||||
proc_exp = proc_net_fops_create("ip_conntrack_expect", 0440,
|
||||
|
||||
Reference in New Issue
Block a user