No need for this module, done in GTPUAH
git-svn-id: http://svn.eurecom.fr/openair4G/trunk@7420 818b1a75-f10b-46b9-bf7c-635c3b92a50f
This commit is contained in:
Lionel Gauthier
@@ -1,339 +0,0 @@
|
||||
GNU GENERAL PUBLIC LICENSE
|
||||
Version 2, June 1991
|
||||
|
||||
Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
Preamble
|
||||
|
||||
The licenses for most software are designed to take away your
|
||||
freedom to share and change it. By contrast, the GNU General Public
|
||||
License is intended to guarantee your freedom to share and change free
|
||||
software--to make sure the software is free for all its users. This
|
||||
General Public License applies to most of the Free Software
|
||||
Foundation's software and to any other program whose authors commit to
|
||||
using it. (Some other Free Software Foundation software is covered by
|
||||
the GNU Lesser General Public License instead.) You can apply it to
|
||||
your programs, too.
|
||||
|
||||
When we speak of free software, we are referring to freedom, not
|
||||
price. Our General Public Licenses are designed to make sure that you
|
||||
have the freedom to distribute copies of free software (and charge for
|
||||
this service if you wish), that you receive source code or can get it
|
||||
if you want it, that you can change the software or use pieces of it
|
||||
in new free programs; and that you know you can do these things.
|
||||
|
||||
To protect your rights, we need to make restrictions that forbid
|
||||
anyone to deny you these rights or to ask you to surrender the rights.
|
||||
These restrictions translate to certain responsibilities for you if you
|
||||
distribute copies of the software, or if you modify it.
|
||||
|
||||
For example, if you distribute copies of such a program, whether
|
||||
gratis or for a fee, you must give the recipients all the rights that
|
||||
you have. You must make sure that they, too, receive or can get the
|
||||
source code. And you must show them these terms so they know their
|
||||
rights.
|
||||
|
||||
We protect your rights with two steps: (1) copyright the software, and
|
||||
(2) offer you this license which gives you legal permission to copy,
|
||||
distribute and/or modify the software.
|
||||
|
||||
Also, for each author's protection and ours, we want to make certain
|
||||
that everyone understands that there is no warranty for this free
|
||||
software. If the software is modified by someone else and passed on, we
|
||||
want its recipients to know that what they have is not the original, so
|
||||
that any problems introduced by others will not reflect on the original
|
||||
authors' reputations.
|
||||
|
||||
Finally, any free program is threatened constantly by software
|
||||
patents. We wish to avoid the danger that redistributors of a free
|
||||
program will individually obtain patent licenses, in effect making the
|
||||
program proprietary. To prevent this, we have made it clear that any
|
||||
patent must be licensed for everyone's free use or not licensed at all.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow.
|
||||
|
||||
GNU GENERAL PUBLIC LICENSE
|
||||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
||||
|
||||
0. This License applies to any program or other work which contains
|
||||
a notice placed by the copyright holder saying it may be distributed
|
||||
under the terms of this General Public License. The "Program", below,
|
||||
refers to any such program or work, and a "work based on the Program"
|
||||
means either the Program or any derivative work under copyright law:
|
||||
that is to say, a work containing the Program or a portion of it,
|
||||
either verbatim or with modifications and/or translated into another
|
||||
language. (Hereinafter, translation is included without limitation in
|
||||
the term "modification".) Each licensee is addressed as "you".
|
||||
|
||||
Activities other than copying, distribution and modification are not
|
||||
covered by this License; they are outside its scope. The act of
|
||||
running the Program is not restricted, and the output from the Program
|
||||
is covered only if its contents constitute a work based on the
|
||||
Program (independent of having been made by running the Program).
|
||||
Whether that is true depends on what the Program does.
|
||||
|
||||
1. You may copy and distribute verbatim copies of the Program's
|
||||
source code as you receive it, in any medium, provided that you
|
||||
conspicuously and appropriately publish on each copy an appropriate
|
||||
copyright notice and disclaimer of warranty; keep intact all the
|
||||
notices that refer to this License and to the absence of any warranty;
|
||||
and give any other recipients of the Program a copy of this License
|
||||
along with the Program.
|
||||
|
||||
You may charge a fee for the physical act of transferring a copy, and
|
||||
you may at your option offer warranty protection in exchange for a fee.
|
||||
|
||||
2. You may modify your copy or copies of the Program or any portion
|
||||
of it, thus forming a work based on the Program, and copy and
|
||||
distribute such modifications or work under the terms of Section 1
|
||||
above, provided that you also meet all of these conditions:
|
||||
|
||||
a) You must cause the modified files to carry prominent notices
|
||||
stating that you changed the files and the date of any change.
|
||||
|
||||
b) You must cause any work that you distribute or publish, that in
|
||||
whole or in part contains or is derived from the Program or any
|
||||
part thereof, to be licensed as a whole at no charge to all third
|
||||
parties under the terms of this License.
|
||||
|
||||
c) If the modified program normally reads commands interactively
|
||||
when run, you must cause it, when started running for such
|
||||
interactive use in the most ordinary way, to print or display an
|
||||
announcement including an appropriate copyright notice and a
|
||||
notice that there is no warranty (or else, saying that you provide
|
||||
a warranty) and that users may redistribute the program under
|
||||
these conditions, and telling the user how to view a copy of this
|
||||
License. (Exception: if the Program itself is interactive but
|
||||
does not normally print such an announcement, your work based on
|
||||
the Program is not required to print an announcement.)
|
||||
|
||||
These requirements apply to the modified work as a whole. If
|
||||
identifiable sections of that work are not derived from the Program,
|
||||
and can be reasonably considered independent and separate works in
|
||||
themselves, then this License, and its terms, do not apply to those
|
||||
sections when you distribute them as separate works. But when you
|
||||
distribute the same sections as part of a whole which is a work based
|
||||
on the Program, the distribution of the whole must be on the terms of
|
||||
this License, whose permissions for other licensees extend to the
|
||||
entire whole, and thus to each and every part regardless of who wrote it.
|
||||
|
||||
Thus, it is not the intent of this section to claim rights or contest
|
||||
your rights to work written entirely by you; rather, the intent is to
|
||||
exercise the right to control the distribution of derivative or
|
||||
collective works based on the Program.
|
||||
|
||||
In addition, mere aggregation of another work not based on the Program
|
||||
with the Program (or with a work based on the Program) on a volume of
|
||||
a storage or distribution medium does not bring the other work under
|
||||
the scope of this License.
|
||||
|
||||
3. You may copy and distribute the Program (or a work based on it,
|
||||
under Section 2) in object code or executable form under the terms of
|
||||
Sections 1 and 2 above provided that you also do one of the following:
|
||||
|
||||
a) Accompany it with the complete corresponding machine-readable
|
||||
source code, which must be distributed under the terms of Sections
|
||||
1 and 2 above on a medium customarily used for software interchange; or,
|
||||
|
||||
b) Accompany it with a written offer, valid for at least three
|
||||
years, to give any third party, for a charge no more than your
|
||||
cost of physically performing source distribution, a complete
|
||||
machine-readable copy of the corresponding source code, to be
|
||||
distributed under the terms of Sections 1 and 2 above on a medium
|
||||
customarily used for software interchange; or,
|
||||
|
||||
c) Accompany it with the information you received as to the offer
|
||||
to distribute corresponding source code. (This alternative is
|
||||
allowed only for noncommercial distribution and only if you
|
||||
received the program in object code or executable form with such
|
||||
an offer, in accord with Subsection b above.)
|
||||
|
||||
The source code for a work means the preferred form of the work for
|
||||
making modifications to it. For an executable work, complete source
|
||||
code means all the source code for all modules it contains, plus any
|
||||
associated interface definition files, plus the scripts used to
|
||||
control compilation and installation of the executable. However, as a
|
||||
special exception, the source code distributed need not include
|
||||
anything that is normally distributed (in either source or binary
|
||||
form) with the major components (compiler, kernel, and so on) of the
|
||||
operating system on which the executable runs, unless that component
|
||||
itself accompanies the executable.
|
||||
|
||||
If distribution of executable or object code is made by offering
|
||||
access to copy from a designated place, then offering equivalent
|
||||
access to copy the source code from the same place counts as
|
||||
distribution of the source code, even though third parties are not
|
||||
compelled to copy the source along with the object code.
|
||||
|
||||
4. You may not copy, modify, sublicense, or distribute the Program
|
||||
except as expressly provided under this License. Any attempt
|
||||
otherwise to copy, modify, sublicense or distribute the Program is
|
||||
void, and will automatically terminate your rights under this License.
|
||||
However, parties who have received copies, or rights, from you under
|
||||
this License will not have their licenses terminated so long as such
|
||||
parties remain in full compliance.
|
||||
|
||||
5. You are not required to accept this License, since you have not
|
||||
signed it. However, nothing else grants you permission to modify or
|
||||
distribute the Program or its derivative works. These actions are
|
||||
prohibited by law if you do not accept this License. Therefore, by
|
||||
modifying or distributing the Program (or any work based on the
|
||||
Program), you indicate your acceptance of this License to do so, and
|
||||
all its terms and conditions for copying, distributing or modifying
|
||||
the Program or works based on it.
|
||||
|
||||
6. Each time you redistribute the Program (or any work based on the
|
||||
Program), the recipient automatically receives a license from the
|
||||
original licensor to copy, distribute or modify the Program subject to
|
||||
these terms and conditions. You may not impose any further
|
||||
restrictions on the recipients' exercise of the rights granted herein.
|
||||
You are not responsible for enforcing compliance by third parties to
|
||||
this License.
|
||||
|
||||
7. If, as a consequence of a court judgment or allegation of patent
|
||||
infringement or for any other reason (not limited to patent issues),
|
||||
conditions are imposed on you (whether by court order, agreement or
|
||||
otherwise) that contradict the conditions of this License, they do not
|
||||
excuse you from the conditions of this License. If you cannot
|
||||
distribute so as to satisfy simultaneously your obligations under this
|
||||
License and any other pertinent obligations, then as a consequence you
|
||||
may not distribute the Program at all. For example, if a patent
|
||||
license would not permit royalty-free redistribution of the Program by
|
||||
all those who receive copies directly or indirectly through you, then
|
||||
the only way you could satisfy both it and this License would be to
|
||||
refrain entirely from distribution of the Program.
|
||||
|
||||
If any portion of this section is held invalid or unenforceable under
|
||||
any particular circumstance, the balance of the section is intended to
|
||||
apply and the section as a whole is intended to apply in other
|
||||
circumstances.
|
||||
|
||||
It is not the purpose of this section to induce you to infringe any
|
||||
patents or other property right claims or to contest validity of any
|
||||
such claims; this section has the sole purpose of protecting the
|
||||
integrity of the free software distribution system, which is
|
||||
implemented by public license practices. Many people have made
|
||||
generous contributions to the wide range of software distributed
|
||||
through that system in reliance on consistent application of that
|
||||
system; it is up to the author/donor to decide if he or she is willing
|
||||
to distribute software through any other system and a licensee cannot
|
||||
impose that choice.
|
||||
|
||||
This section is intended to make thoroughly clear what is believed to
|
||||
be a consequence of the rest of this License.
|
||||
|
||||
8. If the distribution and/or use of the Program is restricted in
|
||||
certain countries either by patents or by copyrighted interfaces, the
|
||||
original copyright holder who places the Program under this License
|
||||
may add an explicit geographical distribution limitation excluding
|
||||
those countries, so that distribution is permitted only in or among
|
||||
countries not thus excluded. In such case, this License incorporates
|
||||
the limitation as if written in the body of this License.
|
||||
|
||||
9. The Free Software Foundation may publish revised and/or new versions
|
||||
of the General Public License from time to time. Such new versions will
|
||||
be similar in spirit to the present version, but may differ in detail to
|
||||
address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the Program
|
||||
specifies a version number of this License which applies to it and "any
|
||||
later version", you have the option of following the terms and conditions
|
||||
either of that version or of any later version published by the Free
|
||||
Software Foundation. If the Program does not specify a version number of
|
||||
this License, you may choose any version ever published by the Free Software
|
||||
Foundation.
|
||||
|
||||
10. If you wish to incorporate parts of the Program into other free
|
||||
programs whose distribution conditions are different, write to the author
|
||||
to ask for permission. For software which is copyrighted by the Free
|
||||
Software Foundation, write to the Free Software Foundation; we sometimes
|
||||
make exceptions for this. Our decision will be guided by the two goals
|
||||
of preserving the free status of all derivatives of our free software and
|
||||
of promoting the sharing and reuse of software generally.
|
||||
|
||||
NO WARRANTY
|
||||
|
||||
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
|
||||
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
|
||||
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
|
||||
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
|
||||
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
|
||||
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
|
||||
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
|
||||
REPAIR OR CORRECTION.
|
||||
|
||||
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
|
||||
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
|
||||
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
|
||||
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
|
||||
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
|
||||
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
|
||||
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
|
||||
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
|
||||
POSSIBILITY OF SUCH DAMAGES.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
How to Apply These Terms to Your New Programs
|
||||
|
||||
If you develop a new program, and you want it to be of the greatest
|
||||
possible use to the public, the best way to achieve this is to make it
|
||||
free software which everyone can redistribute and change under these terms.
|
||||
|
||||
To do so, attach the following notices to the program. It is safest
|
||||
to attach them to the start of each source file to most effectively
|
||||
convey the exclusion of warranty; and each file should have at least
|
||||
the "copyright" line and a pointer to where the full notice is found.
|
||||
|
||||
<one line to give the program's name and a brief idea of what it does.>
|
||||
Copyright (C) <year> <name of author>
|
||||
|
||||
This program 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.
|
||||
|
||||
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
|
||||
Also add information on how to contact you by electronic and paper mail.
|
||||
|
||||
If the program is interactive, make it output a short notice like this
|
||||
when it starts in an interactive mode:
|
||||
|
||||
Gnomovision version 69, Copyright (C) year name of author
|
||||
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
|
||||
This is free software, and you are welcome to redistribute it
|
||||
under certain conditions; type `show c' for details.
|
||||
|
||||
The hypothetical commands `show w' and `show c' should show the appropriate
|
||||
parts of the General Public License. Of course, the commands you use may
|
||||
be called something other than `show w' and `show c'; they could even be
|
||||
mouse-clicks or menu items--whatever suits your program.
|
||||
|
||||
You should also get your employer (if you work as a programmer) or your
|
||||
school, if any, to sign a "copyright disclaimer" for the program, if
|
||||
necessary. Here is a sample; alter the names:
|
||||
|
||||
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
|
||||
`Gnomovision' (which makes passes at compilers) written by James Hacker.
|
||||
|
||||
<signature of Ty Coon>, 1 April 1989
|
||||
Ty Coon, President of Vice
|
||||
|
||||
This General Public License does not permit incorporating your program into
|
||||
proprietary programs. If your program is a subroutine library, you may
|
||||
consider it more useful to permit linking proprietary applications with the
|
||||
library. If this is what you want to do, use the GNU Lesser General
|
||||
Public License instead of this License.
|
||||
@@ -1,33 +0,0 @@
|
||||
How to build
|
||||
------------
|
||||
|
||||
1. Extract the files in a location of your choice. The
|
||||
Files will be extracted in a directory called gtpu.
|
||||
|
||||
2. cd <gtpu_dir>/gtpu.
|
||||
|
||||
3. make
|
||||
|
||||
If make is successful, the binary files (libxt_GTPU.so and xt_GTPU.ko)
|
||||
will be created in the Bin folder.
|
||||
|
||||
|
||||
How to install
|
||||
--------------
|
||||
There is no "make install" as that will be difficult to support all
|
||||
possible Linux distro. The cmd.sh file demonstrates how to install
|
||||
the two binary files in the system.
|
||||
|
||||
|
||||
In case of problem:
|
||||
- check you got the last release of the library (see README),
|
||||
- contact the mailing list (see README),
|
||||
- check the bugtracker for known bugs (see README).
|
||||
|
||||
|
||||
Documentation
|
||||
-------------
|
||||
Please have a look at the "Architecture" section in the README.
|
||||
|
||||
|
||||
|
||||
@@ -1,105 +0,0 @@
|
||||
####################################################################################
|
||||
# Makefile for iptables extension for the GTPU target and GTPu klm
|
||||
#
|
||||
# Copyright (c) 2010-2011 Polaris Networks
|
||||
# Author: Pradip Biswas <pradip_biswas@polarisnetworks.net>
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License version 2 as
|
||||
# published by the Free Software Foundation.
|
||||
#
|
||||
####################################################################################
|
||||
|
||||
|
||||
export BIN_DIR ?= $(shell pwd)/Bin
|
||||
KVERSION = $(shell uname -r)
|
||||
KVERSION_LAST_DIGIT = $(shell echo ${KVERSION} | cut -d "." -f 3 | cut -d "-" -f 1)
|
||||
|
||||
obj-m = xt_GTPURH.o
|
||||
EXTRA_CFLAGS += -DKVERSION=$(KVERSION_LAST_DIGIT)
|
||||
|
||||
all: xtlib
|
||||
echo "Building for Kernel Version: $(KVERSION_LAST_DIGIT)"
|
||||
make -C /lib/modules/$(KVERSION)/build M=$(PWD) modules
|
||||
chmod 777 xt_GTPURH.ko
|
||||
mv xt_GTPURH.ko $(BIN_DIR)/
|
||||
|
||||
clean: libclean
|
||||
make -C /lib/modules/$(KVERSION)/build M=$(PWD) clean
|
||||
|
||||
################################################################################
|
||||
# The next section is used by libxt_GTPURH
|
||||
################################################################################
|
||||
|
||||
XT_IPTABLES_VERSION = $(shell /sbin/iptables -V | cut -d " " -f 2 | cut -b 2-)
|
||||
IPT_FIRST_NUM = $(shell echo ${XT_IPTABLES_VERSION} | cut -d "." -f 1 | cut -d "-" -f 1)
|
||||
IPT_SECOND_NUM = $(shell echo ${XT_IPTABLES_VERSION} | cut -d "." -f 2 | cut -d "-" -f 1)
|
||||
IPT_THIRD_NUM = $(shell echo ${XT_IPTABLES_VERSION} | cut -d "." -f 3 | cut -d "-" -f 1)
|
||||
IPTVERSION = $(IPT_FIRST_NUM)$(IPT_SECOND_NUM)$(IPT_THIRD_NUM)
|
||||
IPTABLES_VERSION_STRING = \"$(IPT_FIRST_NUM).$(IPT_SECOND_NUM).$(IPT_THIRD_NUM)\"
|
||||
|
||||
LIB_CC := gcc
|
||||
|
||||
ifeq ($(IPTVERSION), 135)
|
||||
LIB_LD := ld
|
||||
else
|
||||
LIB_LD := gcc
|
||||
endif
|
||||
|
||||
LIB_CFLAGS := -fPIC -Wall -MMD -D_LARGEFILE_SOURCE=1 -D_LARGE_FILES -D_FILE_OFFSET_BITS=64 \
|
||||
-D_REENTRANT -pipe -DXTABLES_LIBDIR=\"/usr/local/libexec/xtables\" -DXTABLES_INTERNAL \
|
||||
-D_INIT=libxt_GTPURH_init -DPIC -fPIC -O2 \
|
||||
-DIPTVERSION=$(IPTVERSION) \
|
||||
-DIPTABLES_VERSION_STRING=$(IPTABLES_VERSION_STRING)
|
||||
|
||||
XT_TARGET := xt_GTPURH
|
||||
XT_LIBNAME := lib$(XT_TARGET).so
|
||||
XT_BUILD_DIR = $(BIN_DIR)/$(XT_TARGET)
|
||||
|
||||
# Get the system distribution type
|
||||
IsDebian=$(shell /bin/cat /proc/version | grep -i -e ubuntu -e debian)
|
||||
IsRedHat=$(shell /bin/cat /proc/version | grep -i -e centos -e "red hat" -e suse -e fedora)
|
||||
|
||||
# Change the ipq library name for 64-bit Debian-based distributions
|
||||
ifeq ($(X86_64),x86_64)
|
||||
ifneq ($(strip $(IsDebian)),)
|
||||
LIB_IPQ=_pic
|
||||
endif
|
||||
endif
|
||||
|
||||
INCLUDE_DIR = -I. \
|
||||
-I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include \
|
||||
-I/usr/lib64/glib-2.0/include
|
||||
|
||||
XT_SOURCES = libxt_GTPURH.c
|
||||
|
||||
XT_OBJECTS := $(addprefix $(XT_BUILD_DIR)/, $(notdir $(XT_SOURCES:.c=.o)))
|
||||
|
||||
xtlib: XT
|
||||
|
||||
XT: DF = $(XT_BUILD_DIR)/$(*F)
|
||||
XT: $(XT_BUILD_DIR) $(BIN_DIR)/$(XT_LIBNAME)
|
||||
|
||||
-include $(addprefix $(XT_BUILD_DIR)/, $(notdir $(XT_SOURCES:.c=.P)))
|
||||
|
||||
$(XT_BUILD_DIR):
|
||||
@echo Build Directory is $@
|
||||
@if [ ! -d $(BIN_DIR) ]; then mkdir $(BIN_DIR); fi
|
||||
@if [ ! -d $@ ]; then mkdir $@; fi
|
||||
|
||||
$(BIN_DIR)/$(XT_LIBNAME): $(XT_OBJECTS)
|
||||
@echo Linking $@
|
||||
@$(LIB_LD) -shared $(XT_OBJECTS) -o $@
|
||||
|
||||
$(XT_BUILD_DIR)/%.o : %.c
|
||||
@echo "Building GTPuRH ext for version $(IPTVERSION) $(IPTABLES_VERSION_STRING)"
|
||||
@echo Compiling $<
|
||||
@$(LIB_CC) $(LIB_CFLAGS) -MF $(DF).d $(INCLUDE_DIR) -o $@ -c $<
|
||||
@cp $(DF).d $(DF).P; \
|
||||
sed -e 's/#.*//' -e 's/^[^:]*: *//' -e 's/ *\\$$//' \
|
||||
-e '/^$$/ d' -e 's/$$/ :/' < $(DF).d >> $(DF).P; \
|
||||
rm -f $(DF).d
|
||||
|
||||
libclean:
|
||||
@rm -rf $(BIN_DIR)/$(XT_LIBNAME) $(XT_BUILD_DIR)
|
||||
|
||||
@@ -1,80 +0,0 @@
|
||||
Introduction
|
||||
------------
|
||||
This piece of software implementes GPRS Tunneling Protocol (GTP) for user plane.
|
||||
The software has two components - one is the extension of iptables that
|
||||
run in user-space. The other is the counterpart of the iptables extension
|
||||
that runs in kernel space.
|
||||
|
||||
|
||||
License
|
||||
-------
|
||||
The project is licensed under GPL2+, see the COPYING and AUTHORS files for more
|
||||
details.
|
||||
|
||||
|
||||
Architecture
|
||||
------------
|
||||
The GTPu tunneling is handled in two parts. The first part is the user-space
|
||||
iptables target extension library (let's call it libxt). The second
|
||||
part is the GTPu kernel loadable module (let's call it gtpu). The way it
|
||||
is, once the user configures a GTPu tunnel attributes using iptables, the klm
|
||||
is loaded by the kernel automatically and handles the IP packets according to
|
||||
the GTPu tunnel attributes set by the user.
|
||||
|
||||
The user can set the action to be taken on a matching IP packet. The action can be
|
||||
either of "add", "remove" or "transport" .
|
||||
|
||||
A GTPu tunnel has the following attributes:
|
||||
- own IP address
|
||||
- own GTPu tunnel id
|
||||
- peer's IP address
|
||||
- peer's GTPu tunnel id
|
||||
|
||||
The GTPU target is designed to work only on mangle table. Also, the user is
|
||||
expected to add GTPU target to the PREROUTING chain, as the GTPU target will
|
||||
modify the original IP packet before it is routed.
|
||||
|
||||
Once the user creates the rule in iptables, the matching IP packets go through
|
||||
the gtpu klm, which acts upon the IP packet according to the action set by the
|
||||
user. The action "Add" means the klm will add a GTPu header to the IP packet.
|
||||
"Remove" will remove the GTPu header from the IP packet and "Transport" will
|
||||
do a Remove first followed by an "Add" on the IP packet.
|
||||
|
||||
For example, consider the following command:
|
||||
|
||||
iptables -t mangle -A PREROUTING -d 10.10.10.1 -j GTPU --own-ip 192.168.0.98 --own-tun 100 --peer-ip 192.168.0.109 --peer-tun 101 --action add
|
||||
|
||||
This command will configure the system to add a GTPu header to any IP packet destined to 10.10.10.1.
|
||||
The source IP address outer IP will be 192.168.0.109, the dest IP will be 192.168.0.98 and
|
||||
the destination GTP tunnel id will be 101.
|
||||
|
||||
Similarly, consider the following command:
|
||||
|
||||
iptables -t mangle -A PREROUTING -s 192.168.0.109 -d 192.168.0.98 -p udp --dport 2152 -j GTPU --action remove
|
||||
|
||||
This command will process all the GTPu packets coming from 192.168.0.109 to 192.168.0.98 to
|
||||
strip the GTPu header and forward the inner IP packet to the kernel's routing engine.
|
||||
|
||||
|
||||
Files
|
||||
---------
|
||||
There are two source C files and one header file:
|
||||
- libxt_GTPU.c : source file for iptables GTPU extension library (libxt)
|
||||
- xt_GTPU.c : source file for gtpu kernel loadable module (klm)
|
||||
- xt_GTPU.h : common header file, shared between the libxt and the klm
|
||||
- Makefile : Makefile to build both the libxt and the klm
|
||||
- cmd.sh : sample cmd file to show how the binaries can be used
|
||||
|
||||
See the INSTALL file to learn how to build the binaries.
|
||||
|
||||
|
||||
References
|
||||
----------
|
||||
3GPP TS 29.281 General Packet Radio System (GPRS)
|
||||
Tunnelling Protocol User Plane (GTP-u)
|
||||
|
||||
|
||||
Authors
|
||||
-------
|
||||
Pradip Biswas <pradip_biswas@polarisnetworks.net>
|
||||
|
||||
@@ -1,7 +0,0 @@
|
||||
|
||||
Known issues in GTPU v1.0
|
||||
-------------------------
|
||||
|
||||
1. Does not implement the "Transport" action.
|
||||
2. Does not handle segmented GTPu packets.
|
||||
|
||||
@@ -1,21 +0,0 @@
|
||||
# Clear the iptables mangle table
|
||||
iptables -t mangle -F
|
||||
|
||||
# Remove GTPU KLM
|
||||
rmmod xt_GTPU
|
||||
|
||||
# Insert the GTPU KLM
|
||||
insmod ./Bin/xt_GTPU.ko
|
||||
|
||||
# Copy the userland iptables extenstion library
|
||||
if [ -d /lib/xtables ]; then
|
||||
/bin/cp -f ./Bin/libxt_GTPU.so /lib/xtables/
|
||||
fi
|
||||
|
||||
if [ -d /lib/iptables ]; then
|
||||
/bin/cp -f ./Bin/libxt_GTPU.so /lib/iptables/libipt_GTPU.so
|
||||
fi
|
||||
|
||||
# Some sample commands for demonstration
|
||||
iptables -t mangle -A PREROUTING -d 10.10.10.1 -j GTPU --own-ip 192.168.0.98 --own-tun 100 --peer-ip 192.168.0.109 --peer-tun 101 --action add
|
||||
iptables -t mangle -A PREROUTING -s 192.168.0.109 -d 192.168.0.98 -p udp --dport 2152 -j GTPU --action remove
|
||||
@@ -1,323 +0,0 @@
|
||||
/* Shared library add-on to iptables for the GTPURH target
|
||||
*
|
||||
* Copyright (c) 2010-2011 Polaris Networks
|
||||
* Author: Pradip Biswas <pradip_biswas@polarisnetworks.net>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdarg.h>
|
||||
#include <getopt.h>
|
||||
#include <sys/socket.h>
|
||||
#include <netinet/in.h>
|
||||
#include <arpa/inet.h>
|
||||
#include <linux/netfilter.h>
|
||||
|
||||
#include "xt_GTPURH.h"
|
||||
|
||||
#if (IPTVERSION <= 135)
|
||||
#include <iptables.h>
|
||||
#elif (IPTVERSION > 135)
|
||||
#include <xtables.h>
|
||||
#endif
|
||||
|
||||
#if (IPTVERSION <= 135)
|
||||
#define GTPURH_PARAM_BAD_VALUE 0
|
||||
#define GTPURH_PARAM_ONLY_ONCE 1
|
||||
#define XT_GTPURH_VERSION IPTABLES_VERSION_STRING
|
||||
#define gtpurh_strtoui(s,v,m,M) !string_to_number(s,m,M,v)
|
||||
#define gtpurh_exit_error exit_error
|
||||
#elif (IPTVERSION > 135) && (IPTVERSION <= 141)
|
||||
#define GTPURH_PARAM_BAD_VALUE P_BAD_VALUE
|
||||
#define GTPURH_PARAM_ONLY_ONCE P_ONLY_ONCE
|
||||
#define XT_GTPURH_VERSION XTABLES_VERSION
|
||||
#define gtpurh_param_act param_act
|
||||
#define gtpurh_strtoui(s,v,m,M) !string_to_number(s,m,M,v)
|
||||
#define gtpurh_exit_error exit_error
|
||||
#elif (IPTVERSION > 141)
|
||||
#define GTPURH_PARAM_BAD_VALUE XTF_BAD_VALUE
|
||||
#define GTPURH_PARAM_ONLY_ONCE XTF_ONLY_ONCE
|
||||
#define XT_GTPURH_VERSION XTABLES_VERSION
|
||||
#define gtpurh_param_act xtables_param_act
|
||||
#define gtpurh_strtoui(s,v,m,M) xtables_strtoui(s,NULL,v,m,M)
|
||||
#define gtpurh_exit_error xtables_error
|
||||
#endif
|
||||
|
||||
enum {
|
||||
PARAM_LADDR = 1 << 0,
|
||||
PARAM_LTUN = 1 << 1,
|
||||
PARAM_RADDR = 1 << 2,
|
||||
PARAM_RTUN = 1 << 3,
|
||||
PARAM_ACTION = 1 << 4,
|
||||
};
|
||||
|
||||
static void GTPURH_help(void)
|
||||
{
|
||||
printf(
|
||||
"GTPUAH target options\n"
|
||||
" --action value Set action <value: remove>\n"
|
||||
" --own-ip value Set own IP address\n"
|
||||
" --own-tun value Set own tunnel id <value: 1-2^31>\n"
|
||||
" --peer-ip value Set peer IP address\n"
|
||||
" --peer-tun value Set peer tunnel id <value: 1-2^31>\n");
|
||||
}
|
||||
|
||||
#if (IPTVERSION <= 135)
|
||||
/* Stolen from iptables v1.4.7 code */
|
||||
void gtpurh_param_act(unsigned int status, const char *p1, ...)
|
||||
{
|
||||
const char *p2, *p3;
|
||||
va_list args;
|
||||
int b;
|
||||
|
||||
va_start(args, p1);
|
||||
|
||||
switch (status) {
|
||||
case GTPURH_PARAM_ONLY_ONCE:
|
||||
p2 = va_arg(args, const char *);
|
||||
b = va_arg(args, unsigned int);
|
||||
|
||||
if (!b)
|
||||
return;
|
||||
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"%s: \"%s\" option may only be specified once",
|
||||
p1, p2);
|
||||
break;
|
||||
|
||||
case GTPURH_PARAM_BAD_VALUE:
|
||||
p2 = va_arg(args, const char *);
|
||||
p3 = va_arg(args, const char *);
|
||||
exit_error(PARAMETER_PROBLEM,
|
||||
"%s: Bad value for \"%s\" option: \"%s\"",
|
||||
p1, p2, p3);
|
||||
break;
|
||||
|
||||
default:
|
||||
exit_error(status, "%s", "Unknown error");
|
||||
break;
|
||||
}
|
||||
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
static void parse_gtpurh_addr(const char *s, struct xt_gtpurh_target_info *info, int flag)
|
||||
{
|
||||
in_addr_t addr;
|
||||
|
||||
if ((addr = inet_addr(s)) == -1) {
|
||||
switch (flag) {
|
||||
case PARAM_LADDR:
|
||||
gtpurh_param_act(GTPURH_PARAM_BAD_VALUE, "GTPURH", "--own-ip", s);
|
||||
break;
|
||||
|
||||
case PARAM_RADDR:
|
||||
gtpurh_param_act(GTPURH_PARAM_BAD_VALUE, "GTPURH", "--peer-ip", s);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
switch (flag) {
|
||||
case PARAM_LADDR:
|
||||
info->laddr = addr;
|
||||
break;
|
||||
|
||||
case PARAM_RADDR:
|
||||
info->raddr = addr;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void parse_gtpurh_tunid(char *s, struct xt_gtpurh_target_info *info, int flag)
|
||||
{
|
||||
unsigned int value;
|
||||
|
||||
if (!gtpurh_strtoui(s, &value, 0, UINT32_MAX)) {
|
||||
switch (flag) {
|
||||
case PARAM_LTUN:
|
||||
gtpurh_param_act(GTPURH_PARAM_BAD_VALUE, "GTPURH", "--own-tun", s);
|
||||
break;
|
||||
|
||||
case PARAM_RTUN:
|
||||
gtpurh_param_act(GTPURH_PARAM_BAD_VALUE, "GTPURH", "--peer-tun", s);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
switch (flag) {
|
||||
case PARAM_LTUN:
|
||||
info->ltun = value;
|
||||
break;
|
||||
|
||||
case PARAM_RTUN:
|
||||
info->rtun = value;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void parse_gtpurh_action(char *s, struct xt_gtpurh_target_info *info, unsigned int *flags)
|
||||
{
|
||||
if (!strcmp(s, "remove")) {
|
||||
info->action = PARAM_GTPURH_ACTION_REM;
|
||||
*flags |= PARAM_GTPURH_ACTION_REM;
|
||||
} else {
|
||||
gtpurh_param_act(GTPURH_PARAM_BAD_VALUE, "GTPURH", "--action", s);
|
||||
}
|
||||
}
|
||||
|
||||
#if (IPTVERSION <= 135)
|
||||
static int
|
||||
GTPURH_parse(int c, char **argv, int invert, unsigned int *flags,
|
||||
const struct ipt_entry *entry,
|
||||
struct ipt_entry_target **target)
|
||||
#else
|
||||
static int
|
||||
GTPURH_parse(int c, char **argv, int invert, unsigned int *flags,
|
||||
const void *entry, struct xt_entry_target **target)
|
||||
#endif
|
||||
{
|
||||
struct xt_gtpurh_target_info *info = (struct xt_gtpurh_target_info *) (*target)->data;
|
||||
|
||||
switch (c) {
|
||||
case '1':
|
||||
gtpurh_param_act(GTPURH_PARAM_ONLY_ONCE, "GTPURH", "--own-ip", *flags & PARAM_LADDR);
|
||||
parse_gtpurh_addr(optarg, info, PARAM_LADDR);
|
||||
*flags |= PARAM_LADDR;
|
||||
return 1;
|
||||
|
||||
case '2':
|
||||
gtpurh_param_act(GTPURH_PARAM_ONLY_ONCE, "GTPURH", "--own-tun", *flags & PARAM_LTUN);
|
||||
parse_gtpurh_tunid(optarg, info, PARAM_LTUN);
|
||||
*flags |= PARAM_LTUN;
|
||||
return 1;
|
||||
|
||||
case '3':
|
||||
gtpurh_param_act(GTPURH_PARAM_ONLY_ONCE, "GTPURH", "--peer-ip", *flags & PARAM_RADDR);
|
||||
parse_gtpurh_addr(optarg, info, PARAM_RADDR);
|
||||
*flags |= PARAM_RADDR;
|
||||
return 1;
|
||||
|
||||
case '4':
|
||||
gtpurh_param_act(GTPURH_PARAM_ONLY_ONCE, "GTPURH", "--peer-tun", *flags & PARAM_RTUN);
|
||||
parse_gtpurh_tunid(optarg, info, PARAM_RTUN);
|
||||
*flags |= PARAM_RTUN;
|
||||
return 1;
|
||||
|
||||
case '5':
|
||||
gtpurh_param_act(GTPURH_PARAM_ONLY_ONCE, "GTPURH", "--action", *flags & PARAM_ACTION);
|
||||
parse_gtpurh_action(optarg, info, flags);
|
||||
*flags |= PARAM_ACTION;
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void GTPURH_check(unsigned int flags)
|
||||
{
|
||||
if (!(flags & PARAM_ACTION)) {
|
||||
gtpurh_exit_error(PARAMETER_PROBLEM, "GTPURH: You must specify action");
|
||||
}
|
||||
|
||||
if (!(flags & PARAM_LADDR)) {
|
||||
gtpurh_exit_error(PARAMETER_PROBLEM, "GTPURH: You must specify local addr");
|
||||
}
|
||||
|
||||
if (!(flags & PARAM_LTUN)) {
|
||||
gtpurh_exit_error(PARAMETER_PROBLEM, "GTPURH: You must specify local tunnel id");
|
||||
}
|
||||
|
||||
if (!(flags & PARAM_RADDR)) {
|
||||
gtpurh_exit_error(PARAMETER_PROBLEM, "GTPURH: You must specify remote addr");
|
||||
}
|
||||
|
||||
if (!(flags & PARAM_RTUN)) {
|
||||
gtpurh_exit_error(PARAMETER_PROBLEM, "GTPURH: You must specify remote tunnel id");
|
||||
}
|
||||
}
|
||||
|
||||
static void convert_action_to_string(int action, char *actionstr)
|
||||
{
|
||||
switch(action) {
|
||||
case PARAM_GTPURH_ACTION_REM:
|
||||
sprintf (actionstr, "remove");
|
||||
break;
|
||||
|
||||
default :
|
||||
sprintf (actionstr, "unspecified!!!");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
#if (IPTVERSION <= 135)
|
||||
static void
|
||||
GTPURH_print(const struct ipt_ip *ip,
|
||||
const struct ipt_entry_target *target,
|
||||
int numeric)
|
||||
|
||||
#else
|
||||
static void
|
||||
GTPURH_print(const void *ip,
|
||||
const struct xt_entry_target *target,
|
||||
int numeric)
|
||||
#endif
|
||||
{
|
||||
const struct xt_gtpurh_target_info *info =
|
||||
(struct xt_gtpurh_target_info *) target->data;
|
||||
|
||||
char laddr[64], raddr[64], actionstr[32];
|
||||
|
||||
convert_action_to_string(info->action, actionstr);
|
||||
|
||||
if (info->action == PARAM_GTPURH_ACTION_REM) {
|
||||
printf("GTPURH action: %s", actionstr);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
static struct option GTPURH_opts[] = {
|
||||
{ "own-ip", 1, NULL, '1' },
|
||||
{ "own-tun", 1, NULL, '2' },
|
||||
{ "peer-ip", 1, NULL, '3' },
|
||||
{ "peer-tun", 1, NULL, '4' },
|
||||
{ "action", 1, NULL, '5' },
|
||||
{ .name = NULL }
|
||||
};
|
||||
|
||||
#if (IPTVERSION <= 135)
|
||||
static struct iptables_target gtpurh_tg_reg = {
|
||||
#else
|
||||
static struct xtables_target gtpurh_tg_reg = {
|
||||
#endif
|
||||
.name = "GTPURH",
|
||||
.version = XT_GTPURH_VERSION,
|
||||
#if (IPTVERSION > 135)
|
||||
.family = NFPROTO_IPV4,
|
||||
#endif
|
||||
.size = XT_ALIGN(sizeof(struct xt_gtpurh_target_info)),
|
||||
.userspacesize = XT_ALIGN(sizeof(struct xt_gtpurh_target_info)),
|
||||
.help = GTPURH_help,
|
||||
.parse = GTPURH_parse,
|
||||
.final_check = GTPURH_check,
|
||||
.print = GTPURH_print,
|
||||
.extra_opts = GTPURH_opts,
|
||||
};
|
||||
|
||||
void _init(void)
|
||||
{
|
||||
#if (IPTVERSION <= 135)
|
||||
register_target(>purh_tg_reg);
|
||||
#else
|
||||
xtables_register_target(>purh_tg_reg);
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -1,650 +0,0 @@
|
||||
/*
|
||||
* GTPu klm for Linux/iptables
|
||||
*
|
||||
* Copyright (c) 2010-2011 Polaris Networks
|
||||
* Author: Pradip Biswas <pradip_biswas@polarisnetworks.net>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/skbuff.h>
|
||||
#include <linux/ip.h>
|
||||
#include <linux/in.h>
|
||||
#include <linux/icmp.h>
|
||||
#include <linux/if_ether.h>
|
||||
#include <linux/route.h>
|
||||
#include <net/checksum.h>
|
||||
#include <net/ip.h>
|
||||
#include <net/udp.h>
|
||||
#include <net/inet_sock.h>
|
||||
#include <net/route.h>
|
||||
#include <linux/netfilter/x_tables.h>
|
||||
#include <linux/netfilter_ipv4/ip_tables.h>
|
||||
#if defined(CONFIG_IP6_NF_IPTABLES) || defined(CONFIG_IP6_NF_IPTABLES_MODULE)
|
||||
# define WITH_IPV6 1
|
||||
#endif
|
||||
#include "xt_GTPURH.h"
|
||||
#if !(defined KVERSION)
|
||||
#error "Kernel version is not defined!!!! Exiting."
|
||||
#endif
|
||||
|
||||
//#define TRACE_IN_KERN_LOG 1
|
||||
#define TRACE_ICMP_IN_KERN_LOG 1
|
||||
|
||||
#if defined(TRACE_IN_KERN_LOG)
|
||||
#define PR_INFO(fORMAT, aRGS...) pr_info(fORMAT, ##aRGS)
|
||||
#else
|
||||
#define PR_INFO(fORMAT, aRGS...)
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_AUTHOR("Pradip Biswas <pradip_biswas@polarisnetworks.net>");
|
||||
MODULE_DESCRIPTION("GTPu Data Path extension on netfilter");
|
||||
//-----------------------------------------------------------------------------
|
||||
static char* _gtpurh_nf_inet_hook_2_string(int nf_inet_hookP);
|
||||
static inline bool _gtpurh_ip_is_fragment(const struct iphdr *iph_p);
|
||||
static void _gtpurh_print_hex_octets(unsigned char* data_pP, unsigned short sizeP);
|
||||
static unsigned int _gtpurh_tg4_rem(struct sk_buff *orig_skb_pP, const struct xt_action_param *par_pP);
|
||||
#if defined(WITH_IPV6)
|
||||
static unsigned int gtpurh_tg6(struct sk_buff *skb_pP, const struct xt_action_param *par_pP);
|
||||
#endif
|
||||
static unsigned int gtpurh_tg4(struct sk_buff *skb_pP, const struct xt_action_param *par_pP);
|
||||
//-----------------------------------------------------------------------------
|
||||
//#define ROUTE_PACKET 1
|
||||
#define NEW_SKB 1
|
||||
|
||||
#define GTPURH_HDR_PNBIT 1
|
||||
#define GTPURH_HDR_SBIT 1 << 1
|
||||
#define GTPURH_HDR_EBIT 1 << 2
|
||||
#define GTPURH_ANY_EXT_HDR_BIT (GTPURH_HDR_PNBIT | GTPURH_HDR_SBIT | GTPURH_HDR_EBIT)
|
||||
#define GTPURH_FAILURE 1
|
||||
#define GTPURH_SUCCESS !GTPURH_FAILURE
|
||||
#define GTPURH_PORT 2152
|
||||
#define GTPURH_2_PRINT_BUFFER_LEN 8192
|
||||
#define NIPADDR(addr) \
|
||||
(uint8_t)(addr & 0x000000FF), \
|
||||
(uint8_t)((addr & 0x0000FF00) >> 8), \
|
||||
(uint8_t)((addr & 0x00FF0000) >> 16), \
|
||||
(uint8_t)((addr & 0xFF000000) >> 24)
|
||||
//-----------------------------------------------------------------------------
|
||||
static char _gtpurh_print_buffer[GTPURH_2_PRINT_BUFFER_LEN];
|
||||
|
||||
static struct xt_target gtpurh_tg_reg[] __read_mostly = {
|
||||
{
|
||||
.name = "GTPURH",
|
||||
.revision = 0,
|
||||
.family = NFPROTO_IPV4,
|
||||
.hooks = (1 << NF_INET_PRE_ROUTING) |
|
||||
(1 << NF_INET_LOCAL_OUT),
|
||||
.proto = IPPROTO_UDP,
|
||||
.table = "raw",
|
||||
.target = gtpurh_tg4,
|
||||
.targetsize = sizeof(struct xt_gtpurh_target_info),
|
||||
.me = THIS_MODULE,
|
||||
},
|
||||
#if defined(WITH_IPV6)
|
||||
{
|
||||
.name = "GTPURH",
|
||||
.revision = 0,
|
||||
.family = NFPROTO_IPV6,
|
||||
.proto = IPPROTO_UDP,
|
||||
.table = "raw",
|
||||
.target = gtpurh_tg6,
|
||||
.me = THIS_MODULE,
|
||||
},
|
||||
#endif
|
||||
};
|
||||
|
||||
struct gtpuhdr {
|
||||
char flags;
|
||||
char msgtype;
|
||||
u_int16_t length;
|
||||
u_int32_t tunid;
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
static char*
|
||||
_gtpurh_icmph_type_2_string(uint8_t typeP)
|
||||
//-----------------------------------------------------------------------------
|
||||
{
|
||||
switch (typeP) {
|
||||
case ICMP_ECHOREPLY:return "ECHOREPLY";break;
|
||||
case ICMP_DEST_UNREACH:return "DEST_UNREACH";break;
|
||||
case ICMP_SOURCE_QUENCH:return "SOURCE_QUENCH";break;
|
||||
case ICMP_REDIRECT:return "REDIRECT";break;
|
||||
case ICMP_ECHO:return "ECHO";break;
|
||||
case ICMP_TIME_EXCEEDED:return "TIME_EXCEEDED";break;
|
||||
case ICMP_PARAMETERPROB:return "PARAMETERPROB";break;
|
||||
case ICMP_TIMESTAMP:return "TIMESTAMP";break;
|
||||
case ICMP_TIMESTAMPREPLY:return "TIMESTAMPREPLY";break;
|
||||
case ICMP_INFO_REQUEST:return "INFO_REQUEST";break;
|
||||
case ICMP_INFO_REPLY:return "INFO_REPLY";break;
|
||||
case ICMP_ADDRESS:return "ADDRESS";break;
|
||||
case ICMP_ADDRESSREPLY:return "ADDRESSREPLY";break;
|
||||
default:return "TYPE?";
|
||||
}
|
||||
}
|
||||
//-----------------------------------------------------------------------------
|
||||
static char*
|
||||
_gtpurh_nf_inet_hook_2_string(int nf_inet_hookP)
|
||||
//-----------------------------------------------------------------------------
|
||||
{
|
||||
switch (nf_inet_hookP) {
|
||||
case NF_INET_PRE_ROUTING:
|
||||
return "NF_INET_PRE_ROUTING";
|
||||
break;
|
||||
|
||||
case NF_INET_LOCAL_IN:
|
||||
return "NF_INET_LOCAL_IN";
|
||||
break;
|
||||
|
||||
case NF_INET_FORWARD:
|
||||
return "NF_INET_FORWARD";
|
||||
break;
|
||||
|
||||
case NF_INET_LOCAL_OUT:
|
||||
return "NF_INET_LOCAL_OUT";
|
||||
break;
|
||||
|
||||
case NF_INET_POST_ROUTING:
|
||||
return "NF_INET_POST_ROUTING";
|
||||
break;
|
||||
|
||||
default:
|
||||
return "NF_INET_UNKNOWN";
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
static inline bool
|
||||
_gtpurh_ip_is_fragment(const struct iphdr *iph_p)
|
||||
{
|
||||
//-----------------------------------------------------------------------------
|
||||
return (iph_p->frag_off & htons(IP_MF | IP_OFFSET)) != 0;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
void _gtpurh_print_hex_octets(unsigned char* data_pP, unsigned short sizeP)
|
||||
//-----------------------------------------------------------------------------
|
||||
{
|
||||
unsigned long octet_index = 0;
|
||||
unsigned long buffer_marker = 0;
|
||||
unsigned char aindex;
|
||||
struct timeval tv;
|
||||
char timeofday[64];
|
||||
unsigned int h,m,s;
|
||||
|
||||
if (data_pP == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (sizeP > 2000) {
|
||||
return;
|
||||
}
|
||||
|
||||
do_gettimeofday(&tv);
|
||||
h = (tv.tv_sec/3600) % 24;
|
||||
m = (tv.tv_sec / 60) % 60;
|
||||
s = tv.tv_sec % 60;
|
||||
snprintf(timeofday, 64, "%02d:%02d:%02d.%06ld", h,m,s,tv.tv_usec);
|
||||
|
||||
buffer_marker+=snprintf(&_gtpurh_print_buffer[buffer_marker], GTPURH_2_PRINT_BUFFER_LEN - buffer_marker,"%s------+-------------------------------------------------+\n",timeofday);
|
||||
buffer_marker+=snprintf(&_gtpurh_print_buffer[buffer_marker], GTPURH_2_PRINT_BUFFER_LEN - buffer_marker,"%s | 0 1 2 3 4 5 6 7 8 9 a b c d e f |\n",timeofday);
|
||||
buffer_marker+=snprintf(&_gtpurh_print_buffer[buffer_marker], GTPURH_2_PRINT_BUFFER_LEN - buffer_marker,"%s------+-------------------------------------------------+\n",timeofday);
|
||||
pr_info("%s",_gtpurh_print_buffer);
|
||||
buffer_marker = 0;
|
||||
|
||||
for (octet_index = 0; octet_index < sizeP; octet_index++) {
|
||||
if ((octet_index % 16) == 0) {
|
||||
if (octet_index != 0) {
|
||||
buffer_marker+=snprintf(&_gtpurh_print_buffer[buffer_marker], GTPURH_2_PRINT_BUFFER_LEN - buffer_marker, " |\n");
|
||||
pr_info("%s",_gtpurh_print_buffer);
|
||||
buffer_marker = 0;
|
||||
}
|
||||
|
||||
buffer_marker+=snprintf(&_gtpurh_print_buffer[buffer_marker], GTPURH_2_PRINT_BUFFER_LEN - buffer_marker, "%s %04ld |",timeofday, octet_index);
|
||||
}
|
||||
|
||||
/*
|
||||
* Print every single octet in hexadecimal form
|
||||
*/
|
||||
buffer_marker+=snprintf(&_gtpurh_print_buffer[buffer_marker], GTPURH_2_PRINT_BUFFER_LEN - buffer_marker, " %02x", data_pP[octet_index]);
|
||||
/*
|
||||
* Align newline and pipes according to the octets in groups of 2
|
||||
*/
|
||||
}
|
||||
|
||||
/*
|
||||
* Append enough spaces and put final pipe
|
||||
*/
|
||||
for (aindex = octet_index; aindex < 16; ++aindex)
|
||||
buffer_marker+=snprintf(&_gtpurh_print_buffer[buffer_marker], GTPURH_2_PRINT_BUFFER_LEN - buffer_marker, " ");
|
||||
|
||||
//SGI_IF_DEBUG(" ");
|
||||
buffer_marker+=snprintf(&_gtpurh_print_buffer[buffer_marker], GTPURH_2_PRINT_BUFFER_LEN - buffer_marker, " |\n");
|
||||
pr_info("%s",_gtpurh_print_buffer);
|
||||
}
|
||||
|
||||
|
||||
#if defined(ROUTE_PACKET)
|
||||
//-----------------------------------------------------------------------------
|
||||
static bool _gtpurh_route_packet(struct sk_buff *skb_pP, const struct xt_gtpurh_target_info *info_pP)
|
||||
//-----------------------------------------------------------------------------
|
||||
{
|
||||
int err = 0;
|
||||
struct rtable *rt = NULL;
|
||||
struct iphdr *iph_p = ip_hdr(skb_pP);
|
||||
int daddr = iph_p->daddr;
|
||||
struct flowi fl = {
|
||||
.u = {
|
||||
.ip4 = {
|
||||
.daddr = daddr,
|
||||
.flowi4_tos = RT_TOS(iph_p->tos),
|
||||
.flowi4_scope = RT_SCOPE_UNIVERSE,
|
||||
}
|
||||
}
|
||||
};
|
||||
//skb_pP->pkt_type = PACKET_OTHERHOST;
|
||||
skb_pP->pkt_type = PACKET_OUTGOING;
|
||||
#if 0
|
||||
pr_info("GTPURH(%d): Routing packet: %d.%d.%d.%d --> %d.%d.%d.%d Proto: %d, Len: %d Mark: %u Packet type: %u\n",
|
||||
info_pP->action,
|
||||
iph_p->saddr & 0xFF,
|
||||
(iph_p->saddr & 0x0000FF00) >> 8,
|
||||
(iph_p->saddr & 0x00FF0000) >> 16,
|
||||
iph_p->saddr >> 24,
|
||||
iph_p->daddr & 0xFF,
|
||||
(iph_p->daddr & 0x0000FF00) >> 8,
|
||||
(iph_p->daddr & 0x00FF0000) >> 16,
|
||||
iph_p->daddr >> 24,
|
||||
iph_p->protocol,
|
||||
ntohs(iph_p->tot_len),
|
||||
skb_pP->mark,
|
||||
skb_pP->pkt_type);
|
||||
#endif
|
||||
rt = ip_route_output_key(&init_net, &fl.u.ip4);
|
||||
|
||||
if (rt == null) {
|
||||
pr_info("GTPURH: Failed to route packet to dst 0x%x. Error: (%d)\n", fl.u.ip4.daddr, err);
|
||||
return GTPURH_FAILURE;
|
||||
}
|
||||
|
||||
#if 0
|
||||
|
||||
if (rt->dst.dev) {
|
||||
pr_info("GTPURH: dst dev name %s\n", rt->dst.dev->name);
|
||||
} else {
|
||||
pr_info("GTPURH: dst dev NULL\n");
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
skb_pP->priority = rt_tos2priority(iph_p->tos);
|
||||
skb_dst_drop(skb_pP);
|
||||
skb_dst_set(skb_pP, &rt->dst);
|
||||
skb_pP->dev = skb_dst(skb_pP)->dev;
|
||||
|
||||
// Send the GTPu message out
|
||||
ip_local_out(skb_pP);
|
||||
|
||||
if (err == 0) {
|
||||
return GTPURH_SUCCESS;
|
||||
} else {
|
||||
return GTPURH_FAILURE;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
static unsigned int
|
||||
_gtpurh_tg4_rem(struct sk_buff *orig_skb_pP, const struct xt_action_param *par_pP)
|
||||
{
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
struct iphdr *iph_p = ip_hdr(orig_skb_pP);
|
||||
struct iphdr *iph2_p = NULL;
|
||||
struct udphdr *udph_p = NULL;
|
||||
struct gtpuhdr *gtpuh_p = NULL;
|
||||
struct sk_buff *skb_p = NULL;
|
||||
#if defined(NEW_SKB)
|
||||
struct sk_buff *new_skb_p = NULL;
|
||||
struct iphdr *new_ip_p = NULL;
|
||||
#endif
|
||||
#if defined(TRACE_ICMP_IN_KERN_LOG)
|
||||
struct icmphdr *icmph_p = NULL;
|
||||
#endif
|
||||
uint16_t gtp_payload_size = 0;
|
||||
|
||||
/* Create a new copy of the original skb_p...can't avoid :-( LG: WHY???*/
|
||||
#if defined(ROUTE_PACKET)
|
||||
skb_p = skb_copy(orig_skb_pP, GFP_ATOMIC);
|
||||
|
||||
if (skb_p == NULL) {
|
||||
return NF_ACCEPT;
|
||||
}
|
||||
|
||||
skb_p->skb_iif = orig_skb_pP->skb_iif;
|
||||
PR_INFO("GTPURH: skb protocol %04X\n", orig_skb_pP->protocol);
|
||||
skb_p->protocol = orig_skb_pP->protocol;
|
||||
#else
|
||||
skb_p = orig_skb_pP;
|
||||
|
||||
if (skb_linearize(skb_p) < 0) {
|
||||
PR_INFO("GTPURH: skb DROPPED (no linearize)\n");
|
||||
return NF_DROP;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//---------------------------
|
||||
// check if is GTPU TUNNEL
|
||||
if (iph_p->protocol != IPPROTO_UDP) {
|
||||
PR_INFO("GTPURH: skb DROPPED Not GTPV1U packet (not UDP)\n");
|
||||
return NF_ACCEPT;
|
||||
}
|
||||
|
||||
//---------------------------
|
||||
// check if is fragment
|
||||
// but should not happen since MTU should have been set bigger than 1500 + GTP encap.
|
||||
// TO DO later segment, but did not succeed in getting in this target all framents of an ip packet!
|
||||
if (_gtpurh_ip_is_fragment(iph_p)) {
|
||||
PR_INFO("GTPURH: ip_is_fragment YES, FLAGS %04X & %04X = %04X\n",
|
||||
iph_p->frag_off,
|
||||
htons(IP_MF | IP_OFFSET),
|
||||
iph_p->frag_off & htons(IP_MF | IP_OFFSET));
|
||||
return NF_ACCEPT;
|
||||
}
|
||||
|
||||
if (skb_p->len <= sizeof (struct udphdr) + sizeof (struct gtpuhdr) + sizeof (struct iphdr)) {
|
||||
PR_INFO("GTPURH: Thought was GTPV1U packet but too short length\n");
|
||||
return NF_ACCEPT;
|
||||
}
|
||||
|
||||
/* Remove IP header */
|
||||
udph_p = (struct udphdr*)skb_pull(skb_p, (iph_p->ihl << 2));
|
||||
|
||||
if (udph_p->dest != htons(GTPURH_PORT)) {
|
||||
PR_INFO("GTPURH: Not GTPV1U packet (bad UDP dest port)\n");
|
||||
skb_push(skb_p, (iph_p->ihl << 2));
|
||||
return NF_ACCEPT;
|
||||
}
|
||||
|
||||
/* Remove UDP header */
|
||||
gtpuh_p = (struct gtpuhdr*)skb_pull(skb_p, sizeof(struct udphdr));
|
||||
gtp_payload_size = ntohs(gtpuh_p->length);
|
||||
|
||||
skb_p->mark = ntohl(gtpuh_p->tunid);
|
||||
/* Remove GTPu header */
|
||||
skb_pull(skb_p, sizeof(struct gtpuhdr));
|
||||
|
||||
/* If additional fields are present in header, remove them also */
|
||||
if (gtpuh_p->flags & GTPURH_ANY_EXT_HDR_BIT) {
|
||||
PR_INFO("GTPURH: GTPURH_ANY_EXT_HDR_BIT found\n");
|
||||
skb_pull(skb_p, sizeof(short) + sizeof(char) + sizeof(char)); /* #Seq, #N-PDU, #ExtHdr Type */
|
||||
gtp_payload_size = gtp_payload_size - sizeof(short) - sizeof(char) - sizeof(char);
|
||||
}
|
||||
|
||||
skb_set_network_header(skb_p, 0);
|
||||
iph2_p = ip_hdr(skb_p);
|
||||
skb_set_transport_header(skb_p, iph2_p->ihl << 2);
|
||||
|
||||
|
||||
if ((iph2_p->version != 4 ) && (iph2_p->version != 6)) {
|
||||
PR_INFO("\nGTPURH: Decapsulated packet dropped because not IPvx protocol see all GTPU packet here:\n");
|
||||
_gtpurh_print_hex_octets((unsigned char*)iph_p, ntohs(iph_p->tot_len));
|
||||
return NF_DROP;
|
||||
}
|
||||
|
||||
#if 0
|
||||
|
||||
if ((skb_p->mark == 0) || (gtp_payload_size != ntohs(iph2_p->tot_len))) {
|
||||
pr_info("\nGTPURH: Decapsulated packet: %d.%d.%d.%d --> %d.%d.%d.%d Proto: %d, Total Len (IP): %u mark %u Frag offset %u Flags 0x%0x\n",
|
||||
iph2_p->saddr & 0xFF,
|
||||
(iph2_p->saddr & 0x0000FF00) >> 8,
|
||||
(iph2_p->saddr & 0x00FF0000) >> 16,
|
||||
iph2_p->saddr >> 24,
|
||||
iph2_p->daddr & 0xFF,
|
||||
(iph2_p->daddr & 0x0000FF00) >> 8,
|
||||
(iph2_p->daddr & 0x00FF0000) >> 16,
|
||||
iph2_p->daddr >> 24,
|
||||
iph2_p->protocol,
|
||||
ntohs(iph2_p->tot_len),
|
||||
skb_p->mark,
|
||||
ntohs(iph_p->frag_off) & 0x1FFFFFFF,
|
||||
ntohs(iph_p->frag_off) >> 13);
|
||||
|
||||
if (gtp_payload_size != ntohs(iph2_p->tot_len)) {
|
||||
pr_info("GTPURH: Mismatch in lengths GTPU length: %u -> %u, IP length %u\n",
|
||||
ntohs(gtpuh_p->length),
|
||||
gtp_payload_size,
|
||||
ntohs(iph2_p->tot_len));
|
||||
|
||||
_gtpurh_print_hex_octets((unsigned char*)iph_p, ntohs(iph_p->tot_len));
|
||||
return NF_DROP;
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
/* Route the packet */
|
||||
#if defined(ROUTE_PACKET)
|
||||
_gtpurh_route_packet(skb_p, tgi_pP);
|
||||
return NF_DROP;
|
||||
#else
|
||||
{
|
||||
int err = 0;
|
||||
struct rtable *rt = NULL;
|
||||
int daddr = iph2_p->daddr;
|
||||
struct flowi fl = {
|
||||
.u = {
|
||||
.ip4 = {
|
||||
.daddr = daddr,
|
||||
.flowi4_tos = RT_TOS(iph2_p->tos),
|
||||
.flowi4_scope = RT_SCOPE_UNIVERSE,
|
||||
}
|
||||
}
|
||||
};
|
||||
rt = ip_route_output_key(&init_net, &fl.u.ip4);
|
||||
|
||||
if (rt == NULL) {
|
||||
PR_INFO("GTPURH: Failed to route packet to dst 0x%x. Error: (%d)\n", fl.u.ip4.daddr, err);
|
||||
return NF_DROP;
|
||||
}
|
||||
|
||||
|
||||
if (rt->dst.dev) {
|
||||
PR_INFO("GTPURH: dst dev name %s\n", rt->dst.dev->name);
|
||||
} else {
|
||||
pr_info("GTPURH: dst dev NULL\n");
|
||||
return NF_DROP;
|
||||
}
|
||||
|
||||
skb_p->priority = rt_tos2priority(iph2_p->tos);
|
||||
skb_p->pkt_type = PACKET_OTHERHOST;
|
||||
skb_dst_drop(skb_p);
|
||||
skb_dst_set(skb_p, dst_clone(&rt->dst));
|
||||
skb_p->dev = skb_dst(skb_p)->dev;
|
||||
|
||||
#if defined(NEW_SKB)
|
||||
new_skb_p = alloc_skb(LL_MAX_HEADER + ntohs(iph2_p->tot_len), GFP_ATOMIC);
|
||||
|
||||
if (new_skb_p == NULL) {
|
||||
return NF_DROP;
|
||||
}
|
||||
|
||||
skb_reserve(new_skb_p, LL_MAX_HEADER + ntohs(iph2_p->tot_len));
|
||||
new_skb_p->protocol = skb_p->protocol;
|
||||
|
||||
new_ip_p = (void *)skb_push(new_skb_p, ntohs(iph2_p->tot_len) - (iph2_p->ihl << 2));
|
||||
skb_reset_transport_header(new_skb_p);
|
||||
new_ip_p = (void *)skb_push(new_skb_p, iph2_p->ihl << 2);
|
||||
memcpy(new_ip_p, iph2_p, ntohs(iph2_p->tot_len));
|
||||
skb_reset_network_header(new_skb_p);
|
||||
skb_reset_inner_network_header(new_skb_p);
|
||||
skb_reset_inner_transport_header(new_skb_p);
|
||||
|
||||
new_skb_p->mark = ntohl(gtpuh_p->tunid);
|
||||
//new_skb_p->mark = skb_p->mark;
|
||||
|
||||
/* ip_route_me_harder expects skb->dst to be set */
|
||||
skb_dst_set(new_skb_p, dst_clone(skb_dst(skb_p)));
|
||||
|
||||
/*if (ip_route_me_harder(new_skb_p, RTN_UNSPEC) < 0) {
|
||||
pr_info("GTPURH: cannot route harder dest 0x%x\n", daddr);
|
||||
goto free_skb;
|
||||
}*/
|
||||
|
||||
new_ip_p->ttl = new_ip_p->ttl -1; // ip4_dst_hoplimit(skb_dst(new_skb_p));
|
||||
new_skb_p->ip_summed = CHECKSUM_NONE;
|
||||
|
||||
if (new_skb_p->len > dst_mtu(skb_dst(new_skb_p))) {
|
||||
PR_INFO("GTPURH: bad length\n");
|
||||
goto free_skb;
|
||||
}
|
||||
|
||||
nf_ct_attach(new_skb_p, skb_p);
|
||||
/*pr_info("GTPURH: ip_local_out %s/%s dev %s src %u.%u.%u.%u dst %u.%u.%u.%u\n",
|
||||
_gtpurh_nf_inet_hook_2_string(par_pP->hooknum),
|
||||
gtpurh_tg_reg[0].table,
|
||||
(new_skb_p->dev == NULL) ? "NULL" : new_skb_p->dev->name,
|
||||
NIPADDR(new_ip_p->saddr),
|
||||
NIPADDR(new_ip_p->daddr));*/
|
||||
#if defined(TRACE_ICMP_IN_KERN_LOG)
|
||||
if (new_ip_p->protocol == IPPROTO_ICMP) {
|
||||
icmph_p = (struct icmphdr*)((uint8_t*)new_ip_p + (new_ip_p->ihl << 2));
|
||||
if ((icmph_p->type == ICMP_ECHOREPLY) || (icmph_p->type == ICMP_ECHO)) {
|
||||
pr_info("GTPURH: %s/%s ICMP src %u.%u.%u.%u dst %u.%u.%u.%u %s id %04X seq %u\n",
|
||||
_gtpurh_nf_inet_hook_2_string(par_pP->hooknum),gtpurh_tg_reg[0].table,
|
||||
NIPADDR(new_ip_p->saddr),
|
||||
NIPADDR(new_ip_p->daddr),
|
||||
_gtpurh_icmph_type_2_string(icmph_p->type),
|
||||
ntohs(icmph_p->un.echo.id),
|
||||
ntohs(icmph_p->un.echo.sequence));
|
||||
}
|
||||
}
|
||||
#endif
|
||||
ip_local_out(new_skb_p);
|
||||
return NF_DROP;
|
||||
free_skb:
|
||||
pr_info("GTPURH: Dropped skb ip_local_out %s/%s\n",
|
||||
_gtpurh_nf_inet_hook_2_string(par_pP->hooknum),
|
||||
gtpurh_tg_reg[0].table);
|
||||
kfree_skb(new_skb_p);
|
||||
return NF_DROP;
|
||||
|
||||
#else
|
||||
|
||||
return NF_ACCEPT;
|
||||
free_skb:
|
||||
pr_info("GTPURH: Dropped skb\n");
|
||||
kfree_skb(skb_p);
|
||||
return NF_DROP;
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
#if defined(WITH_IPV6)
|
||||
//-----------------------------------------------------------------------------
|
||||
static unsigned int
|
||||
gtpurh_tg6(struct sk_buff *skb_pP, const struct xt_action_param *par_pP)
|
||||
//-----------------------------------------------------------------------------
|
||||
{
|
||||
const struct xt_gtpurh_target_info *tgi_p = par_pP->targinfo;
|
||||
int result = NF_DROP;
|
||||
|
||||
if (tgi_p == NULL) {
|
||||
return result;
|
||||
}
|
||||
|
||||
if (tgi_p->action == PARAM_GTPURH_ACTION_REM) {
|
||||
result = NF_DROP; // TO DO
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
#endif
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
static unsigned int
|
||||
gtpurh_tg4(struct sk_buff *skb_pP, const struct xt_action_param *par_pP)
|
||||
//-----------------------------------------------------------------------------
|
||||
{
|
||||
const struct iphdr *iph_p = ip_hdr(skb_pP);
|
||||
const struct rtable *rt_p = skb_rtable(skb_pP);
|
||||
const struct xt_gtpurh_target_info *tgi_p = par_pP->targinfo;
|
||||
|
||||
if (tgi_p == NULL) {
|
||||
return NF_ACCEPT;
|
||||
}
|
||||
|
||||
if ((tgi_p->raddr != iph_p->saddr) || (tgi_p->laddr != iph_p->daddr)) {
|
||||
pr_info("GTPURH: Not processed because of not matching saddr %d.%d.%d.%d raddr %d.%d.%d.%d laddr %d.%d.%d.%d daddr %d.%d.%d.%d\n",
|
||||
NIPADDR(tgi_p->raddr),
|
||||
NIPADDR(iph_p->saddr),
|
||||
NIPADDR(tgi_p->laddr),
|
||||
NIPADDR(iph_p->daddr));
|
||||
return NF_ACCEPT;
|
||||
}
|
||||
|
||||
if (ip_hdrlen(skb_pP) != sizeof(struct iphdr)) {
|
||||
pr_info("GTPURH: Dropped because IP options\n");
|
||||
return NF_DROP;
|
||||
}
|
||||
|
||||
// Drop fragments
|
||||
if (iph_p->frag_off & htons(IP_OFFSET)) {
|
||||
pr_info("GTPURH: Dropped because is fragment\n");
|
||||
return NF_DROP;
|
||||
}
|
||||
|
||||
if (tgi_p->action == PARAM_GTPURH_ACTION_REM) {
|
||||
return _gtpurh_tg4_rem(skb_pP, par_pP);
|
||||
}
|
||||
|
||||
return NF_DROP;
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
static int
|
||||
__init gtpurh_tg_init(void)
|
||||
{
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
pr_info("GTPURH: Initializing module (KVersion: %d)\n", KVERSION);
|
||||
pr_info("GTPURH: Copyright Polaris Networks 2010-2011\n");
|
||||
pr_info("GTPURH: Modified by EURECOM Lionel GAUTHIER 2014\n");
|
||||
#ifndef CMAKER
|
||||
pr_info("GTPURH: Compiled %s at time %s\n",__DATE__,__TIME__);
|
||||
#endif
|
||||
#if defined(WITH_IPV6)
|
||||
pr_info("GTPURH: IPv4/IPv6 enabled\n");
|
||||
#else
|
||||
pr_info("GTPURH: IPv4 only enabled\n");
|
||||
#endif
|
||||
return xt_register_targets(gtpurh_tg_reg, ARRAY_SIZE(gtpurh_tg_reg));
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
static void
|
||||
__exit gtpurh_tg_exit(void)
|
||||
{
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
xt_unregister_targets(gtpurh_tg_reg, ARRAY_SIZE(gtpurh_tg_reg));
|
||||
pr_info("GTPURH: Unloading module\n");
|
||||
}
|
||||
|
||||
module_init(gtpurh_tg_init);
|
||||
module_exit(gtpurh_tg_exit);
|
||||
MODULE_ALIAS("ipt6_GTPURH");
|
||||
MODULE_ALIAS("ipt_GTPURH");
|
||||
|
||||
@@ -1,24 +0,0 @@
|
||||
/* Shared header file for iptables extension for the GTPU target and GTPu KLM
|
||||
*
|
||||
* Copyright (c) 2010-2011 Polaris Networks
|
||||
* Author: Pradip Biswas <pradip_biswas@polarisnetworks.net>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
*/
|
||||
|
||||
enum xt_gtpurh_mode_ {
|
||||
PARAM_GTPURH_ACTION_REM = 1 << 9,
|
||||
};
|
||||
|
||||
struct xt_gtpurh_target_info {
|
||||
u_int32_t laddr __attribute__((aligned(8)));
|
||||
u_int32_t raddr __attribute__((aligned(8)));
|
||||
u_int32_t ltun __attribute__((aligned(8)));
|
||||
u_int32_t rtun __attribute__((aligned(8)));
|
||||
u_int32_t action __attribute__((aligned(8)));
|
||||
};
|
||||
|
||||
|
||||
Reference in New Issue
Block a user