Mirror/youtubeUnblock
1
0
Fork 0
mirror of https://github.com/Waujito/youtubeUnblock.git synced 2025-12-31 21:58:51 +03:00
Code Issues Packages Projects Releases Wiki Activity

Specify dependencies libs explicitly.

Browse Source 
Such setup is better for cross compilation. Also changed Makefile to
properly make the project with these libraries.
This commit is contained in:
Vadim Vetrov
2024-07-22 22:46:16 +03:00
parent 4a4519cbac
commit 822266b74b
131 changed files with 17984 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
deps/libnfnetlink/.gitignore vendored Normal file
View File

@@ -0,0 +1,17 @@
.deps/
.libs/
Makefile
Makefile.in
*.o
*.la
*.lo
/aclocal.m4
/autom4te.cache/
/build-aux/
/config.*
/configure
/libtool
/stamp-h1
/*.pc

339
deps/libnfnetlink/COPYING vendored Normal file
View File

@@ -0,0 +1,339 @@
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
675 Mass Ave, Cambridge, MA 02139, 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 Library 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
Appendix: 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) 19yy <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., 675 Mass Ave, Cambridge, MA 02139, 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) 19yy 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 Library General
Public License instead of this License.

8
deps/libnfnetlink/Make_global.am vendored Normal file
View File

@@ -0,0 +1,8 @@
# This is _NOT_ the library release version, it's an API version.
# Please read Chapter 6 "Library interface versions" of the libtool
# documentation before making any modification
# http://sources.redhat.com/autobook/autobook/autobook_91.html
LIBVERSION=2:0:2
AM_CPPFLAGS = -I$(top_srcdir)/include
AM_CFLAGS = -Wall -fvisibility=hidden -D'NFNL_EXPORT=__attribute__((visibility("default")))'

16
deps/libnfnetlink/Makefile.am vendored Normal file
View File

@@ -0,0 +1,16 @@
include $(top_srcdir)/Make_global.am
ACLOCAL_AMFLAGS = -I m4
EXTRA_DIST = $(man_MANS)
SUBDIRS = src include utils
DIST_SUBDIRS = src include utils
man_MANS = #nfnetlink.3
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = libnfnetlink.pc
dist-hook:
rm -rf `find $(distdir)/debian -name .svn`

50
deps/libnfnetlink/README vendored Normal file
View File

@@ -0,0 +1,50 @@
libnfnetlink - userspace library for handling of netfilter netlink messages
(C) 2001-2005 Netfilter Core Team <coreteam@netfilter.org>
===========================================================================
What is nfnetlink?
nfnetlink is a netlink(7) based kernel/userspace transport layer. It
provides a unified kernel/userspace interface for the various netfilter
subsystems, such as connection tracking, logging and queueing.
What is libnfnetlink?
libnfnetlink is a userspace library that provides some low-level
nfnetlink handling functions. It is used as a foundation for other, netfilter
subsystem specific libraries such as libnfnetlink_conntrack, libnfnetlink_log
and libnfnetlink_queue.
Prerequirements for libnfnetlink
You will need kernel headers from a kernel that has nfnetlink support. The
first official kernel release to include nfnetlink support is 2.6.14.
You can specify the location of your kernel sources using the "--with-kernel="
configure option.
Where can I find documentation?
At the moment, you will have to RTFS. Sorry, but we have barely enough
manpower to keep development ongoing. If you want to conribute documentation,
please contact us.
It has bugs. Where do I report them?
Please report all libnfnetlink bugs to https://bugzilla.netfilter.org/, using
the "libnfnetlink" Product.
License
This library is released under GPLv2+.
Where do I get support?
The netfilter@lists.netfilter.org and netfilter-devel@lists.netfilter.org
mailinglists server as support forum.

37
deps/libnfnetlink/autogen.sh vendored Executable file
View File

@@ -0,0 +1,37 @@
#!/bin/sh -e
include ()
{
# If we keep a copy of the kernel header in the SVN tree, we'll have
# to worry about synchronization issues forever. Instead, we just copy
# the headers that we need from the lastest kernel version at autogen
# stage.
INCLUDEDIR=${KERNEL_DIR:-/lib/modules/`uname -r`/build}/include/linux
if [ -f $INCLUDEDIR/netfilter/nfnetlink.h ]
then
TARGET=include/libnfnetlink/linux_nfnetlink.h
echo "Copying nfnetlink.h to linux_nfnetlink.h"
cp $INCLUDEDIR/netfilter/nfnetlink.h $TARGET
TMP=`mktemp`
sed 's/#include <linux\/netfilter\/nfnetlink_compat\.h>/#include <libnfnetlink\/linux_nfnetlink_compat\.h>/g' $TARGET > $TMP
cp $TMP $TARGET
else
echo "can't find nfnetlink.h kernel file in $INCLUDEDIR"
exit 1
fi
if [ -f $INCLUDEDIR/netfilter/nfnetlink_compat.h ]
then
TARGET=include/libnfnetlink/linux_nfnetlink_compat.h
echo "Copying nfnetlink_compat.h to linux_nfnetlink_compat.h"
cp $INCLUDEDIR/netfilter/nfnetlink_compat.h $TARGET
else
echo "can't find nfnetlink.h kernel file in $INCLUDEDIR, ignoring"
fi
}
[ "x$1" = "xdistrib" ] && include
autoreconf -fi
rm -Rf autom4te.cache

33
deps/libnfnetlink/configure.ac vendored Normal file
View File

@@ -0,0 +1,33 @@
dnl Process this file with autoconf to create configure.
AC_INIT(libnfnetlink, 1.0.2)
AC_CONFIG_AUX_DIR([build-aux])
AC_CONFIG_MACRO_DIR([m4])
AC_CANONICAL_HOST
AM_INIT_AUTOMAKE([-Wall foreign subdir-objects
tar-pax no-dist-gzip dist-xz 1.6])
m4_ifdef([AM_PROG_AR], [AM_PROG_AR])
dnl kernel style compile messages
m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
AC_PROG_CC
AM_PROG_CC_C_O
AC_DISABLE_STATIC
AM_PROG_LIBTOOL
case "$host" in
*-*-linux* | *-*-uclinux*) ;;
*) AC_MSG_ERROR([Linux only, dude!]);;
esac
dnl--------------------------------
dnl--------------------------------
dnl Output the makefile
AC_CONFIG_FILES([Makefile src/Makefile include/Makefile doxygen.cfg
include/libnfnetlink/Makefile utils/Makefile libnfnetlink.pc])
AC_OUTPUT

180
deps/libnfnetlink/doxygen.cfg vendored Normal file
View File

@@ -0,0 +1,180 @@
DOXYFILE_ENCODING = UTF-8
PROJECT_NAME = libnfnetlink
PROJECT_NUMBER = 1.0.2
OUTPUT_DIRECTORY = doxygen
CREATE_SUBDIRS = NO
OUTPUT_LANGUAGE = English
BRIEF_MEMBER_DESC = YES
REPEAT_BRIEF = YES
ABBREVIATE_BRIEF =
ALWAYS_DETAILED_SEC = NO
INLINE_INHERITED_MEMB = NO
FULL_PATH_NAMES = NO
STRIP_FROM_PATH =
STRIP_FROM_INC_PATH =
SHORT_NAMES = NO
JAVADOC_AUTOBRIEF = NO
QT_AUTOBRIEF = NO
MULTILINE_CPP_IS_BRIEF = NO
INHERIT_DOCS = YES
SEPARATE_MEMBER_PAGES = NO
TAB_SIZE = 8
ALIASES =
OPTIMIZE_OUTPUT_FOR_C = YES
OPTIMIZE_OUTPUT_JAVA = NO
OPTIMIZE_FOR_FORTRAN = NO
OPTIMIZE_OUTPUT_VHDL = NO
BUILTIN_STL_SUPPORT = NO
CPP_CLI_SUPPORT = NO
SIP_SUPPORT = NO
DISTRIBUTE_GROUP_DOC = NO
SUBGROUPING = YES
TYPEDEF_HIDES_STRUCT = NO
EXTRACT_ALL = NO
EXTRACT_PRIVATE = NO
EXTRACT_STATIC = NO
EXTRACT_LOCAL_CLASSES = YES
EXTRACT_LOCAL_METHODS = NO
EXTRACT_ANON_NSPACES = NO
HIDE_UNDOC_MEMBERS = NO
HIDE_UNDOC_CLASSES = NO
HIDE_FRIEND_COMPOUNDS = NO
HIDE_IN_BODY_DOCS = NO
INTERNAL_DOCS = NO
CASE_SENSE_NAMES = YES
HIDE_SCOPE_NAMES = NO
SHOW_INCLUDE_FILES = YES
INLINE_INFO = YES
SORT_MEMBER_DOCS = YES
SORT_BRIEF_DOCS = NO
SORT_GROUP_NAMES = NO
SORT_BY_SCOPE_NAME = NO
GENERATE_TODOLIST = YES
GENERATE_TESTLIST = YES
GENERATE_BUGLIST = YES
GENERATE_DEPRECATEDLIST= YES
ENABLED_SECTIONS =
MAX_INITIALIZER_LINES = 30
SHOW_USED_FILES = YES
FILE_VERSION_FILTER =
QUIET = NO
WARNINGS = YES
WARN_IF_UNDOCUMENTED = YES
WARN_IF_DOC_ERROR = YES
WARN_NO_PARAMDOC = NO
WARN_FORMAT = "$file:$line: $text"
WARN_LOGFILE =
INPUT = .
INPUT_ENCODING = UTF-8
FILE_PATTERNS = *.c libnfnetlink.h
RECURSIVE = YES
EXCLUDE =
EXCLUDE_SYMLINKS = NO
EXCLUDE_PATTERNS = */.git/* .*.d
EXCLUDE_SYMBOLS = EXPORT_SYMBOL
EXAMPLE_PATH =
EXAMPLE_PATTERNS =
EXAMPLE_RECURSIVE = NO
IMAGE_PATH =
INPUT_FILTER =
FILTER_PATTERNS =
FILTER_SOURCE_FILES = NO
SOURCE_BROWSER = YES
INLINE_SOURCES = NO
STRIP_CODE_COMMENTS = YES
REFERENCED_BY_RELATION = NO
REFERENCES_RELATION = NO
REFERENCES_LINK_SOURCE = YES
USE_HTAGS = NO
VERBATIM_HEADERS = YES
ALPHABETICAL_INDEX = NO
COLS_IN_ALPHA_INDEX = 5
IGNORE_PREFIX =
GENERATE_HTML = YES
HTML_OUTPUT = html
HTML_FILE_EXTENSION = .html
HTML_HEADER =
HTML_STYLESHEET =
GENERATE_HTMLHELP = NO
GENERATE_DOCSET = NO
DOCSET_FEEDNAME = "Doxygen generated docs"
DOCSET_BUNDLE_ID = org.doxygen.Project
HTML_DYNAMIC_SECTIONS = NO
CHM_FILE =
HHC_LOCATION =
GENERATE_CHI = NO
BINARY_TOC = NO
TOC_EXPAND = NO
DISABLE_INDEX = NO
ENUM_VALUES_PER_LINE = 4
GENERATE_TREEVIEW = NO
TREEVIEW_WIDTH = 250
GENERATE_LATEX = NO
LATEX_OUTPUT = latex
LATEX_CMD_NAME = latex
MAKEINDEX_CMD_NAME = makeindex
COMPACT_LATEX = NO
PAPER_TYPE = a4wide
EXTRA_PACKAGES =
LATEX_HEADER =
PDF_HYPERLINKS = YES
USE_PDFLATEX = YES
LATEX_BATCHMODE = NO
LATEX_HIDE_INDICES = NO
GENERATE_RTF = NO
RTF_OUTPUT = rtf
COMPACT_RTF = NO
RTF_HYPERLINKS = NO
RTF_STYLESHEET_FILE =
RTF_EXTENSIONS_FILE =
GENERATE_MAN = YES
MAN_OUTPUT = man
MAN_EXTENSION = .3
MAN_LINKS = NO
GENERATE_XML = NO
XML_OUTPUT = xml
XML_PROGRAMLISTING = YES
GENERATE_AUTOGEN_DEF = NO
GENERATE_PERLMOD = NO
PERLMOD_LATEX = NO
PERLMOD_PRETTY = YES
PERLMOD_MAKEVAR_PREFIX =
ENABLE_PREPROCESSING = YES
MACRO_EXPANSION = NO
EXPAND_ONLY_PREDEF = NO
SEARCH_INCLUDES = YES
INCLUDE_PATH =
INCLUDE_FILE_PATTERNS =
PREDEFINED =
EXPAND_AS_DEFINED =
SKIP_FUNCTION_MACROS = YES
TAGFILES =
GENERATE_TAGFILE =
ALLEXTERNALS = NO
EXTERNAL_GROUPS = YES
PERL_PATH = /usr/bin/perl
CLASS_DIAGRAMS = YES
MSCGEN_PATH =
HIDE_UNDOC_RELATIONS = YES
HAVE_DOT = YES
CLASS_GRAPH = YES
COLLABORATION_GRAPH = YES
GROUP_GRAPHS = YES
UML_LOOK = NO
TEMPLATE_RELATIONS = NO
INCLUDE_GRAPH = YES
INCLUDED_BY_GRAPH = YES
CALL_GRAPH = NO
CALLER_GRAPH = NO
GRAPHICAL_HIERARCHY = YES
DIRECTORY_GRAPH = YES
DOT_IMAGE_FORMAT = png
DOT_PATH =
DOTFILE_DIRS =
DOT_GRAPH_MAX_NODES = 50
MAX_DOT_GRAPH_DEPTH = 0
DOT_TRANSPARENT = YES
DOT_MULTI_TARGETS = NO
GENERATE_LEGEND = YES
DOT_CLEANUP = YES
SEARCHENGINE = NO

180
deps/libnfnetlink/doxygen.cfg.in vendored Normal file
View File

@@ -0,0 +1,180 @@
DOXYFILE_ENCODING = UTF-8
PROJECT_NAME = @PACKAGE@
PROJECT_NUMBER = @VERSION@
OUTPUT_DIRECTORY = doxygen
CREATE_SUBDIRS = NO
OUTPUT_LANGUAGE = English
BRIEF_MEMBER_DESC = YES
REPEAT_BRIEF = YES
ABBREVIATE_BRIEF =
ALWAYS_DETAILED_SEC = NO
INLINE_INHERITED_MEMB = NO
FULL_PATH_NAMES = NO
STRIP_FROM_PATH =
STRIP_FROM_INC_PATH =
SHORT_NAMES = NO
JAVADOC_AUTOBRIEF = NO
QT_AUTOBRIEF = NO
MULTILINE_CPP_IS_BRIEF = NO
INHERIT_DOCS = YES
SEPARATE_MEMBER_PAGES = NO
TAB_SIZE = 8
ALIASES =
OPTIMIZE_OUTPUT_FOR_C = YES
OPTIMIZE_OUTPUT_JAVA = NO
OPTIMIZE_FOR_FORTRAN = NO
OPTIMIZE_OUTPUT_VHDL = NO
BUILTIN_STL_SUPPORT = NO
CPP_CLI_SUPPORT = NO
SIP_SUPPORT = NO
DISTRIBUTE_GROUP_DOC = NO
SUBGROUPING = YES
TYPEDEF_HIDES_STRUCT = NO
EXTRACT_ALL = NO
EXTRACT_PRIVATE = NO
EXTRACT_STATIC = NO
EXTRACT_LOCAL_CLASSES = YES
EXTRACT_LOCAL_METHODS = NO
EXTRACT_ANON_NSPACES = NO
HIDE_UNDOC_MEMBERS = NO
HIDE_UNDOC_CLASSES = NO
HIDE_FRIEND_COMPOUNDS = NO
HIDE_IN_BODY_DOCS = NO
INTERNAL_DOCS = NO
CASE_SENSE_NAMES = YES
HIDE_SCOPE_NAMES = NO
SHOW_INCLUDE_FILES = YES
INLINE_INFO = YES
SORT_MEMBER_DOCS = YES
SORT_BRIEF_DOCS = NO
SORT_GROUP_NAMES = NO
SORT_BY_SCOPE_NAME = NO
GENERATE_TODOLIST = YES
GENERATE_TESTLIST = YES
GENERATE_BUGLIST = YES
GENERATE_DEPRECATEDLIST= YES
ENABLED_SECTIONS =
MAX_INITIALIZER_LINES = 30
SHOW_USED_FILES = YES
FILE_VERSION_FILTER =
QUIET = NO
WARNINGS = YES
WARN_IF_UNDOCUMENTED = YES
WARN_IF_DOC_ERROR = YES
WARN_NO_PARAMDOC = NO
WARN_FORMAT = "$file:$line: $text"
WARN_LOGFILE =
INPUT = .
INPUT_ENCODING = UTF-8
FILE_PATTERNS = *.c libnfnetlink.h
RECURSIVE = YES
EXCLUDE =
EXCLUDE_SYMLINKS = NO
EXCLUDE_PATTERNS = */.git/* .*.d
EXCLUDE_SYMBOLS = EXPORT_SYMBOL
EXAMPLE_PATH =
EXAMPLE_PATTERNS =
EXAMPLE_RECURSIVE = NO
IMAGE_PATH =
INPUT_FILTER =
FILTER_PATTERNS =
FILTER_SOURCE_FILES = NO
SOURCE_BROWSER = YES
INLINE_SOURCES = NO
STRIP_CODE_COMMENTS = YES
REFERENCED_BY_RELATION = NO
REFERENCES_RELATION = NO
REFERENCES_LINK_SOURCE = YES
USE_HTAGS = NO
VERBATIM_HEADERS = YES
ALPHABETICAL_INDEX = NO
COLS_IN_ALPHA_INDEX = 5
IGNORE_PREFIX =
GENERATE_HTML = YES
HTML_OUTPUT = html
HTML_FILE_EXTENSION = .html
HTML_HEADER =
HTML_STYLESHEET =
GENERATE_HTMLHELP = NO
GENERATE_DOCSET = NO
DOCSET_FEEDNAME = "Doxygen generated docs"
DOCSET_BUNDLE_ID = org.doxygen.Project
HTML_DYNAMIC_SECTIONS = NO
CHM_FILE =
HHC_LOCATION =
GENERATE_CHI = NO
BINARY_TOC = NO
TOC_EXPAND = NO
DISABLE_INDEX = NO
ENUM_VALUES_PER_LINE = 4
GENERATE_TREEVIEW = NO
TREEVIEW_WIDTH = 250
GENERATE_LATEX = NO
LATEX_OUTPUT = latex
LATEX_CMD_NAME = latex
MAKEINDEX_CMD_NAME = makeindex
COMPACT_LATEX = NO
PAPER_TYPE = a4wide
EXTRA_PACKAGES =
LATEX_HEADER =
PDF_HYPERLINKS = YES
USE_PDFLATEX = YES
LATEX_BATCHMODE = NO
LATEX_HIDE_INDICES = NO
GENERATE_RTF = NO
RTF_OUTPUT = rtf
COMPACT_RTF = NO
RTF_HYPERLINKS = NO
RTF_STYLESHEET_FILE =
RTF_EXTENSIONS_FILE =
GENERATE_MAN = YES
MAN_OUTPUT = man
MAN_EXTENSION = .3
MAN_LINKS = NO
GENERATE_XML = NO
XML_OUTPUT = xml
XML_PROGRAMLISTING = YES
GENERATE_AUTOGEN_DEF = NO
GENERATE_PERLMOD = NO
PERLMOD_LATEX = NO
PERLMOD_PRETTY = YES
PERLMOD_MAKEVAR_PREFIX =
ENABLE_PREPROCESSING = YES
MACRO_EXPANSION = NO
EXPAND_ONLY_PREDEF = NO
SEARCH_INCLUDES = YES
INCLUDE_PATH =
INCLUDE_FILE_PATTERNS =
PREDEFINED =
EXPAND_AS_DEFINED =
SKIP_FUNCTION_MACROS = YES
TAGFILES =
GENERATE_TAGFILE =
ALLEXTERNALS = NO
EXTERNAL_GROUPS = YES
PERL_PATH = /usr/bin/perl
CLASS_DIAGRAMS = YES
MSCGEN_PATH =
HIDE_UNDOC_RELATIONS = YES
HAVE_DOT = YES
CLASS_GRAPH = YES
COLLABORATION_GRAPH = YES
GROUP_GRAPHS = YES
UML_LOOK = NO
TEMPLATE_RELATIONS = NO
INCLUDE_GRAPH = YES
INCLUDED_BY_GRAPH = YES
CALL_GRAPH = NO
CALLER_GRAPH = NO
GRAPHICAL_HIERARCHY = YES
DIRECTORY_GRAPH = YES
DOT_IMAGE_FORMAT = png
DOT_PATH =
DOTFILE_DIRS =
DOT_GRAPH_MAX_NODES = 50
MAX_DOT_GRAPH_DEPTH = 0
DOT_TRANSPARENT = YES
DOT_MULTI_TARGETS = NO
GENERATE_LEGEND = YES
DOT_CLEANUP = YES
SEARCHENGINE = NO

2
deps/libnfnetlink/include/Makefile.am vendored Normal file
View File

@@ -0,0 +1,2 @@
SUBDIRS = libnfnetlink
noinst_HEADERS = linux_list.h

3
deps/libnfnetlink/include/libnfnetlink/Makefile.am vendored Normal file
View File

@@ -0,0 +1,3 @@
pkginclude_HEADERS = libnfnetlink.h linux_nfnetlink.h linux_nfnetlink_compat.h

267
deps/libnfnetlink/include/libnfnetlink/libnfnetlink.h vendored Normal file
View File

@@ -0,0 +1,267 @@
/* libnfnetlink.h: Header file for generic netfilter netlink interface
*
* (C) 2002 Harald Welte <laforge@gnumonks.org>
*
* 2005-10-29 Pablo Neira Ayuso <pablo@netfilter.org>:
* Fix NFNL_HEADER_LEN
* 2005-11-13 Pablo Neira Ayuso <pablo@netfilter.org>:
* Define NETLINK_NETFILTER if it's undefined
*/
#ifndef __LIBNFNETLINK_H
#define __LIBNFNETLINK_H
#ifndef aligned_u64
#define aligned_u64 unsigned long long __attribute__((aligned(8)))
#endif
#include <stdint.h>
#include <sys/socket.h> /* for sa_family_t */
#include <linux/netlink.h>
#include <libnfnetlink/linux_nfnetlink.h>
#ifndef NETLINK_NETFILTER
#define NETLINK_NETFILTER 12
#endif
#ifndef SOL_NETLINK
#define SOL_NETLINK 270
#endif
#ifndef NETLINK_BROADCAST_SEND_ERROR
#define NETLINK_BROADCAST_SEND_ERROR 4
#endif
#ifndef NETLINK_NO_ENOBUFS
#define NETLINK_NO_ENOBUFS 5
#endif
#define NLMSG_TAIL(nlh) \
(((void *) (nlh)) + NLMSG_ALIGN((nlh)->nlmsg_len))
#define NFNL_HEADER_LEN (NLMSG_ALIGN(sizeof(struct nlmsghdr)) \
+NLMSG_ALIGN(sizeof(struct nfgenmsg)))
#define NFNL_BUFFSIZE 8192
#ifndef NFNL_EXPORT
#define NFNL_EXPORT
#endif
#ifdef __cplusplus
extern "C" {
#endif
struct nfnlhdr {
struct nlmsghdr nlh;
struct nfgenmsg nfmsg;
};
struct nfnl_callback {
int (*call)(struct nlmsghdr *nlh, struct nfattr *nfa[], void *data);
void *data;
uint16_t attr_count;
};
struct nfnl_handle;
struct nfnl_subsys_handle;
extern NFNL_EXPORT int nfnl_fd(struct nfnl_handle *h);
extern NFNL_EXPORT unsigned int nfnl_portid(const struct nfnl_handle *h);
/* get a new library handle */
extern NFNL_EXPORT struct nfnl_handle *nfnl_open(void);
extern NFNL_EXPORT int nfnl_close(struct nfnl_handle *);
extern NFNL_EXPORT struct nfnl_subsys_handle *nfnl_subsys_open(struct nfnl_handle *,
uint8_t, uint8_t,
unsigned int);
extern NFNL_EXPORT void nfnl_subsys_close(struct nfnl_subsys_handle *);
/* set and unset sequence tracking */
extern NFNL_EXPORT void nfnl_set_sequence_tracking(struct nfnl_handle *h);
extern NFNL_EXPORT void nfnl_unset_sequence_tracking(struct nfnl_handle *h);
/* set receive buffer size (for nfnl_catch) */
extern NFNL_EXPORT void nfnl_set_rcv_buffer_size(struct nfnl_handle *h, unsigned int size);
/* sending of data */
extern NFNL_EXPORT int nfnl_send(struct nfnl_handle *, struct nlmsghdr *);
extern NFNL_EXPORT int nfnl_sendmsg(const struct nfnl_handle *, const struct msghdr *msg,
unsigned int flags);
extern NFNL_EXPORT int nfnl_sendiov(const struct nfnl_handle *nfnlh,
const struct iovec *iov, unsigned int num,
unsigned int flags);
extern NFNL_EXPORT void nfnl_fill_hdr(struct nfnl_subsys_handle *, struct nlmsghdr *,
unsigned int, uint8_t, uint16_t, uint16_t,
uint16_t);
extern NFNL_EXPORT __attribute__((deprecated)) int
nfnl_talk(struct nfnl_handle *, struct nlmsghdr *, pid_t,
unsigned, struct nlmsghdr *,
int (*)(struct sockaddr_nl *, struct nlmsghdr *, void *), void *);
/* simple challenge/response */
extern NFNL_EXPORT __attribute__((deprecated)) int
nfnl_listen(struct nfnl_handle *,
int (*)(struct sockaddr_nl *, struct nlmsghdr *, void *), void *);
/* receiving */
extern NFNL_EXPORT ssize_t nfnl_recv(const struct nfnl_handle *h, unsigned char *buf, size_t len);
extern NFNL_EXPORT int nfnl_callback_register(struct nfnl_subsys_handle *,
uint8_t type, struct nfnl_callback *cb);
extern NFNL_EXPORT int nfnl_callback_unregister(struct nfnl_subsys_handle *, uint8_t type);
extern NFNL_EXPORT int nfnl_handle_packet(struct nfnl_handle *, char *buf, int len);
/* parsing */
extern NFNL_EXPORT struct nfattr *nfnl_parse_hdr(const struct nfnl_handle *nfnlh,
const struct nlmsghdr *nlh,
struct nfgenmsg **genmsg);
extern NFNL_EXPORT int nfnl_check_attributes(const struct nfnl_handle *nfnlh,
const struct nlmsghdr *nlh,
struct nfattr *tb[]);
extern NFNL_EXPORT struct nlmsghdr *nfnl_get_msg_first(struct nfnl_handle *h,
const unsigned char *buf,
size_t len);
extern NFNL_EXPORT struct nlmsghdr *nfnl_get_msg_next(struct nfnl_handle *h,
const unsigned char *buf,
size_t len);
/* callback verdict */
enum {
NFNL_CB_FAILURE = -1, /* failure */
NFNL_CB_STOP = 0, /* stop the query */
NFNL_CB_CONTINUE = 1, /* keep iterating */
};
/* join a certain netlink multicast group */
extern NFNL_EXPORT int nfnl_join(const struct nfnl_handle *nfnlh, unsigned int group);
/* process a netlink message */
extern NFNL_EXPORT int nfnl_process(struct nfnl_handle *h,
const unsigned char *buf,
size_t len);
/* iterator API */
extern NFNL_EXPORT struct nfnl_iterator *
nfnl_iterator_create(const struct nfnl_handle *h,
const char *buf,
size_t len);
extern NFNL_EXPORT void nfnl_iterator_destroy(struct nfnl_iterator *it);
extern NFNL_EXPORT int nfnl_iterator_process(struct nfnl_handle *h,
struct nfnl_iterator *it);
extern NFNL_EXPORT int nfnl_iterator_next(const struct nfnl_handle *h,
struct nfnl_iterator *it);
/* replacement for nfnl_listen */
extern NFNL_EXPORT int nfnl_catch(struct nfnl_handle *h);
/* replacement for nfnl_talk */
extern NFNL_EXPORT int nfnl_query(struct nfnl_handle *h, struct nlmsghdr *nlh);
#define nfnl_attr_present(tb, attr) \
(tb[attr-1])
#define nfnl_get_data(tb, attr, type) \
({ type __ret = 0; \
if (tb[attr-1]) \
__ret = *(type *)NFA_DATA(tb[attr-1]); \
__ret; \
})
#define nfnl_get_pointer_to_data(tb, attr, type) \
({ type *__ret = NULL; \
if (tb[attr-1]) \
__ret = NFA_DATA(tb[attr-1]); \
__ret; \
})
#ifndef NLA_F_NESTED
#define NLA_F_NESTED (1 << 15)
#endif
/* nfnl attribute handling functions */
extern NFNL_EXPORT int nfnl_addattr_l(struct nlmsghdr *, int, int, const void *, int);
extern NFNL_EXPORT int nfnl_addattr8(struct nlmsghdr *, int, int, uint8_t);
extern NFNL_EXPORT int nfnl_addattr16(struct nlmsghdr *, int, int, uint16_t);
extern NFNL_EXPORT int nfnl_addattr32(struct nlmsghdr *, int, int, uint32_t);
extern NFNL_EXPORT int nfnl_nfa_addattr_l(struct nfattr *, int, int, const void *, int);
extern NFNL_EXPORT int nfnl_nfa_addattr16(struct nfattr *, int, int, uint16_t);
extern NFNL_EXPORT int nfnl_nfa_addattr32(struct nfattr *, int, int, uint32_t);
extern NFNL_EXPORT int nfnl_parse_attr(struct nfattr **, int, struct nfattr *, int);
#define nfnl_parse_nested(tb, max, nfa) \
nfnl_parse_attr((tb), (max), NFA_DATA((nfa)), NFA_PAYLOAD((nfa)))
#define nfnl_nest(nlh, bufsize, type) \
({ struct nfattr *__start = NLMSG_TAIL(nlh); \
nfnl_addattr_l(nlh, bufsize, (NLA_F_NESTED | type), NULL, 0); \
__start; })
#define nfnl_nest_end(nlh, tail) \
({ (tail)->nfa_len = (void *) NLMSG_TAIL(nlh) - (void *) tail; })
extern NFNL_EXPORT void nfnl_build_nfa_iovec(struct iovec *iov, struct nfattr *nfa,
uint16_t type, uint32_t len,
unsigned char *val);
extern NFNL_EXPORT unsigned int nfnl_rcvbufsiz(const struct nfnl_handle *h,
unsigned int size);
extern NFNL_EXPORT void nfnl_dump_packet(struct nlmsghdr *, int, char *);
/*
* index to interface name API
*/
#ifndef IFNAMSIZ
#define IFNAMSIZ 16
#endif
struct nlif_handle;
extern NFNL_EXPORT struct nlif_handle *nlif_open(void);
extern NFNL_EXPORT void nlif_close(struct nlif_handle *orig);
extern NFNL_EXPORT int nlif_fd(struct nlif_handle *nlif_handle);
extern NFNL_EXPORT int nlif_query(struct nlif_handle *nlif_handle);
extern NFNL_EXPORT int nlif_catch(struct nlif_handle *nlif_handle);
extern NFNL_EXPORT int nlif_index2name(struct nlif_handle *nlif_handle,
unsigned int if_index,
char *name);
extern NFNL_EXPORT int nlif_get_ifflags(const struct nlif_handle *h,
unsigned int index,
unsigned int *flags);
#ifdef __cplusplus
} /* extern "C" */
#endif
/* Pablo: What is the equivalence of be64_to_cpu in userspace?
*
* Harald: Good question. I don't think there's a standard way [yet?],
* so I'd suggest manually implementing it by "#if little endian" bitshift
* operations in C (at least for now).
*
* All the payload of any nfattr will always be in network byte order.
* This would allow easy transport over a real network in the future
* (e.g. jamal's netlink2).
*
* Pablo: I've called it __be64_to_cpu instead of be64_to_cpu, since maybe
* there will one in the userspace headers someday. We don't want to
* pollute POSIX space naming,
*/
#include <byteswap.h>
#if __BYTE_ORDER == __BIG_ENDIAN
# ifndef __be64_to_cpu
# define __be64_to_cpu(x) (x)
# endif
# else
# if __BYTE_ORDER == __LITTLE_ENDIAN
# ifndef __be64_to_cpu
# define __be64_to_cpu(x) __bswap_64(x)
# endif
# endif
#endif
#endif /* __LIBNFNETLINK_H */

53
deps/libnfnetlink/include/libnfnetlink/linux_nfnetlink.h vendored Normal file
View File

@@ -0,0 +1,53 @@
#ifndef _NFNETLINK_H
#define _NFNETLINK_H
#include <linux/types.h>
#include <libnfnetlink/linux_nfnetlink_compat.h>
enum nfnetlink_groups {
NFNLGRP_NONE,
#define NFNLGRP_NONE NFNLGRP_NONE
NFNLGRP_CONNTRACK_NEW,
#define NFNLGRP_CONNTRACK_NEW NFNLGRP_CONNTRACK_NEW
NFNLGRP_CONNTRACK_UPDATE,
#define NFNLGRP_CONNTRACK_UPDATE NFNLGRP_CONNTRACK_UPDATE
NFNLGRP_CONNTRACK_DESTROY,
#define NFNLGRP_CONNTRACK_DESTROY NFNLGRP_CONNTRACK_DESTROY
NFNLGRP_CONNTRACK_EXP_NEW,
#define NFNLGRP_CONNTRACK_EXP_NEW NFNLGRP_CONNTRACK_EXP_NEW
NFNLGRP_CONNTRACK_EXP_UPDATE,
#define NFNLGRP_CONNTRACK_EXP_UPDATE NFNLGRP_CONNTRACK_EXP_UPDATE
NFNLGRP_CONNTRACK_EXP_DESTROY,
#define NFNLGRP_CONNTRACK_EXP_DESTROY NFNLGRP_CONNTRACK_EXP_DESTROY
__NFNLGRP_MAX,
};
#define NFNLGRP_MAX (__NFNLGRP_MAX - 1)
/* General form of address family dependent message.
*/
struct nfgenmsg {
__u8 nfgen_family; /* AF_xxx */
__u8 version; /* nfnetlink version */
__be16 res_id; /* resource id */
};
#define NFNETLINK_V0 0
/* netfilter netlink message types are split in two pieces:
* 8 bit subsystem, 8bit operation.
*/
#define NFNL_SUBSYS_ID(x) ((x & 0xff00) >> 8)
#define NFNL_MSG_TYPE(x) (x & 0x00ff)
/* No enum here, otherwise __stringify() trick of MODULE_ALIAS_NFNL_SUBSYS()
* won't work anymore */
#define NFNL_SUBSYS_NONE 0
#define NFNL_SUBSYS_CTNETLINK 1
#define NFNL_SUBSYS_CTNETLINK_EXP 2
#define NFNL_SUBSYS_QUEUE 3
#define NFNL_SUBSYS_ULOG 4
#define NFNL_SUBSYS_OSF 5
#define NFNL_SUBSYS_IPSET 6
#define NFNL_SUBSYS_COUNT 7
#endif /* _NFNETLINK_H */

61
deps/libnfnetlink/include/libnfnetlink/linux_nfnetlink_compat.h vendored Normal file
View File

@@ -0,0 +1,61 @@
#ifndef _NFNETLINK_COMPAT_H
#define _NFNETLINK_COMPAT_H
#include <linux/types.h>
/* Old nfnetlink macros for userspace */
/* nfnetlink groups: Up to 32 maximum */
#define NF_NETLINK_CONNTRACK_NEW 0x00000001
#define NF_NETLINK_CONNTRACK_UPDATE 0x00000002
#define NF_NETLINK_CONNTRACK_DESTROY 0x00000004
#define NF_NETLINK_CONNTRACK_EXP_NEW 0x00000008
#define NF_NETLINK_CONNTRACK_EXP_UPDATE 0x00000010
#define NF_NETLINK_CONNTRACK_EXP_DESTROY 0x00000020
/* Generic structure for encapsulation optional netfilter information.
* It is reminiscent of sockaddr, but with sa_family replaced
* with attribute type.
* ! This should someday be put somewhere generic as now rtnetlink and
* ! nfnetlink use the same attributes methods. - J. Schulist.
*/
struct nfattr {
__u16 nfa_len;
__u16 nfa_type; /* we use 15 bits for the type, and the highest
* bit to indicate whether the payload is nested */
};
/* FIXME: Apart from NFNL_NFA_NESTED shamelessly copy and pasted from
* rtnetlink.h, it's time to put this in a generic file */
#define NFNL_NFA_NEST 0x8000
#define NFA_TYPE(attr) ((attr)->nfa_type & 0x7fff)
#define NFA_ALIGNTO 4
#define NFA_ALIGN(len) (((len) + NFA_ALIGNTO - 1) & ~(NFA_ALIGNTO - 1))
#define NFA_OK(nfa,len) ((len) > 0 && (nfa)->nfa_len >= sizeof(struct nfattr) \
&& (nfa)->nfa_len <= (len))
#define NFA_NEXT(nfa,attrlen) ((attrlen) -= NFA_ALIGN((nfa)->nfa_len), \
(struct nfattr *)(((char *)(nfa)) + NFA_ALIGN((nfa)->nfa_len)))
#define NFA_LENGTH(len) (NFA_ALIGN(sizeof(struct nfattr)) + (len))
#define NFA_SPACE(len) NFA_ALIGN(NFA_LENGTH(len))
#define NFA_DATA(nfa) ((void *)(((char *)(nfa)) + NFA_LENGTH(0)))
#define NFA_PAYLOAD(nfa) ((int)((nfa)->nfa_len) - NFA_LENGTH(0))
#define NFA_NEST(skb, type) \
({ struct nfattr *__start = (struct nfattr *)skb_tail_pointer(skb); \
NFA_PUT(skb, (NFNL_NFA_NEST | type), 0, NULL); \
__start; })
#define NFA_NEST_END(skb, start) \
({ (start)->nfa_len = skb_tail_pointer(skb) - (unsigned char *)(start); \
(skb)->len; })
#define NFA_NEST_CANCEL(skb, start) \
({ if (start) \
skb_trim(skb, (unsigned char *) (start) - (skb)->data); \
-1; })
#define NFM_NFA(n) ((struct nfattr *)(((char *)(n)) \
+ NLMSG_ALIGN(sizeof(struct nfgenmsg))))
#define NFM_PAYLOAD(n) NLMSG_PAYLOAD(n, sizeof(struct nfgenmsg))
#endif /* _NFNETLINK_COMPAT_H */

727
deps/libnfnetlink/include/linux_list.h vendored Normal file
View File

@@ -0,0 +1,727 @@
#ifndef _LINUX_LIST_H
#define _LINUX_LIST_H
#include <stddef.h>
#undef offsetof
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
/**
* container_of - cast a member of a structure out to the containing structure
*
* @ptr: the pointer to the member.
* @type: the type of the container struct this is embedded in.
* @member: the name of the member within the struct.
*
*/
#define container_of(ptr, type, member) ({ \
typeof( ((type *)0)->member ) *__mptr = (ptr); \
(type *)( (char *)__mptr - offsetof(type,member) );})
/*
* Check at compile time that something is of a particular type.
* Always evaluates to 1 so you may use it easily in comparisons.
*/
#define typecheck(type,x) \
({ type __dummy; \
typeof(x) __dummy2; \
(void)(&__dummy == &__dummy2); \
1; \
})
#define prefetch(x) ((void)0)
/* empty define to make this work in userspace -HW */
#ifndef smp_wmb
#define smp_wmb()
#endif
/*
* These are non-NULL pointers that will result in page faults
* under normal circumstances, used to verify that nobody uses
* non-initialized list entries.
*/
#define LIST_POISON1 ((void *) 0x00100100)
#define LIST_POISON2 ((void *) 0x00200200)
/*
* Simple doubly linked list implementation.
*
* Some of the internal functions ("__xxx") are useful when
* manipulating whole lists rather than single entries, as
* sometimes we already know the next/prev entries and we can
* generate better code by using them directly rather than
* using the generic single-entry routines.
*/
struct list_head {
struct list_head *next, *prev;
};
#define LIST_HEAD_INIT(name) { &(name), &(name) }
#define LIST_HEAD(name) \
struct list_head name = LIST_HEAD_INIT(name)
#define INIT_LIST_HEAD(ptr) do { \
(ptr)->next = (ptr); (ptr)->prev = (ptr); \
} while (0)
/*
* Insert a new entry between two known consecutive entries.
*
* This is only for internal list manipulation where we know
* the prev/next entries already!
*/
static inline void __list_add(struct list_head *new,
struct list_head *prev,
struct list_head *next)
{
next->prev = new;
new->next = next;
new->prev = prev;
prev->next = new;
}
/**
* list_add - add a new entry
* @new: new entry to be added
* @head: list head to add it after
*
* Insert a new entry after the specified head.
* This is good for implementing stacks.
*/
static inline void list_add(struct list_head *new, struct list_head *head)
{
__list_add(new, head, head->next);
}
/**
* list_add_tail - add a new entry
* @new: new entry to be added
* @head: list head to add it before
*
* Insert a new entry before the specified head.
* This is useful for implementing queues.
*/
static inline void list_add_tail(struct list_head *new, struct list_head *head)
{
__list_add(new, head->prev, head);
}
/*
* Insert a new entry between two known consecutive entries.
*
* This is only for internal list manipulation where we know
* the prev/next entries already!
*/
static inline void __list_add_rcu(struct list_head * new,
struct list_head * prev, struct list_head * next)
{
new->next = next;
new->prev = prev;
smp_wmb();
next->prev = new;
prev->next = new;
}
/**
* list_add_rcu - add a new entry to rcu-protected list
* @new: new entry to be added
* @head: list head to add it after
*
* Insert a new entry after the specified head.
* This is good for implementing stacks.
*
* The caller must take whatever precautions are necessary
* (such as holding appropriate locks) to avoid racing
* with another list-mutation primitive, such as list_add_rcu()
* or list_del_rcu(), running on this same list.
* However, it is perfectly legal to run concurrently with
* the _rcu list-traversal primitives, such as
* list_for_each_entry_rcu().
*/
static inline void list_add_rcu(struct list_head *new, struct list_head *head)
{
__list_add_rcu(new, head, head->next);
}
/**
* list_add_tail_rcu - add a new entry to rcu-protected list
* @new: new entry to be added
* @head: list head to add it before
*
* Insert a new entry before the specified head.
* This is useful for implementing queues.
*
* The caller must take whatever precautions are necessary
* (such as holding appropriate locks) to avoid racing
* with another list-mutation primitive, such as list_add_tail_rcu()
* or list_del_rcu(), running on this same list.
* However, it is perfectly legal to run concurrently with
* the _rcu list-traversal primitives, such as
* list_for_each_entry_rcu().
*/
static inline void list_add_tail_rcu(struct list_head *new,
struct list_head *head)
{
__list_add_rcu(new, head->prev, head);
}
/*
* Delete a list entry by making the prev/next entries
* point to each other.
*
* This is only for internal list manipulation where we know
* the prev/next entries already!
*/
static inline void __list_del(struct list_head * prev, struct list_head * next)
{
next->prev = prev;
prev->next = next;
}
/**
* list_del - deletes entry from list.
* @entry: the element to delete from the list.
* Note: list_empty on entry does not return true after this, the entry is
* in an undefined state.
*/
static inline void list_del(struct list_head *entry)
{
__list_del(entry->prev, entry->next);
entry->next = LIST_POISON1;
entry->prev = LIST_POISON2;
}
/**
* list_del_rcu - deletes entry from list without re-initialization
* @entry: the element to delete from the list.
*
* Note: list_empty on entry does not return true after this,
* the entry is in an undefined state. It is useful for RCU based
* lockfree traversal.
*
* In particular, it means that we can not poison the forward
* pointers that may still be used for walking the list.
*
* The caller must take whatever precautions are necessary
* (such as holding appropriate locks) to avoid racing
* with another list-mutation primitive, such as list_del_rcu()
* or list_add_rcu(), running on this same list.
* However, it is perfectly legal to run concurrently with
* the _rcu list-traversal primitives, such as
* list_for_each_entry_rcu().
*
* Note that the caller is not permitted to immediately free
* the newly deleted entry. Instead, either synchronize_kernel()
* or call_rcu() must be used to defer freeing until an RCU
* grace period has elapsed.
*/
static inline void list_del_rcu(struct list_head *entry)
{
__list_del(entry->prev, entry->next);
entry->prev = LIST_POISON2;
}
/**
* list_del_init - deletes entry from list and reinitialize it.
* @entry: the element to delete from the list.
*/
static inline void list_del_init(struct list_head *entry)
{
__list_del(entry->prev, entry->next);
INIT_LIST_HEAD(entry);
}
/**
* list_move - delete from one list and add as another's head
* @list: the entry to move
* @head: the head that will precede our entry
*/
static inline void list_move(struct list_head *list, struct list_head *head)
{
__list_del(list->prev, list->next);
list_add(list, head);
}
/**
* list_move_tail - delete from one list and add as another's tail
* @list: the entry to move
* @head: the head that will follow our entry
*/
static inline void list_move_tail(struct list_head *list,
struct list_head *head)
{
__list_del(list->prev, list->next);
list_add_tail(list, head);
}
/**
* list_empty - tests whether a list is empty
* @head: the list to test.
*/
static inline int list_empty(const struct list_head *head)
{
return head->next == head;
}
/**
* list_empty_careful - tests whether a list is
* empty _and_ checks that no other CPU might be
* in the process of still modifying either member
*
* NOTE: using list_empty_careful() without synchronization
* can only be safe if the only activity that can happen
* to the list entry is list_del_init(). Eg. it cannot be used
* if another CPU could re-list_add() it.
*
* @head: the list to test.
*/
static inline int list_empty_careful(const struct list_head *head)
{
struct list_head *next = head->next;
return (next == head) && (next == head->prev);
}
static inline void __list_splice(struct list_head *list,
struct list_head *head)
{
struct list_head *first = list->next;
struct list_head *last = list->prev;
struct list_head *at = head->next;
first->prev = head;
head->next = first;
last->next = at;
at->prev = last;
}
/**
* list_splice - join two lists
* @list: the new list to add.
* @head: the place to add it in the first list.
*/
static inline void list_splice(struct list_head *list, struct list_head *head)
{
if (!list_empty(list))
__list_splice(list, head);
}
/**
* list_splice_init - join two lists and reinitialise the emptied list.
* @list: the new list to add.
* @head: the place to add it in the first list.
*
* The list at @list is reinitialised
*/
static inline void list_splice_init(struct list_head *list,
struct list_head *head)
{
if (!list_empty(list)) {
__list_splice(list, head);
INIT_LIST_HEAD(list);
}
}
/**
* list_entry - get the struct for this entry
* @ptr: the &struct list_head pointer.
* @type: the type of the struct this is embedded in.
* @member: the name of the list_struct within the struct.
*/
#define list_entry(ptr, type, member) \
container_of(ptr, type, member)
/**
* list_for_each - iterate over a list
* @pos: the &struct list_head to use as a loop counter.
* @head: the head for your list.
*/
#define list_for_each(pos, head) \
for (pos = (head)->next, prefetch(pos->next); pos != (head); \
pos = pos->next, prefetch(pos->next))
/**
* __list_for_each - iterate over a list
* @pos: the &struct list_head to use as a loop counter.
* @head: the head for your list.
*
* This variant differs from list_for_each() in that it's the
* simplest possible list iteration code, no prefetching is done.
* Use this for code that knows the list to be very short (empty
* or 1 entry) most of the time.
*/
#define __list_for_each(pos, head) \
for (pos = (head)->next; pos != (head); pos = pos->next)
/**
* list_for_each_prev - iterate over a list backwards
* @pos: the &struct list_head to use as a loop counter.
* @head: the head for your list.
*/
#define list_for_each_prev(pos, head) \
for (pos = (head)->prev, prefetch(pos->prev); pos != (head); \
pos = pos->prev, prefetch(pos->prev))
/**
* list_for_each_safe - iterate over a list safe against removal of list entry
* @pos: the &struct list_head to use as a loop counter.
* @n: another &struct list_head to use as temporary storage
* @head: the head for your list.
*/
#define list_for_each_safe(pos, n, head) \
for (pos = (head)->next, n = pos->next; pos != (head); \
pos = n, n = pos->next)
/**
* list_for_each_entry - iterate over list of given type
* @pos: the type * to use as a loop counter.
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
*/
#define list_for_each_entry(pos, head, member) \
for (pos = list_entry((head)->next, typeof(*pos), member), \
prefetch(pos->member.next); \
&pos->member != (head); \
pos = list_entry(pos->member.next, typeof(*pos), member), \
prefetch(pos->member.next))
/**
* list_for_each_entry_reverse - iterate backwards over list of given type.
* @pos: the type * to use as a loop counter.
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
*/
#define list_for_each_entry_reverse(pos, head, member) \
for (pos = list_entry((head)->prev, typeof(*pos), member), \
prefetch(pos->member.prev); \
&pos->member != (head); \
pos = list_entry(pos->member.prev, typeof(*pos), member), \
prefetch(pos->member.prev))
/**
* list_prepare_entry - prepare a pos entry for use as a start point in
* list_for_each_entry_continue
* @pos: the type * to use as a start point
* @head: the head of the list
* @member: the name of the list_struct within the struct.
*/
#define list_prepare_entry(pos, head, member) \
((pos) ? : list_entry(head, typeof(*pos), member))
/**
* list_for_each_entry_continue - iterate over list of given type
* continuing after existing point
* @pos: the type * to use as a loop counter.
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
*/
#define list_for_each_entry_continue(pos, head, member) \
for (pos = list_entry(pos->member.next, typeof(*pos), member), \
prefetch(pos->member.next); \
&pos->member != (head); \
pos = list_entry(pos->member.next, typeof(*pos), member), \
prefetch(pos->member.next))
/**
* list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
* @pos: the type * to use as a loop counter.
* @n: another type * to use as temporary storage
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
*/
#define list_for_each_entry_safe(pos, n, head, member) \
for (pos = list_entry((head)->next, typeof(*pos), member), \
n = list_entry(pos->member.next, typeof(*pos), member); \
&pos->member != (head); \
pos = n, n = list_entry(n->member.next, typeof(*n), member))
/**
* list_for_each_rcu - iterate over an rcu-protected list
* @pos: the &struct list_head to use as a loop counter.
* @head: the head for your list.
*
* This list-traversal primitive may safely run concurrently with
* the _rcu list-mutation primitives such as list_add_rcu()
* as long as the traversal is guarded by rcu_read_lock().
*/
#define list_for_each_rcu(pos, head) \
for (pos = (head)->next, prefetch(pos->next); pos != (head); \
pos = pos->next, ({ smp_read_barrier_depends(); 0;}), prefetch(pos->next))
#define __list_for_each_rcu(pos, head) \
for (pos = (head)->next; pos != (head); \
pos = pos->next, ({ smp_read_barrier_depends(); 0;}))
/**
* list_for_each_safe_rcu - iterate over an rcu-protected list safe
* against removal of list entry
* @pos: the &struct list_head to use as a loop counter.
* @n: another &struct list_head to use as temporary storage
* @head: the head for your list.
*
* This list-traversal primitive may safely run concurrently with
* the _rcu list-mutation primitives such as list_add_rcu()
* as long as the traversal is guarded by rcu_read_lock().
*/
#define list_for_each_safe_rcu(pos, n, head) \
for (pos = (head)->next, n = pos->next; pos != (head); \
pos = n, ({ smp_read_barrier_depends(); 0;}), n = pos->next)
/**
* list_for_each_entry_rcu - iterate over rcu list of given type
* @pos: the type * to use as a loop counter.
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
*
* This list-traversal primitive may safely run concurrently with
* the _rcu list-mutation primitives such as list_add_rcu()
* as long as the traversal is guarded by rcu_read_lock().
*/
#define list_for_each_entry_rcu(pos, head, member) \
for (pos = list_entry((head)->next, typeof(*pos), member), \
prefetch(pos->member.next); \
&pos->member != (head); \
pos = list_entry(pos->member.next, typeof(*pos), member), \
({ smp_read_barrier_depends(); 0;}), \
prefetch(pos->member.next))
/**
* list_for_each_continue_rcu - iterate over an rcu-protected list
* continuing after existing point.
* @pos: the &struct list_head to use as a loop counter.
* @head: the head for your list.
*
* This list-traversal primitive may safely run concurrently with
* the _rcu list-mutation primitives such as list_add_rcu()
* as long as the traversal is guarded by rcu_read_lock().
*/
#define list_for_each_continue_rcu(pos, head) \
for ((pos) = (pos)->next, prefetch((pos)->next); (pos) != (head); \
(pos) = (pos)->next, ({ smp_read_barrier_depends(); 0;}), prefetch((pos)->next))
/*
* Double linked lists with a single pointer list head.
* Mostly useful for hash tables where the two pointer list head is
* too wasteful.
* You lose the ability to access the tail in O(1).
*/
struct hlist_head {
struct hlist_node *first;
};
struct hlist_node {
struct hlist_node *next, **pprev;
};
#define HLIST_HEAD_INIT { .first = NULL }
#define HLIST_HEAD(name) struct hlist_head name = { .first = NULL }
#define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)
#define INIT_HLIST_NODE(ptr) ((ptr)->next = NULL, (ptr)->pprev = NULL)
static inline int hlist_unhashed(const struct hlist_node *h)
{
return !h->pprev;
}
static inline int hlist_empty(const struct hlist_head *h)
{
return !h->first;
}
static inline void __hlist_del(struct hlist_node *n)
{
struct hlist_node *next = n->next;
struct hlist_node **pprev = n->pprev;
*pprev = next;
if (next)
next->pprev = pprev;
}
static inline void hlist_del(struct hlist_node *n)
{
__hlist_del(n);
n->next = LIST_POISON1;
n->pprev = LIST_POISON2;
}
/**
* hlist_del_rcu - deletes entry from hash list without re-initialization
* @n: the element to delete from the hash list.
*
* Note: list_unhashed() on entry does not return true after this,
* the entry is in an undefined state. It is useful for RCU based
* lockfree traversal.
*
* In particular, it means that we can not poison the forward
* pointers that may still be used for walking the hash list.
*
* The caller must take whatever precautions are necessary
* (such as holding appropriate locks) to avoid racing
* with another list-mutation primitive, such as hlist_add_head_rcu()
* or hlist_del_rcu(), running on this same list.
* However, it is perfectly legal to run concurrently with
* the _rcu list-traversal primitives, such as
* hlist_for_each_entry().
*/
static inline void hlist_del_rcu(struct hlist_node *n)
{
__hlist_del(n);
n->pprev = LIST_POISON2;
}
static inline void hlist_del_init(struct hlist_node *n)
{
if (n->pprev) {
__hlist_del(n);
INIT_HLIST_NODE(n);
}
}
#define hlist_del_rcu_init hlist_del_init
static inline void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
{
struct hlist_node *first = h->first;
n->next = first;
if (first)
first->pprev = &n->next;
h->first = n;
n->pprev = &h->first;
}
/**
* hlist_add_head_rcu - adds the specified element to the specified hlist,
* while permitting racing traversals.
* @n: the element to add to the hash list.
* @h: the list to add to.
*
* The caller must take whatever precautions are necessary
* (such as holding appropriate locks) to avoid racing
* with another list-mutation primitive, such as hlist_add_head_rcu()
* or hlist_del_rcu(), running on this same list.
* However, it is perfectly legal to run concurrently with
* the _rcu list-traversal primitives, such as
* hlist_for_each_entry(), but only if smp_read_barrier_depends()
* is used to prevent memory-consistency problems on Alpha CPUs.
* Regardless of the type of CPU, the list-traversal primitive
* must be guarded by rcu_read_lock().
*
* OK, so why don't we have an hlist_for_each_entry_rcu()???
*/
static inline void hlist_add_head_rcu(struct hlist_node *n,
struct hlist_head *h)
{
struct hlist_node *first = h->first;
n->next = first;
n->pprev = &h->first;
smp_wmb();
if (first)
first->pprev = &n->next;
h->first = n;
}
/* next must be != NULL */
static inline void hlist_add_before(struct hlist_node *n,
struct hlist_node *next)
{
n->pprev = next->pprev;
n->next = next;
next->pprev = &n->next;
*(n->pprev) = n;
}
static inline void hlist_add_after(struct hlist_node *n,
struct hlist_node *next)
{
next->next = n->next;
n->next = next;
next->pprev = &n->next;
if(next->next)
next->next->pprev = &next->next;
}
#define hlist_entry(ptr, type, member) container_of(ptr,type,member)
#define hlist_for_each(pos, head) \
for (pos = (head)->first; pos && ({ prefetch(pos->next); 1; }); \
pos = pos->next)
#define hlist_for_each_safe(pos, n, head) \
for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \
pos = n)
/**
* hlist_for_each_entry - iterate over list of given type
* @tpos: the type * to use as a loop counter.
* @pos: the &struct hlist_node to use as a loop counter.
* @head: the head for your list.
* @member: the name of the hlist_node within the struct.
*/
#define hlist_for_each_entry(tpos, pos, head, member) \
for (pos = (head)->first; \
pos && ({ prefetch(pos->next); 1;}) && \
({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
pos = pos->next)
/**
* hlist_for_each_entry_continue - iterate over a hlist continuing after existing point
* @tpos: the type * to use as a loop counter.
* @pos: the &struct hlist_node to use as a loop counter.
* @member: the name of the hlist_node within the struct.
*/
#define hlist_for_each_entry_continue(tpos, pos, member) \
for (pos = (pos)->next; \
pos && ({ prefetch(pos->next); 1;}) && \
({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
pos = pos->next)
/**
* hlist_for_each_entry_from - iterate over a hlist continuing from existing point
* @tpos: the type * to use as a loop counter.
* @pos: the &struct hlist_node to use as a loop counter.
* @member: the name of the hlist_node within the struct.
*/
#define hlist_for_each_entry_from(tpos, pos, member) \
for (; pos && ({ prefetch(pos->next); 1;}) && \
({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
pos = pos->next)
/**
* hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry
* @tpos: the type * to use as a loop counter.
* @pos: the &struct hlist_node to use as a loop counter.
* @n: another &struct hlist_node to use as temporary storage
* @head: the head for your list.
* @member: the name of the hlist_node within the struct.
*/
#define hlist_for_each_entry_safe(tpos, pos, n, head, member) \
for (pos = (head)->first; \
pos && ({ n = pos->next; 1; }) && \
({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
pos = n)
/**
* hlist_for_each_entry_rcu - iterate over rcu list of given type
* @pos: the type * to use as a loop counter.
* @pos: the &struct hlist_node to use as a loop counter.
* @head: the head for your list.
* @member: the name of the hlist_node within the struct.
*
* This list-traversal primitive may safely run concurrently with
* the _rcu list-mutation primitives such as hlist_add_rcu()
* as long as the traversal is guarded by rcu_read_lock().
*/
#define hlist_for_each_entry_rcu(tpos, pos, head, member) \
for (pos = (head)->first; \
pos && ({ prefetch(pos->next); 1;}) && \
({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
pos = pos->next, ({ smp_read_barrier_depends(); 0; }) )
#endif

15
deps/libnfnetlink/libnfnetlink.pc.in vendored Normal file
View File

@@ -0,0 +1,15 @@
# libnfnetlink pkg-config file
prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
includedir=@includedir@
Name: libnfnetlink
Description: Low-level netfilter netlink communication library
URL: http://netfilter.org/projects/libnfnetlink/
Version: @VERSION@
Requires:
Conflicts:
Libs: -L${libdir} -lnfnetlink
Cflags: -I${includedir}

2
deps/libnfnetlink/m4/.gitignore vendored Normal file
View File

@@ -0,0 +1,2 @@
/libtool.m4
/lt*.m4

11
deps/libnfnetlink/src/Makefile.am vendored Normal file
View File

@@ -0,0 +1,11 @@
include $(top_srcdir)/Make_global.am
lib_LTLIBRARIES = libnfnetlink.la
libnfnetlink_la_LDFLAGS = -Wc,-nostartfiles \
-version-info $(LIBVERSION) \
-Wl,--version-script=$(srcdir)/nfnl.version
libnfnetlink_la_SOURCES = libnfnetlink.c iftable.c rtnl.c nfnl.version
EXTRA_libnfnetlink_la_DEPENDENCIES = $(srcdir)/nfnl.version
noinst_HEADERS = iftable.h rtnl.h

348
deps/libnfnetlink/src/iftable.c vendored Normal file
View File

@@ -0,0 +1,348 @@
/* iftable - table of network interfaces
*
* (C) 2004 by Astaro AG, written by Harald Welte <hwelte@astaro.com>
* (C) 2008 by Pablo Neira Ayuso <pablo@netfilter.org>
*
* This software is Free Software and licensed under GNU GPLv2+.
*/
/* IFINDEX handling */
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <assert.h>
#include <linux/netdevice.h>
#include <libnfnetlink/libnfnetlink.h>
#include "rtnl.h"
#include "linux_list.h"
/**
* \defgroup iftable Functions in iftable.c [DEPRECATED]
* This documentation is provided for the benefit of maintainers of legacy code.
*
* New applications should use
* [libmnl](https://netfilter.org/projects/libmnl/doxygen/html/).
* @{
*/
struct ifindex_node {
struct list_head head;
uint32_t index;
uint32_t type;
uint32_t alen;
uint32_t flags;
char addr[8];
char name[16];
};
struct nlif_handle {
struct list_head ifindex_hash[16];
struct rtnl_handle *rtnl_handle;
struct rtnl_handler ifadd_handler;
struct rtnl_handler ifdel_handler;
};
/* iftable_add - Add/Update an entry to/in the interface table
* @n: netlink message header of a RTM_NEWLINK message
* @arg: not used
*
* This function adds/updates an entry in the intrface table.
* Returns -1 on error, 1 on success.
*/
static int iftable_add(struct nlmsghdr *n, void *arg)
{
unsigned int hash, found = 0;
struct ifinfomsg *ifi_msg = NLMSG_DATA(n);
struct ifindex_node *this;
struct rtattr *cb[IFLA_MAX+1];
struct nlif_handle *h = arg;
if (n->nlmsg_type != RTM_NEWLINK)
return -1;
if (n->nlmsg_len < NLMSG_LENGTH(sizeof(ifi_msg)))
return -1;
rtnl_parse_rtattr(cb, IFLA_MAX, IFLA_RTA(ifi_msg), IFLA_PAYLOAD(n));
if (!cb[IFLA_IFNAME])
return -1;
hash = ifi_msg->ifi_index & 0xF;
list_for_each_entry(this, &h->ifindex_hash[hash], head) {
if (this->index == ifi_msg->ifi_index) {
found = 1;
break;
}
}
if (!found) {
this = malloc(sizeof(*this));
if (!this)
return -1;
this->index = ifi_msg->ifi_index;
}
this->type = ifi_msg->ifi_type;
this->flags = ifi_msg->ifi_flags;
if (cb[IFLA_ADDRESS]) {
unsigned int alen;
this->alen = alen = RTA_PAYLOAD(cb[IFLA_ADDRESS]);
if (alen > sizeof(this->addr))
alen = sizeof(this->addr);
memcpy(this->addr, RTA_DATA(cb[IFLA_ADDRESS]), alen);
} else {
this->alen = 0;
memset(this->addr, 0, sizeof(this->addr));
}
strcpy(this->name, RTA_DATA(cb[IFLA_IFNAME]));
if (!found)
list_add(&this->head, &h->ifindex_hash[hash]);
return 1;
}
/* iftable_del - Delete an entry from the interface table
* @n: netlink message header of a RTM_DELLINK nlmsg
* @arg: not used
*
* Delete an entry from the interface table.
* Returns -1 on error, 0 if no matching entry was found or 1 on success.
*/
static int iftable_del(struct nlmsghdr *n, void *arg)
{
struct ifinfomsg *ifi_msg = NLMSG_DATA(n);
struct rtattr *cb[IFLA_MAX+1];
struct nlif_handle *h = arg;
struct ifindex_node *this, *tmp;
unsigned int hash;
if (n->nlmsg_type != RTM_DELLINK)
return -1;
if (n->nlmsg_len < NLMSG_LENGTH(sizeof(ifi_msg)))
return -1;
rtnl_parse_rtattr(cb, IFLA_MAX, IFLA_RTA(ifi_msg), IFLA_PAYLOAD(n));
hash = ifi_msg->ifi_index & 0xF;
list_for_each_entry_safe(this, tmp, &h->ifindex_hash[hash], head) {
if (this->index == ifi_msg->ifi_index) {
list_del(&this->head);
free(this);
return 1;
}
}
return 0;
}
/** Get the name for an ifindex
*
* \param nlif_handle A pointer to a ::nlif_handle created
* \param index ifindex to be resolved
* \param name interface name, pass a buffer of IFNAMSIZ size
* \return -1 on error, 1 on success
*/
int nlif_index2name(struct nlif_handle *h,
unsigned int index,
char *name)
{
unsigned int hash;
struct ifindex_node *this;
assert(h != NULL);
assert(name != NULL);
if (index == 0) {
strcpy(name, "*");
return 1;
}
hash = index & 0xF;
list_for_each_entry(this, &h->ifindex_hash[hash], head) {
if (this->index == index) {
strcpy(name, this->name);
return 1;
}
}
errno = ENOENT;
return -1;
}
/** Get the flags for an ifindex
*
* \param nlif_handle A pointer to a ::nlif_handle created
* \param index ifindex to be resolved
* \param flags pointer to variable used to store the interface flags
* \return -1 on error, 1 on success
*/
int nlif_get_ifflags(const struct nlif_handle *h,
unsigned int index,
unsigned int *flags)
{
unsigned int hash;
struct ifindex_node *this;
assert(h != NULL);
assert(flags != NULL);
if (index == 0) {
errno = ENOENT;
return -1;
}
hash = index & 0xF;
list_for_each_entry(this, &h->ifindex_hash[hash], head) {
if (this->index == index) {
*flags = this->flags;
return 1;
}
}
errno = ENOENT;
return -1;
}
/** Initialize interface table
*
* Initialize rtnl interface and interface table
* Call this before any nlif_* function
*
* \return file descriptor to netlink socket
*/
struct nlif_handle *nlif_open(void)
{
int i;
struct nlif_handle *h;
h = calloc(1, sizeof(struct nlif_handle));
if (h == NULL)
goto err;
for (i=0; i<16; i++)
INIT_LIST_HEAD(&h->ifindex_hash[i]);
h->ifadd_handler.nlmsg_type = RTM_NEWLINK;
h->ifadd_handler.handlefn = iftable_add;
h->ifadd_handler.arg = h;
h->ifdel_handler.nlmsg_type = RTM_DELLINK;
h->ifdel_handler.handlefn = iftable_del;
h->ifdel_handler.arg = h;
h->rtnl_handle = rtnl_open();
if (h->rtnl_handle == NULL)
goto err;
if (rtnl_handler_register(h->rtnl_handle, &h->ifadd_handler) < 0)
goto err_close;
if (rtnl_handler_register(h->rtnl_handle, &h->ifdel_handler) < 0)
goto err_unregister;
return h;
err_unregister:
rtnl_handler_unregister(h->rtnl_handle, &h->ifadd_handler);
err_close:
rtnl_close(h->rtnl_handle);
free(h);
err:
return NULL;
}
/** Destructor of interface table
*
* \param nlif_handle A pointer to a ::nlif_handle created
* via nlif_open()
*/
void nlif_close(struct nlif_handle *h)
{
int i;
struct ifindex_node *this, *tmp;
assert(h != NULL);
rtnl_handler_unregister(h->rtnl_handle, &h->ifadd_handler);
rtnl_handler_unregister(h->rtnl_handle, &h->ifdel_handler);
rtnl_close(h->rtnl_handle);
for (i=0; i<16; i++) {
list_for_each_entry_safe(this, tmp, &h->ifindex_hash[i], head) {
list_del(&this->head);
free(this);
}
}
free(h);
h = NULL; /* bugtrap */
}
/** Receive message from netlink and update interface table
*
* \param nlif_handle A pointer to a ::nlif_handle created
* \return 0 if OK
*/
int nlif_catch(struct nlif_handle *h)
{
assert(h != NULL);
if (h->rtnl_handle)
return rtnl_receive(h->rtnl_handle);
return -1;
}
static int nlif_catch_multi(struct nlif_handle *h)
{
assert(h != NULL);
if (h->rtnl_handle)
return rtnl_receive_multi(h->rtnl_handle);
return -1;
}
/**
* nlif_query - request a dump of interfaces available in the system
* @h: pointer to a valid nlif_handler
*/
int nlif_query(struct nlif_handle *h)
{
assert(h != NULL);
if (rtnl_dump_type(h->rtnl_handle, RTM_GETLINK) < 0)
return -1;
return nlif_catch_multi(h);
}
/** Returns socket descriptor for the netlink socket
*
* \param nlif_handle A pointer to a ::nlif_handle created
* \return The fd or -1 if there's an error
*/
int nlif_fd(struct nlif_handle *h)
{
assert(h != NULL);
if (h->rtnl_handle)
return h->rtnl_handle->rtnl_fd;
return -1;
}
/**
* @}
*/

12
deps/libnfnetlink/src/iftable.h vendored Normal file
View File

@@ -0,0 +1,12 @@
#ifndef _IFTABLE_H
#define _IFTABLE_H
int iftable_delete(uint32_t dst, uint32_t mask, uint32_t gw, uint32_t oif);
int iftable_insert(uint32_t dst, uint32_t mask, uint32_t gw, uint32_t oif);
int iftable_init(void);
void iftable_fini(void);
int iftable_dump(FILE *outfd);
int iftable_up(unsigned int index);
#endif

1602
deps/libnfnetlink/src/libnfnetlink.c vendored Normal file
View File

File diff suppressed because it is too large Load Diff

55
deps/libnfnetlink/src/nfnl.version vendored Normal file
View File

@@ -0,0 +1,55 @@
NFNETLINK_1.0.1 {
global:
nfnl_fd;
nfnl_portid;
nfnl_open;
nfnl_close;
nfnl_subsys_open;
nfnl_subsys_close;
nfnl_set_sequence_tracking;
nfnl_unset_sequence_tracking;
nfnl_set_rcv_buffer_size;
nfnl_send;
nfnl_sendmsg;
nfnl_sendiov;
nfnl_fill_hdr;
nfnl_talk;
nfnl_listen;
nfnl_recv;
nfnl_callback_register;
nfnl_callback_unregister;
nfnl_handle_packet;
nfnl_parse_hdr;
nfnl_check_attributes;
nfnl_get_msg_first;
nfnl_get_msg_next;
nfnl_join;
nfnl_process;
nfnl_iterator_create;
nfnl_iterator_destroy;
nfnl_iterator_process;
nfnl_iterator_next;
nfnl_catch;
nfnl_query;
nfnl_addattr_l;
nfnl_addattr8;
nfnl_addattr16;
nfnl_addattr32;
nfnl_nfa_addattr_l;
nfnl_nfa_addattr16;
nfnl_nfa_addattr32;
nfnl_parse_attr;
nfnl_build_nfa_iovec;
nfnl_rcvbufsiz;
nfnl_dump_packet;
nlif_open;
nlif_close;
nlif_fd;
nlif_query;
nlif_catch;
nlif_index2name;
nlif_get_ifflags;
local:
*;
};

266
deps/libnfnetlink/src/rtnl.c vendored Normal file
View File

@@ -0,0 +1,266 @@
/* rtnl - rtnetlink utility functions
*
* (C) 2004 by Astaro AG, written by Harald Welte <hwelte@astaro.com>
*
* Adapted to nfnetlink by Eric Leblond <eric@inl.fr>
*
* This software is free software and licensed under GNU GPLv2+.
*
*/
/* rtnetlink - routing table netlink interface */
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <netinet/in.h>
#include <linux/types.h>
#include <sys/socket.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include "rtnl.h"
#define rtnl_log(x, ...)
static inline struct rtnl_handler *
find_handler(struct rtnl_handle *rtnl_handle, uint16_t type)
{
struct rtnl_handler *h;
for (h = rtnl_handle->handlers; h; h = h->next) {
if (h->nlmsg_type == type)
return h;
}
return NULL;
}
static int call_handler(struct rtnl_handle *rtnl_handle,
uint16_t type,
struct nlmsghdr *hdr)
{
struct rtnl_handler *h = find_handler(rtnl_handle, type);
if (!h) {
rtnl_log(LOG_DEBUG, "no registered handler for type %u", type);
return 0;
}
return (h->handlefn)(hdr, h->arg);
}
/* rtnl_handler_register - register handler for given nlmsg type
* @hdlr: handler structure
*/
int rtnl_handler_register(struct rtnl_handle *rtnl_handle,
struct rtnl_handler *hdlr)
{
rtnl_log(LOG_DEBUG, "registering handler for type %u",
hdlr->nlmsg_type);
hdlr->next = rtnl_handle->handlers;
rtnl_handle->handlers = hdlr;
return 1;
}
/* rtnl_handler_unregister - unregister handler for given nlmst type
* @hdlr: handler structure
*/
int rtnl_handler_unregister(struct rtnl_handle *rtnl_handle,
struct rtnl_handler *hdlr)
{
struct rtnl_handler *h, *prev = NULL;
rtnl_log(LOG_DEBUG, "unregistering handler for type %u",
hdlr->nlmsg_type);
for (h = rtnl_handle->handlers; h; h = h->next) {
if (h == hdlr) {
if (prev)
prev->next = h->next;
else
rtnl_handle->handlers = h->next;
return 1;
}
prev = h;
}
return 0;
}
int rtnl_parse_rtattr(struct rtattr *tb[], int max, struct rtattr *rta, int len)
{
memset(tb, 0, sizeof(struct rtattr *) * max);
while (RTA_OK(rta, len)) {
if (rta->rta_type <= max)
tb[rta->rta_type] = rta;
rta = RTA_NEXT(rta,len);
}
if (len)
return -1;
return 0;
}
/* rtnl_dump_type - ask rtnetlink to dump a specific table
* @type: type of table to be dumped
*/
int rtnl_dump_type(struct rtnl_handle *rtnl_handle, unsigned int type)
{
struct {
struct nlmsghdr nlh;
struct rtgenmsg g;
} req;
struct sockaddr_nl nladdr;
memset(&nladdr, 0, sizeof(nladdr));
memset(&req, 0, sizeof(req));
nladdr.nl_family = AF_NETLINK;
req.nlh.nlmsg_len = sizeof(req);
req.nlh.nlmsg_type = type;
req.nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST;
req.nlh.nlmsg_pid = 0;
req.nlh.nlmsg_seq = rtnl_handle->rtnl_dump = ++(rtnl_handle->rtnl_seq);
req.g.rtgen_family = AF_INET;
return sendto(rtnl_handle->rtnl_fd, &req, sizeof(req), 0,
(struct sockaddr*)&nladdr, sizeof(nladdr));
}
/* rtnl_receive - receive netlink packets from rtnetlink socket */
int rtnl_receive(struct rtnl_handle *rtnl_handle)
{
int status;
char buf[8192];
struct sockaddr_nl nladdr;
struct iovec iov = { buf, sizeof(buf) };
struct nlmsghdr *h;
struct msghdr msg = {
.msg_name = &nladdr,
.msg_namelen = sizeof(nladdr),
.msg_iov = &iov,
.msg_iovlen = 1,
};
status = recvmsg(rtnl_handle->rtnl_fd, &msg, 0);
if (status < 0) {
if (errno == EINTR)
return 0;
rtnl_log(LOG_NOTICE, "OVERRUN on rtnl socket");
return -1;
}
if (status == 0) {
rtnl_log(LOG_ERROR, "EOF on rtnl socket");
return -1;
}
if (msg.msg_namelen != sizeof(nladdr)) {
rtnl_log(LOG_ERROR, "invalid address size");
return -1;
}
h = (struct nlmsghdr *) buf;
while (NLMSG_OK(h, status)) {
#if 0
if (h->nlmsg_pid != rtnl_local.nl_pid ||
h->nlmsg_seq != rtnl_dump) {
goto skip;
}
#endif
if (h->nlmsg_type == NLMSG_DONE) {
rtnl_log(LOG_NOTICE, "NLMSG_DONE");
return 0;
}
if (h->nlmsg_type == NLMSG_ERROR) {
struct nlmsgerr *err = NLMSG_DATA(h);
if (h->nlmsg_len>=NLMSG_LENGTH(sizeof(struct nlmsgerr)))
errno = -err->error;
rtnl_log(LOG_ERROR, "NLMSG_ERROR, errnp=%d",
errno);
return -1;
}
if (call_handler(rtnl_handle, h->nlmsg_type, h) == 0)
rtnl_log(LOG_NOTICE, "unhandled nlmsg_type %u",
h->nlmsg_type);
h = NLMSG_NEXT(h, status);
}
return 1;
}
int rtnl_receive_multi(struct rtnl_handle *rtnl_handle)
{
while (1) {
if (rtnl_receive(rtnl_handle) <= 0)
break;
}
return 1;
}
/* rtnl_open - constructor of rtnetlink module */
struct rtnl_handle *rtnl_open(void)
{
socklen_t addrlen;
struct rtnl_handle *h;
h = calloc(1, sizeof(struct rtnl_handle));
if (!h)
return NULL;
addrlen = sizeof(h->rtnl_local);
h->rtnl_local.nl_pid = getpid();
h->rtnl_fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (h->rtnl_fd < 0) {
rtnl_log(LOG_ERROR, "unable to create rtnetlink socket");
goto err;
}
memset(&h->rtnl_local, 0, sizeof(h->rtnl_local));
h->rtnl_local.nl_family = AF_NETLINK;
h->rtnl_local.nl_groups = RTMGRP_LINK;
if (bind(h->rtnl_fd, (struct sockaddr *) &h->rtnl_local, addrlen) < 0) {
rtnl_log(LOG_ERROR, "unable to bind rtnetlink socket");
goto err_close;
}
if (getsockname(h->rtnl_fd,
(struct sockaddr *) &h->rtnl_local,
&addrlen) < 0) {
rtnl_log(LOG_ERROR, "cannot gescockname(rtnl_socket)");
goto err_close;
}
if (addrlen != sizeof(h->rtnl_local)) {
rtnl_log(LOG_ERROR, "invalid address size %u", addr_len);
goto err_close;
}
if (h->rtnl_local.nl_family != AF_NETLINK) {
rtnl_log(LOG_ERROR, "invalid AF %u", h->rtnl_local.nl_family);
goto err_close;
}
h->rtnl_seq = time(NULL);
return h;
err_close:
close(h->rtnl_fd);
err:
free(h);
return NULL;
}
/* rtnl_close - destructor of rtnetlink module */
void rtnl_close(struct rtnl_handle *rtnl_handle)
{
close(rtnl_handle->rtnl_fd);
free(rtnl_handle);
return;
}

37
deps/libnfnetlink/src/rtnl.h vendored Normal file
View File

@@ -0,0 +1,37 @@
#ifndef _RTNL_H
#define _RTNL_H
#include <linux/types.h>
#include <linux/rtnetlink.h>
struct rtnl_handler {
struct rtnl_handler *next;
uint16_t nlmsg_type;
int (*handlefn)(struct nlmsghdr *h, void *arg);
void *arg;
};
struct rtnl_handle {
int rtnl_fd;
int rtnl_seq;
int rtnl_dump;
struct sockaddr_nl rtnl_local;
struct rtnl_handler *handlers;
};
/* api for handler plugins */
int rtnl_handler_register(struct rtnl_handle *rtnl_handle,
struct rtnl_handler *hdlr);
int rtnl_handler_unregister(struct rtnl_handle *rtnl_handle,
struct rtnl_handler *hdlr);
int rtnl_parse_rtattr(struct rtattr *tb[], int max, struct rtattr *rta, int len);
int rtnl_dump_type(struct rtnl_handle *rtnl_handle, unsigned int type);
/* api for core program */
struct rtnl_handle *rtnl_open(void);
void rtnl_close(struct rtnl_handle *rtnl_handle);
int rtnl_receive(struct rtnl_handle *rtnl_handle);
int rtnl_receive_multi(struct rtnl_handle *rtnl_handle);
#endif

1
deps/libnfnetlink/utils/.gitignore vendored Normal file
View File

@@ -0,0 +1 @@
/iftest

7
deps/libnfnetlink/utils/Makefile.am vendored Normal file
View File

@@ -0,0 +1,7 @@
include $(top_srcdir)/Make_global.am
check_PROGRAMS = iftest
iftest_SOURCES = iftest.c
iftest_LDADD = ../src/libnfnetlink.la
iftest_LDFLAGS = -dynamic -ldl

52
deps/libnfnetlink/utils/iftest.c vendored Normal file
View File

@@ -0,0 +1,52 @@
/* simple test for index to interface name API */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <net/if.h>
#include <libnfnetlink/libnfnetlink.h>
int main(int argc, char *argv[])
{
int idx;
struct nlif_handle *h;
char name[IFNAMSIZ];
unsigned int flags;
if (argc != 2) {
fprintf(stderr, "Usage: %s <interface>\n", argv[0]);
exit(EXIT_FAILURE);
}
h = nlif_open();
if (h == NULL) {
perror("nlif_open");
exit(EXIT_FAILURE);
}
if (nlif_query(h) == -1) {
fprintf(stderr, "failed query to retrieve interfaces: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}
idx = if_nametoindex(argv[1]);
/* Superfluous: just to make sure nlif_index2name is working fine */
if (nlif_index2name(h, idx, name) == -1)
fprintf(stderr, "Cannot translate device idx=%u\n", idx);
if (nlif_get_ifflags(h, idx, &flags) == -1) {
fprintf(stderr, "Cannot get flags for device `%s'\n", argv[1]);
exit(EXIT_FAILURE);
}
printf("index (%d) is %s (%s) (%s)\n", idx, argv[1],
flags & IFF_RUNNING ? "RUNNING" : "NOT RUNNING",
flags & IFF_UP ? "UP" : "DOWN");
nlif_close(h);
return EXIT_SUCCESS;
}