Update CHANGES file.

add an include guard to config.h

.gitignore

@@ -0,0 +1,2 @@
+build/**
+include/tins/config.h

CHANGES

@@ -1,3 +1,209 @@
+v3.2
+
+- Added include guard for config.h.
+
+- The functor used on BaseSniffer::sniff_loop can now take a Packet.
+
+- Added mcs, tx_flags, ext and data_retries options to RadioTap.
+
+- Fixed big endian representation of RadioTap header.
+
+- RadioTap's dbm_signal and dbm_noise are now signed.
+
+- RadioTap now throws if an option is not present when getting
+its value.
+
+- TKIP decryption now works correctly on packets from AP to STA.
+
+- Added support for PKTAP header.
+
+- Fixed endian issue on IPv4Address::ip_to_int on Windows.
+
+- Fixed IP parsing when total length is 0 due to TCP segmentation offload.
+
+- Re-added support for pkg-config.
+
+- TCPStreamFollower now calls PDU::find_pdu instead of PDU::rfind_pdu.
+
+- Fixed assertion throw caused by DNS parsing on Windows on debug mode.
+
+- Added throw on BSD when trying to send_recv L3 packets.
+
+- Added Loopback::matches_response.
+
+- Removed obsolete autotools files.
+
+- Fixed exception thrown when an interface didn't have an IP address 
+on NetworkInterface.
+
+- Added NetworkInterface::is_loopback.
+
+- Moved all headers to the directory include/tins.
+
+- Fixed compilation warning on TCPStramFollower due to signed to unsigned
+conversion on integral constant.
+
+- BaseSniffer::get_pcap_handle is now public.
+
+- PPPoE session packets are now parsed correctly.
+
+- Fixed invalid Loopback protocol detection on FreeBSD/OSX.
+
+- Fixed OSX IP packet sending issue.
+
+- Added useful constructors to RawPDU.
+
+- Fixed compilation errors on FreeBSD.
+
+- Improved documentation on several classes.
+
+- Fixed parsing bug when allocating IP over IP packets.
+
+- Fixed Windows network interface naming.
+
+- Utils::network_interface returns pcap compatible names on Windows.
+
+- NetworkInterface::name now works on Windows.
+
+- Added documentation generation through the build system.
+
+- Added SnifferConfiguration class.
+
+- Fixed bug on Dot3 serialization.
+
+- Added OfflinePacketFilter class.
+
+- Renamed NOEXCEPT macro to TINS_NOEXCEPT.
+
+- Added DataLinkType class.
+
+- IPv4Address now uses inet_pton when constructing from string. 
+
+v3.1 - Sun Aug 24 21:39:43 ART 2014
+
+- Fixed ICMPv6 checksum error on serialization.
+
+- Fixed empty domain name encoding on DNS.
+
+- Changed the build system to CMake.
+
+v3.0 - Thu Aug  7 21:39:09 ART 2014
+
+- Timestamps can now be constructed from std::chrono::duration.
+
+- Packets can now be constructed from a PDU pointer and take ownership
+of it.
+
+- All protocols now set the next layer protocol flag, regardless if 
+it was already set. This was not done in some protocols, 
+like EthernetII, and as a consequence if the network layer protocol
+was replaced by other, the packet would be serialized incorrectly.
+
+- Fixed invalid parsing of some unknown DNS records.
+
+- Fixed unaligned memory accesses that were not supported under
+ARMv4 and ARMv5.
+
+- Added BaseSniffer::set_extract_raw_pdus.
+
+- Reduced minimum automake version to 1.11.
+
+- Added Utils::to_string(PDU::PDUType).
+
+- Fixed error compilations on Windows.
+
+- Fixed ICMPv6 checksum calculation.
+
+- Added method in IP and TCP to emplace an option (C++11 only).
+
+- Added small option optimization to PDUOption.
+
+- Fixed error compilation on RSNInformation.
+
+- Renamed ICMP::check to ICMP::checksum.
+
+- Added Sniffer support to set interface to promiscuous mode.
+
+- TCPStreamFollower now handles overlapping fragments correctly.
+
+- Fixed bugs in TCPStreamFollower which didn't allow it to follow
+stream correctly.
+
+- TCPStreamFollower now doesn't clear its state after every call to
+TCPStreamFollower::follow_streams.
+
+- Added IPv6 flag check to pdu_flag_to_ip_type.
+
+- Added DHCP::hostname to extract the hostname options.
+
+- Removed extra qualifier on SessionKeys::decrypt_unicast which 
+produced compilation errors on some platforms.
+
+- PacketSender::send now uses PDU::matches_flag to match specific
+PDU types.
+
+- Removed 'no newline at end of file' warnings.
+
+- Fixed bug when calling BIOCIMMEDIATE on *BSD.
+
+- Fixed bug on PacketSender::send_recv which didn't work under *BSD.
+
+- Fixed bug triggered by not including the string header.
+
+v2.0 - Thu Jan 23 11:09:38 ART 2014 
+
+- DNSResourceRecord was removed. Now DNS records are added using 
+DNS::Resource.
+
+- tins.h now includes ppi.h.
+
+- Done significant improvements in the speed of DNS parsing.
+
+- Added PDUOption<>::to<> which converts a PDUOption to a specific type.
+
+- Layer 3 packets sent using PacketSender::send_recv for which the 
+answer is a different PDU type.
+
+- ICMP::gateway now uses IPv4Address.
+
+- Added support for ICMP address mask request/reply.
+
+- Fixed bug in PacketSender when using send_recv and a layer 2 PDU. The 
+interface in which the packet was sent was not the default_interface 
+set when the sender was constructed.
+
+- IP packets sent using PacketSender::send_recv now match ICMP 
+responses.
+
+- Added support for ICMP timestamp request/reply packets. 
+ICMP::matches_response now works with these types of packets as well.
+
+- Added support for reassembling of fragmented IP packets via the
+IPv4Reassembler class.
+
+- Fragmented IP packet's inner_pdu PDUs are not decoded now.
+
+- Added 1000ms as the default read timeout used when calling 
+pcap_open_live. Added BaseSniffer::set_timeout to modify this parameter.
+
+- Added the --disable-dot11 configure switch.
+
+- Added support for IPSec.
+
+- Fixed bug triggered when ifaddrs::ifa_addr was null in 
+NetworkInterface::addresses.
+
+- Added another overload of Utils::route_entries which returns the
+result either than storing it in a parameter.
+
+- Added ARP monitor, WPS detector, DNS queries sniffer and DNS spoofer 
+examples.
+
+- Added another Sniffer constructor which doesn't expect the maximum
+capture size.
+
+- Added tins_cast as a replacement for dynamic_cast on PDUs.
+
 v1.2 - Mon oct  7 23:33:49 ART 2013
 
 - Added BaseSniffer::begin and BaseSniffer::end.

CMakeLists.txt

@@ -0,0 +1,165 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8.1)
+PROJECT(libtins)
+
+# Compile in release mode by default
+IF(NOT CMAKE_BUILD_TYPE)
+    MESSAGE(STATUS "Setting build type to 'RelWithDebInfo' as none was specified.")
+    SET(CMAKE_BUILD_TYPE RelWithDebInfo) 
+ELSE(NOT CMAKE_BUILD_TYPE)
+    MESSAGE(STATUS "Using specified '${CMAKE_BUILD_TYPE}' build type.")
+ENDIF(NOT CMAKE_BUILD_TYPE)
+
+# Default compilation settings
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
+
+# Build output checks
+OPTION(LIBTINS_BUILD_SHARED "Build libtins as a shared library." ON)
+IF(LIBTINS_BUILD_SHARED)
+    MESSAGE(
+        STATUS 
+        "Build will generate a shared library. "
+        "Use LIBTINS_BUILD_SHARED=0 to perform a static build"
+    )
+    SET(LIBTINS_TYPE SHARED)
+ELSE(LIBTINS_BUILD_SHARED)
+    MESSAGE(STATUS "Build will generate a static library.")
+    SET(LIBTINS_TYPE STATIC)
+ENDIF(LIBTINS_BUILD_SHARED)
+
+# The version number.
+SET(LIBTINS_VERSION_MAJOR 3)
+SET(LIBTINS_VERSION_MINOR 2)
+SET(LIBTINS_VERSION "${LIBTINS_VERSION_MAJOR}.${LIBTINS_VERSION_MINOR}")
+
+# Required Packages
+SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/")
+
+# Look for libpcap
+FIND_PACKAGE(PCAP REQUIRED)
+
+# Set some Windows specific flags
+IF(WIN32)
+    # We need to link against these libs
+    SET(LIBTINS_OS_LIBS Ws2_32.lib Iphlpapi.lib)
+
+    # Add the NOMINMAX macro to avoid Windows' min and max macros.
+    # While compiling on windows, for some reason, WIN32 is not defined,
+    # maybe we could fix this later, but it's OK for now.
+    ADD_DEFINITIONS(-DNOMINMAX -DWIN32)
+ENDIF(WIN32)
+
+# Compilation options
+OPTION(LIBTINS_ENABLE_CXX11 "Compile libtins with c++11 features" OFF)
+IF(LIBTINS_ENABLE_CXX11)
+    SET(HAVE_CXX11 ON)
+    INCLUDE(CheckCXX11Features)
+    IF(HAS_CXX11_NULLPTR AND HAS_CXX11_RVALUE_REFERENCES)
+        MESSAGE(STATUS "Enabling C++11 features")
+        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX11_COMPILER_FLAGS}")
+    ELSE(HAS_CXX11_NULLPTR AND HAS_CXX11_RVALUE_REFERENCES)
+        MESSAGE(FATAL_ERROR "C++11 features requested but the compiler does not support them.")
+    ENDIF(HAS_CXX11_NULLPTR AND HAS_CXX11_RVALUE_REFERENCES)
+ELSE(LIBTINS_ENABLE_CXX11)
+    MESSAGE(
+        WARNING 
+        "Disabling C++11 features. Use LIBTINS_ENABLE_CXX11=1 to enable them. "
+        "Unless you are using an old compiler, you should enable this option, "
+        "as it increases the library's performance")
+ENDIF(LIBTINS_ENABLE_CXX11)
+
+OPTION(LIBTINS_ENABLE_DOT11 "Compile libtins with IEEE 802.11 support" ON)
+OPTION(LIBTINS_ENABLE_WPA2 "Compile libtins with WPA2 decryption features (requires OpenSSL)" ON)
+IF(LIBTINS_ENABLE_DOT11)
+    SET(HAVE_DOT11 ON)
+    MESSAGE(STATUS "Enabling IEEE 802.11 support.")
+    IF(LIBTINS_ENABLE_WPA2)
+        FIND_PACKAGE(OpenSSL REQUIRED)
+        SET(HAVE_WPA2_DECRYPTION ON)
+        MESSAGE(STATUS "Enabling WPA2 decryption support.")
+    ELSE(LIBTINS_ENABLE_WPA2)
+        MESSAGE(STATUS "Disabling WPA2 decryption support.")
+    ENDIF(LIBTINS_ENABLE_WPA2)
+ENDIF(LIBTINS_ENABLE_DOT11)
+
+# Add a target to generate API documentation using Doxygen
+FIND_PACKAGE(Doxygen QUIET)
+IF(DOXYGEN_FOUND)
+    CONFIGURE_FILE(
+        ${CMAKE_CURRENT_SOURCE_DIR}/docs/Doxyfile.in 
+        ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile 
+        @ONLY
+    )
+    ADD_CUSTOM_TARGET(
+        docs
+        ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+        COMMENT "Generating API documentation with Doxygen" VERBATIM
+    )
+ENDIF(DOXYGEN_FOUND)
+
+SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
+SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
+
+# Configuration file
+CONFIGURE_FILE(
+  "${PROJECT_SOURCE_DIR}/include/tins/config.h.in"
+  "${PROJECT_SOURCE_DIR}/include/tins/config.h"
+)
+
+# Support for pkg-config
+set(CMAKE_INSTALL_LIBDIR lib)
+set(pkgconfig_prefix      ${CMAKE_INSTALL_PREFIX})
+set(pkgconfig_exec_prefix ${CMAKE_INSTALL_PREFIX})
+set(pkgconfig_libdir      ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR})
+set(pkgconfig_version     ${LIBTINS_VERSION})
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libtins.pc.in
+               ${CMAKE_CURRENT_BINARY_DIR}/libtins.pc @ONLY)
+
+install(
+    FILES
+    ${CMAKE_CURRENT_BINARY_DIR}/libtins.pc
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig
+)
+
+ENABLE_TESTING()
+ADD_SUBDIRECTORY(include)
+ADD_SUBDIRECTORY(src)
+ADD_SUBDIRECTORY(tests)
+ADD_SUBDIRECTORY(examples)
+
+# Add all targets to the build-tree export set
+EXPORT(
+    TARGETS tins
+    FILE "${PROJECT_BINARY_DIR}/libtinsTargets.cmake"
+)
+
+# Export the package for use from the build-tree
+# (this registers the build-tree with a global CMake-registry)
+EXPORT(PACKAGE libtins)
+
+# Create the libtinsConfig.cmake and libtinsConfigVersion.cmake files
+# for the build tree
+SET(CONF_INCLUDE_DIRS "${PROJECT_SOURCE_DIR}/include")
+CONFIGURE_FILE(
+    cmake/libtinsConfig.cmake.in
+    "${PROJECT_BINARY_DIR}/libtinsConfig.cmake" @ONLY
+)
+CONFIGURE_FILE(
+    cmake/libtinsConfigVersion.cmake.in
+    "${PROJECT_BINARY_DIR}/libtinsConfigVersion.cmake" @ONLY
+)
+# Install the libtinsConfig.cmake and libtinsConfigVersion.cmake
+INSTALL(
+    FILES
+    "${PROJECT_BINARY_DIR}/libtinsConfig.cmake"
+    "${PROJECT_BINARY_DIR}/libtinsConfigVersion.cmake"
+    DESTINATION CMake
+    COMPONENT dev
+)
+
+# Install the export set for use with the install-tree
+INSTALL(
+    EXPORT libtinsTargets
+    DESTINATION CMake
+    COMPONENT dev
+)

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012, Nasel
+Copyright (c) 2012-2014, Matias Fontanini
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

Makefile.am

@@ -1,128 +0,0 @@
-AUTOMAKE_OPTIONS=subdir-objects
-ACLOCAL_AMFLAGS=${ACLOCAL_FLAGS} -I m4
-
-# pkg-config stuff
-pkgconfigdir = $(libdir)/pkgconfig
-pkgconfig_DATA = libtins.pc
-
-lib_LTLIBRARIES=libtins.la
-
-libtins_la_LDFLAGS = -version-info @LIBTINS_VERSION@
-
-AM_CXXFLAGS = -Wall -pedantic -I@LIBTINS_INCLUDE_DIR@
-
-libtins_la_SOURCES=src/arp.cpp \
-                    src/bootp.cpp \
-                    src/handshake_capturer.cpp \
-                    src/stp.cpp \
-                    src/pppoe.cpp \
-                    src/crypto.cpp \
-                    src/dhcp.cpp \
-                    src/dhcpv6.cpp \
-                    src/dns.cpp \
-                    src/dns_record.cpp \
-                    src/dot3.cpp \
-                    src/dot1q.cpp \
-                    src/eapol.cpp \
-                    src/ethernetII.cpp \
-                    src/icmp.cpp \
-                    src/icmpv6.cpp \
-                    src/internals.cpp \
-                    src/ip.cpp src/ip_address.cpp \
-                    src/ipv6.cpp \
-                    src/ipv6_address.cpp \
-                    src/llc.cpp \
-                    src/loopback.cpp \
-                    src/network_interface.cpp \
-                    src/packet_sender.cpp \
-                    src/packet_writer.cpp \
-                    src/ppi.cpp \
-                    src/pdu.cpp \
-                    src/radiotap.cpp \
-                    src/address_range.cpp \
-                    src/rawpdu.cpp \
-                    src/rsn_information.cpp \
-                    src/sll.cpp \
-                    src/snap.cpp \
-                    src/sniffer.cpp \
-                    src/tcp.cpp \
-                    src/tcp_stream.cpp \
-                    src/udp.cpp \
-                    src/utils.cpp \
-                    src/dot11/dot11_base.cpp \
-                    src/dot11/dot11_data.cpp \
-                    src/dot11/dot11_mgmt.cpp \
-                    src/dot11/dot11_beacon.cpp \
-                    src/dot11/dot11_assoc.cpp \
-                    src/dot11/dot11_auth.cpp \
-                    src/dot11/dot11_probe.cpp \
-                    src/dot11/dot11_control.cpp
-
-libtinsdir = $(includedir)/tins
-
-libtins_HEADERS = include/internals.h \
-							include/dhcpv6.h \
-							include/dot11.h \
-							include/dot1q.h \
-							include/dot3.h \
-							include/small_uint.h \
-							include/ip.h \
-							include/dns_record.h \
-							include/eapol.h \
-							include/tcp_stream.h \
-							include/pppoe.h \
-							include/handshake_capturer.h \
-							include/ipv6.h \
-							include/icmpv6.h \
-							include/ieee802_3.h \
-							include/endianness.h \
-							include/rsn_information.h \
-							include/loopback.h \
-							include/ethernetII.h \
-							include/crypto.h \
-							include/packet.h \
-							include/llc.h \
-							include/icmp.h \
-							include/hw_address.h \
-							include/packet_writer.h \
-							include/macros.h \
-							include/arp.h \
-							include/ip_address.h \
-							include/pdu.h \
-							include/packet_sender.h \
-							include/bootp.h \
-							include/network_interface.h \
-							include/sll.h \
-							include/ppi.h \
-							include/radiotap.h \
-							include/dns.h \
-							include/rawpdu.h \
-							include/sniffer.h \
-							include/snap.h \
-							include/pdu_cacher.h \
-							include/dhcp.h \
-							include/timestamp.h \
-							include/tcp.h \
-							include/pdu_option.h \
-							include/tins.h \
-							include/udp.h \
-							include/ipv6_address.h  \
-							include/constants.h \
-							include/utils.h \
-							include/cxxstd.h \
-							include/stp.h \
-							include/exceptions.h \
-							include/config.h \
-							include/address_range.h \
-							include/pdu_allocator.h
-
-libtins_dot11_HEADERS =  include/dot11/dot11_base.h \
-						include/dot11/dot11_beacon.h \
-						include/dot11/dot11_data.h \
-						include/dot11/dot11_mgmt.h \
-						include/dot11/dot11_assoc.h \
-						include/dot11/dot11_auth.h \
-						include/dot11/dot11_probe.h \
-						include/dot11/dot11_control.h
-
-libtins_dot11dir  	  =     $(includedir)/tins/dot11/

README

@@ -1,58 +0,0 @@
-------------------------------------------------------------------------
-       libtins v1.1
-------------------------------------------------------------------------
-
-
--------------------------------- About ---------------------------------
-
-libtins is a C++ library for crafting, sending, sniffing and 
-interpreting raw network packets.
-
-Its main purpose is to provide the C++ developer an easy, efficient, 
-platform and endianess-independent way to create tools which need to 
-send, receive and manipulate specially crafted packets. 
-
-In order to read tutorials, examples and checkout some benchmarks which 
-show libtins' actual performance, please visit:
-
-http://libtins.sourceforge.net 
-
-------------------------------- Compiling ------------------------------
-
-In order to compile, execute:
-
-./configure
-make
-
-Note that by default, only the shared object is compiled. If you would
-like to generate a static library file as well, run:
-
-./configure --enable-static
-
-The generated static/shared library files will be located in the .libs
-directory.
-
-If you want to enable C++11 features, such as move semantics, use the
---enable-c++11 switch:
-
-./configure --enable-c++11
-
------------------------------- Installing-------------------------------
-
-Once you're done, if you want to install the header files and the 
-shared object, execute as root:
-
-make install
-
-This will install the shared object typically in /usr/local/lib. Note
-that you might have to update ldconfig's cache before using it, so 
-in order to invalidate it, you should run(as root):
-
-ldconfig
-
------------------------------- Examples --------------------------------
-
-You might want to have a look at the examples located  in the "examples"
-directory. The same samples can be found online at:
-
-http://libtins.sourceforge.net/index.php?page=examples

README.md

@@ -0,0 +1,93 @@
+libtins
+=======
+
+libtins is a high-level, multiplatform C++ network packet sniffing and 
+crafting library. 
+
+Its main purpose is to provide the C++ developer an easy, efficient, 
+platform and endianess-independent way to create tools which need to 
+send, receive and manipulate specially crafted packets. 
+
+In order to read tutorials, examples and checkout some benchmarks of the
+library, please visit:
+
+http://libtins.github.io/
+
+## Compiling ##
+
+[libtins](http://libtins.github.io/) depends on 
+[libpcap](http://www.tcpdump.org/) and 
+[openssl](http://www.openssl.org/), although the latter is not necessary 
+if some features of the library are disabled.
+
+In order to compile, execute:
+
+```Shell
+# Create the build directory
+mkdir build
+cd build
+
+# Configure the project. Add any relevant configuration flags
+cmake ../
+
+# Compile!
+make
+```
+
+Note that by default, only the shared object is compiled. If you would
+like to generate a static library file, run:
+
+```Shell
+cmake ../ -DLIBTINS_BUILD_SHARED=0
+```
+
+The generated static/shared library files will be located in the 
+_build/lib_ directory.
+
+libtins is noticeable faster if you enable _C++11_ support. Therefore, 
+if your compiler supports this standard, then you should enable it. 
+In order to do so, use the _LIBTINS_ENABLE_CXX11_ switch:
+
+```Shell
+cmake ../ -DLIBTINS_ENABLE_CXX11=1
+```
+
+If you want to disable _WPA2_ decryption support, which will remove 
+openssl as a dependency for compilation, use the 
+_LIBTINS_ENABLE_WPA2_ switch:
+
+```Shell
+cmake ../ -DLIBTINS_ENABLE_WPA2=0
+```
+
+If you want to disable IEEE 802.11 support(this will also disable 
+RadioTap and WPA2 decryption), which will reduce the size of the 
+resulting library in around 20%, use the _LIBTINS_ENABLE_DOT11_ switch:
+
+```Shell
+cmake ../ -DLIBTINS_ENABLE_DOT11=0
+```
+
+## Installing ##
+
+Once you're done, if you want to install the header files and the 
+shared object, execute as root:
+
+```Shell
+make install
+```
+
+This will install the shared object typically in _/usr/local/lib_. Note
+that you might have to update ldconfig's cache before using it, so 
+in order to invalidate it, you should run(as root):
+
+```Shell
+ldconfig
+```
+
+## Examples ##
+
+You might want to have a look at the examples located  in the "examples"
+directory. The same samples can be found online at:
+
+http://libtins.github.io/examples/

cmake/Modules/CheckCXX11Features.cmake

@@ -0,0 +1,142 @@
+# - Check which parts of the C++11 standard the compiler supports
+#
+# When found it will set the following variables
+#
+#  CXX11_COMPILER_FLAGS         - the compiler flags needed to get C++11 features
+#
+#  HAS_CXX11_AUTO               - auto keyword
+#  HAS_CXX11_AUTO_RET_TYPE      - function declaration with deduced return types
+#  HAS_CXX11_CLASS_OVERRIDE     - override and final keywords for classes and methods
+#  HAS_CXX11_CONSTEXPR          - constexpr keyword
+#  HAS_CXX11_CSTDINT_H          - cstdint header
+#  HAS_CXX11_DECLTYPE           - decltype keyword
+#  HAS_CXX11_FUNC               - __func__ preprocessor constant
+#  HAS_CXX11_INITIALIZER_LIST   - initializer list
+#  HAS_CXX11_LAMBDA             - lambdas
+#  HAS_CXX11_LIB_REGEX          - regex library
+#  HAS_CXX11_LONG_LONG          - long long signed & unsigned types
+#  HAS_CXX11_NULLPTR            - nullptr
+#  HAS_CXX11_RVALUE_REFERENCES  - rvalue references
+#  HAS_CXX11_SIZEOF_MEMBER      - sizeof() non-static members
+#  HAS_CXX11_STATIC_ASSERT      - static_assert()
+#  HAS_CXX11_VARIADIC_TEMPLATES - variadic templates
+
+#=============================================================================
+# Copyright 2011,2012 Rolf Eike Beer <eike@sf-mail.de>
+# Copyright 2012 Andreas Weis
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+#
+# Each feature may have up to 3 checks, every one of them in it's own file
+# FEATURE.cpp              - example that must build and return 0 when run
+# FEATURE_fail.cpp         - example that must build, but may not return 0 when run
+# FEATURE_fail_compile.cpp - example that must fail compilation
+#
+# The first one is mandatory, the latter 2 are optional and do not depend on
+# each other (i.e. only one may be present).
+#
+
+if (NOT CMAKE_CXX_COMPILER_LOADED)
+    message(FATAL_ERROR "CheckCXX11Features modules only works if language CXX is enabled")
+endif ()
+
+cmake_minimum_required(VERSION 2.8.3)
+
+#
+### Check for needed compiler flags
+#
+include(CheckCXXCompilerFlag)
+check_cxx_compiler_flag("-std=c++11" _HAS_CXX11_FLAG)
+if (NOT _HAS_CXX11_FLAG)
+    check_cxx_compiler_flag("-std=c++0x" _HAS_CXX0X_FLAG)
+endif ()
+
+if (_HAS_CXX11_FLAG)
+    set(CXX11_COMPILER_FLAGS "-std=c++11")
+elseif (_HAS_CXX0X_FLAG)
+    set(CXX11_COMPILER_FLAGS "-std=c++0x")
+endif ()
+
+function(cxx11_check_feature FEATURE_NAME RESULT_VAR)
+    if (NOT DEFINED ${RESULT_VAR})
+        set(_bindir "${CMAKE_CURRENT_BINARY_DIR}/cxx11_${FEATURE_NAME}")
+
+        set(_SRCFILE_BASE ${CMAKE_CURRENT_LIST_DIR}/CheckCXX11Features/cxx11-test-${FEATURE_NAME})
+        set(_LOG_NAME "\"${FEATURE_NAME}\"")
+        message(STATUS "Checking C++11 support for ${_LOG_NAME}")
+
+        set(_SRCFILE "${_SRCFILE_BASE}.cpp")
+        set(_SRCFILE_FAIL "${_SRCFILE_BASE}_fail.cpp")
+        set(_SRCFILE_FAIL_COMPILE "${_SRCFILE_BASE}_fail_compile.cpp")
+
+        if (CROSS_COMPILING)
+            try_compile(${RESULT_VAR} "${_bindir}" "${_SRCFILE}"
+                        COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}")
+            if (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
+                try_compile(${RESULT_VAR} "${_bindir}_fail" "${_SRCFILE_FAIL}"
+                            COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}")
+            endif (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
+        else (CROSS_COMPILING)
+            try_run(_RUN_RESULT_VAR _COMPILE_RESULT_VAR
+                    "${_bindir}" "${_SRCFILE}"
+                    COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}")
+            if (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR)
+                set(${RESULT_VAR} TRUE)
+            else (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR)
+                set(${RESULT_VAR} FALSE)
+            endif (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR)
+            if (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
+                try_run(_RUN_RESULT_VAR _COMPILE_RESULT_VAR
+                        "${_bindir}_fail" "${_SRCFILE_FAIL}"
+                         COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}")
+                if (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR)
+                    set(${RESULT_VAR} TRUE)
+                else (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR)
+                    set(${RESULT_VAR} FALSE)
+                endif (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR)
+            endif (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
+        endif (CROSS_COMPILING)
+        if (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL_COMPILE})
+            try_compile(_TMP_RESULT "${_bindir}_fail_compile" "${_SRCFILE_FAIL_COMPILE}"
+                        COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}")
+            if (_TMP_RESULT)
+                set(${RESULT_VAR} FALSE)
+            else (_TMP_RESULT)
+                set(${RESULT_VAR} TRUE)
+            endif (_TMP_RESULT)
+        endif (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL_COMPILE})
+
+        if (${RESULT_VAR})
+            message(STATUS "Checking C++11 support for ${_LOG_NAME}: works")
+        else (${RESULT_VAR})
+            message(STATUS "Checking C++11 support for ${_LOG_NAME}: not supported")
+        endif (${RESULT_VAR})
+        set(${RESULT_VAR} ${${RESULT_VAR}} CACHE INTERNAL "C++11 support for ${_LOG_NAME}")
+    endif (NOT DEFINED ${RESULT_VAR})
+endfunction(cxx11_check_feature)
+
+cxx11_check_feature("__func__" HAS_CXX11_FUNC)
+cxx11_check_feature("auto" HAS_CXX11_AUTO)
+cxx11_check_feature("auto_ret_type" HAS_CXX11_AUTO_RET_TYPE)
+cxx11_check_feature("class_override_final" HAS_CXX11_CLASS_OVERRIDE)
+cxx11_check_feature("constexpr" HAS_CXX11_CONSTEXPR)
+cxx11_check_feature("cstdint" HAS_CXX11_CSTDINT_H)
+cxx11_check_feature("decltype" HAS_CXX11_DECLTYPE)
+cxx11_check_feature("initializer_list" HAS_CXX11_INITIALIZER_LIST)
+cxx11_check_feature("lambda" HAS_CXX11_LAMBDA)
+cxx11_check_feature("long_long" HAS_CXX11_LONG_LONG)
+cxx11_check_feature("nullptr" HAS_CXX11_NULLPTR)
+cxx11_check_feature("regex" HAS_CXX11_LIB_REGEX)
+cxx11_check_feature("rvalue-references" HAS_CXX11_RVALUE_REFERENCES)
+cxx11_check_feature("sizeof_member" HAS_CXX11_SIZEOF_MEMBER)
+cxx11_check_feature("static_assert" HAS_CXX11_STATIC_ASSERT)
+cxx11_check_feature("variadic_templates" HAS_CXX11_VARIADIC_TEMPLATES)

cmake/Modules/CheckCXX11Features/cxx11-test-__func__.cpp

@@ -0,0 +1,8 @@
+int main(void)
+{
+	if (!__func__)
+		return 1;
+	if (!(*__func__))
+		return 1;
+	return 0;
+}

cmake/Modules/CheckCXX11Features/cxx11-test-auto.cpp

@@ -0,0 +1,12 @@
+
+int main()
+{
+	auto i = 5;
+	auto f = 3.14159f;
+	auto d = 3.14159;
+	bool ret = (
+		(sizeof(f) < sizeof(d)) &&
+		(sizeof(i) == sizeof(int))
+	);
+	return ret ? 0 : 1;
+}

cmake/Modules/CheckCXX11Features/cxx11-test-auto_fail_compile.cpp

@@ -0,0 +1,7 @@
+int main(void)
+{
+	// must fail because there is no initializer
+	auto i;
+
+	return 0;
+}

cmake/Modules/CheckCXX11Features/cxx11-test-auto_ret_type.cpp

@@ -0,0 +1,8 @@
+auto foo(int i) -> int {
+	return i - 1;
+}
+
+int main()
+{
+	return foo(1);
+}

cmake/Modules/CheckCXX11Features/cxx11-test-class_override_final.cpp

@@ -0,0 +1,21 @@
+class base {
+public:
+    virtual int foo(int a)
+     { return 4 + a; }
+    int bar(int a) final
+     { return a - 2; }
+};
+
+class sub final : public base {
+public:
+    virtual int foo(int a) override
+     { return 8 + 2 * a; };
+};
+
+int main(void)
+{
+    base b;
+    sub s;
+
+    return (b.foo(2) * 2 == s.foo(2)) ? 0 : 1;
+}

cmake/Modules/CheckCXX11Features/cxx11-test-class_override_final_fail_compile.cpp

@@ -0,0 +1,25 @@
+class base {
+public:
+    virtual int foo(int a)
+     { return 4 + a; }
+    virtual int bar(int a) final
+     { return a - 2; }
+};
+
+class sub final : public base {
+public:
+    virtual int foo(int a) override
+     { return 8 + 2 * a; };
+    virtual int bar(int a)
+     { return a; }
+};
+
+class impossible : public sub { };
+
+int main(void)
+{
+    base b;
+    sub s;
+
+    return 1;
+}

cmake/Modules/CheckCXX11Features/cxx11-test-constexpr.cpp

@@ -0,0 +1,19 @@
+constexpr int square(int x)
+{
+	return x*x;
+}
+
+constexpr int the_answer()
+{
+	return 42;
+}
+
+int main()
+{
+	int test_arr[square(3)];
+	bool ret = (
+		(square(the_answer()) == 1764) &&
+		(sizeof(test_arr)/sizeof(test_arr[0]) == 9)
+	);
+	return ret ? 0 : 1;
+}

cmake/Modules/CheckCXX11Features/cxx11-test-cstdint.cpp

@@ -0,0 +1,11 @@
+#include <cstdint>
+
+int main()
+{
+	bool test =
+		(sizeof(int8_t) == 1) &&
+		(sizeof(int16_t) == 2) &&
+		(sizeof(int32_t) == 4) &&
+		(sizeof(int64_t) == 8);
+	return test ? 0 : 1;
+}

cmake/Modules/CheckCXX11Features/cxx11-test-decltype.cpp

@@ -0,0 +1,10 @@
+bool check_size(int i)
+{
+	return sizeof(int) == sizeof(decltype(i));
+}
+
+int main()
+{
+	bool ret = check_size(42);
+	return ret ? 0 : 1;
+}

cmake/Modules/CheckCXX11Features/cxx11-test-initializer_list.cpp

@@ -0,0 +1,27 @@
+#include <vector>
+
+class seq {
+public:
+    seq(std::initializer_list<int> list);
+
+    int length() const;
+private:
+    std::vector<int> m_v;
+};
+
+seq::seq(std::initializer_list<int> list)
+    : m_v(list)
+{
+}
+
+int seq::length() const
+{
+    return m_v.size();
+}
+
+int main(void)
+{
+    seq a = {18, 20, 2, 0, 4, 7};
+
+    return (a.length() == 6) ? 0 : 1;
+}

cmake/Modules/CheckCXX11Features/cxx11-test-lambda.cpp

@@ -0,0 +1,5 @@
+int main()
+{
+	int ret = 0;
+	return ([&ret]() -> int { return ret; })();
+}

cmake/Modules/CheckCXX11Features/cxx11-test-long_long.cpp

@@ -0,0 +1,7 @@
+int main(void)
+{
+	long long l;
+	unsigned long long ul;
+
+	return ((sizeof(l) >= 8) && (sizeof(ul) >= 8)) ? 0 : 1;
+}

cmake/Modules/CheckCXX11Features/cxx11-test-nullptr.cpp

@@ -0,0 +1,6 @@
+int main(void)
+{
+	void *v = nullptr;
+
+	return v ? 1 : 0;
+}

cmake/Modules/CheckCXX11Features/cxx11-test-nullptr_fail_compile.cpp

@@ -0,0 +1,6 @@
+int main(void)
+{
+	int i = nullptr;
+
+	return 1;
+}

cmake/Modules/CheckCXX11Features/cxx11-test-regex.cpp

@@ -0,0 +1,26 @@
+#include <algorithm>
+#include <regex>
+
+int parse_line(std::string const& line)
+{
+	std::string tmp;
+	if(std::regex_search(line, std::regex("(\\s)+(-)?(\\d)+//(-)?(\\d)+(\\s)+"))) {
+		tmp = std::regex_replace(line, std::regex("(-)?(\\d)+//(-)?(\\d)+"), std::string("V"));
+	} else if(std::regex_search(line, std::regex("(\\s)+(-)?(\\d)+/(-)?(\\d)+(\\s)+"))) {
+		tmp = std::regex_replace(line, std::regex("(-)?(\\d)+/(-)?(\\d)+"), std::string("V"));
+	} else if(std::regex_search(line, std::regex("(\\s)+(-)?(\\d)+/(-)?(\\d)+/(-)?(\\d)+(\\s)+"))) {
+		tmp = std::regex_replace(line, std::regex("(-)?(\\d)+/(-)?(\\d)+/(-)?(\\d)+"), std::string("V"));
+	} else {
+		tmp = std::regex_replace(line, std::regex("(-)?(\\d)+"), std::string("V"));
+	}
+	return static_cast<int>(std::count(tmp.begin(), tmp.end(), 'V'));
+}
+
+int main()
+{
+	bool test = (parse_line("f 7/7/7 -3/3/-3 2/-2/2") == 3) &&
+				(parse_line("f 7//7 3//-3 -2//2") == 3) &&
+				(parse_line("f 7/7 3/-3 -2/2") == 3) &&
+				(parse_line("f 7 3 -2") == 3);
+	return test ? 0 : 1;
+}

cmake/Modules/CheckCXX11Features/cxx11-test-rvalue-references.cpp

@@ -0,0 +1,57 @@
+#include <cassert>
+
+class rvmove {
+public:
+   void *ptr;
+   char *array;
+
+   rvmove()
+    : ptr(0),
+    array(new char[10])
+   {
+     ptr = this;
+   }
+
+   rvmove(rvmove &&other)
+    : ptr(other.ptr),
+    array(other.array)
+   {
+    other.array = 0;
+    other.ptr = 0;
+   }
+
+   ~rvmove()
+   {
+    assert(((ptr != 0) && (array != 0)) || ((ptr == 0) && (array == 0)));
+    delete[] array;
+   }
+
+   rvmove &operator=(rvmove &&other)
+   {
+     delete[] array;
+     ptr = other.ptr;
+     array = other.array;
+     other.array = 0;
+     other.ptr = 0;
+     return *this;
+   }
+
+   static rvmove create()
+   {
+     return rvmove();
+   }
+private:
+  rvmove(const rvmove &);
+  rvmove &operator=(const rvmove &);
+};
+
+int main()
+{
+  rvmove mine;
+  if (mine.ptr != &mine)
+    return 1;
+  mine = rvmove::create();
+  if (mine.ptr == &mine)
+    return 1;
+  return 0;
+}

cmake/Modules/CheckCXX11Features/cxx11-test-sizeof_member.cpp

@@ -0,0 +1,14 @@
+struct foo {
+	char bar;
+	int baz;
+};
+
+int main(void)
+{
+	bool ret = (
+		(sizeof(foo::bar) == 1) &&
+		(sizeof(foo::baz) >= sizeof(foo::bar)) &&
+		(sizeof(foo) >= sizeof(foo::bar) + sizeof(foo::baz))
+	);
+	return ret ? 0 : 1;
+}

cmake/Modules/CheckCXX11Features/cxx11-test-sizeof_member_fail.cpp

@@ -0,0 +1,9 @@
+struct foo {
+	int baz;
+	double bar;
+};
+
+int main(void)
+{
+	return (sizeof(foo::bar) == 4) ? 0 : 1;
+}

cmake/Modules/CheckCXX11Features/cxx11-test-static_assert.cpp

@@ -0,0 +1,5 @@
+int main(void)
+{
+	static_assert(0 < 1, "your ordering of integers is screwed");
+	return 0;
+}

cmake/Modules/CheckCXX11Features/cxx11-test-static_assert_fail_compile.cpp

@@ -0,0 +1,5 @@
+int main(void)
+{
+	static_assert(1 < 0, "your ordering of integers is screwed");
+	return 0;
+}

cmake/Modules/CheckCXX11Features/cxx11-test-variadic_templates.cpp

@@ -0,0 +1,23 @@
+int Accumulate()
+{
+	return 0;
+}
+
+template<typename T, typename... Ts>
+int Accumulate(T v, Ts... vs)
+{
+	return v + Accumulate(vs...);
+}
+
+template<int... Is>
+int CountElements()
+{
+	return sizeof...(Is);
+}
+
+int main()
+{
+	int acc = Accumulate(1, 2, 3, 4, -5);
+	int count = CountElements<1,2,3,4,5>();
+	return ((acc == 5) && (count == 5)) ? 0 : 1;
+}

cmake/Modules/FindPCAP.cmake

@@ -0,0 +1,74 @@
+# - Try to find libpcap include dirs and libraries
+#
+# Usage of this module as follows:
+#
+#     find_package(PCAP)
+#
+# Variables used by this module, they can change the default behaviour and need
+# to be set before calling find_package:
+#
+#  PCAP_ROOT_DIR             Set this variable to the root installation of
+#                            libpcap if the module has problems finding the
+#                            proper installation path.
+#
+# Variables defined by this module:
+#
+#  PCAP_FOUND                System has libpcap, include and library dirs found
+#  PCAP_INCLUDE_DIR          The libpcap include directories.
+#  PCAP_LIBRARY              The libpcap library (possibly includes a thread
+#                            library e.g. required by pf_ring's libpcap)
+#  HAVE_PF_RING              If a found version of libpcap supports PF_RING
+
+find_path(PCAP_ROOT_DIR
+    NAMES include/pcap.h
+)
+
+find_path(PCAP_INCLUDE_DIR
+    NAMES pcap.h
+    HINTS ${PCAP_ROOT_DIR}/include
+)
+
+find_library(PCAP_LIBRARY
+    NAMES pcap wpcap
+    HINTS ${PCAP_ROOT_DIR}/lib
+)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(PCAP DEFAULT_MSG
+    PCAP_LIBRARY
+    PCAP_INCLUDE_DIR
+)
+
+include(CheckCXXSourceCompiles)
+set(CMAKE_REQUIRED_LIBRARIES ${PCAP_LIBRARY})
+check_cxx_source_compiles("int main() { return 0; }" PCAP_LINKS_SOLO)
+set(CMAKE_REQUIRED_LIBRARIES)
+
+# check if linking against libpcap also needs to link against a thread library
+if (NOT PCAP_LINKS_SOLO)
+    find_package(Threads)
+    if (THREADS_FOUND)
+        set(CMAKE_REQUIRED_LIBRARIES ${PCAP_LIBRARY} ${CMAKE_THREAD_LIBS_INIT})
+        check_cxx_source_compiles("int main() { return 0; }" PCAP_NEEDS_THREADS)
+        set(CMAKE_REQUIRED_LIBRARIES)
+    endif (THREADS_FOUND)
+    if (THREADS_FOUND AND PCAP_NEEDS_THREADS)
+        set(_tmp ${PCAP_LIBRARY} ${CMAKE_THREAD_LIBS_INIT})
+        list(REMOVE_DUPLICATES _tmp)
+        set(PCAP_LIBRARY ${_tmp}
+            CACHE STRING "Libraries needed to link against libpcap" FORCE)
+    else (THREADS_FOUND AND PCAP_NEEDS_THREADS)
+        message(FATAL_ERROR "Couldn't determine how to link against libpcap")
+    endif (THREADS_FOUND AND PCAP_NEEDS_THREADS)
+endif (NOT PCAP_LINKS_SOLO)
+
+include(CheckFunctionExists)
+set(CMAKE_REQUIRED_LIBRARIES ${PCAP_LIBRARY})
+check_function_exists(pcap_get_pfring_id HAVE_PF_RING)
+set(CMAKE_REQUIRED_LIBRARIES)
+
+mark_as_advanced(
+    PCAP_ROOT_DIR
+    PCAP_INCLUDE_DIR
+    PCAP_LIBRARY
+)

cmake/libtinsConfig.cmake.in

@@ -0,0 +1,16 @@
+# - Config file for the libtins package
+# It defines the following variables
+#  LIBTINS_INCLUDE_DIRS - include directories for libtins
+#  LIBTINS_LIBRARIES    - libraries to link against
+
+# Compute paths
+get_filename_component(LIBTINS_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
+set(LIBTINS_INCLUDE_DIRS "@CONF_INCLUDE_DIRS@")
+
+# Our library dependencies (contains definitions for IMPORTED targets)
+if(NOT TARGET libtins AND NOT LIBTINS_BINARY_DIR)
+    include("${LIBTINS_CMAKE_DIR}/libtinsTargets.cmake")
+endif()
+
+# These are IMPORTED targets created by libtinsTargets.cmake
+set(LIBTINS_LIBRARIES tins)

cmake/libtinsConfigVersion.cmake.in

@@ -0,0 +1,11 @@
+set(PACKAGE_VERSION "@LIBTINS_VERSION@")
+
+# Check whether the requested PACKAGE_FIND_VERSION is compatible
+if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}")
+    set(PACKAGE_VERSION_COMPATIBLE FALSE)
+else()
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+    if ("${PACKAGE_VERSION}" VERSION_EQUAL "${PACKAGE_FIND_VERSION}")
+        set(PACKAGE_VERSION_EXACT TRUE)
+    endif()
+endif()

configure.ac

@@ -1,75 +0,0 @@
-AC_INIT([libtins], [1.2], [matias.fontanini@gmail.com], [libtins], [http://libtins.sourceforge.net])
-AC_CANONICAL_SYSTEM
-AC_CONFIG_HEADER(include/config.h)
-AM_INIT_AUTOMAKE([-Wall -Werror -Wno-extra-portability foreign])
-LT_INIT([disable-static])
-AC_CONFIG_MACRO_DIR([m4])
-AM_MAINTAINER_MODE([enable])
-
-AC_PROG_CXX
-AC_LANG(C++)
-
-AC_PROG_LIBTOOL
-
-# Check that libpcap exists
-
-AC_ARG_WITH([pcap-include-path],
-  [AS_HELP_STRING([--with-pcap-include-path],
-    [location of the libpcap headers, defaults to /usr/include/pcap])],
-  [CXXFLAGS="$CXXFLAGS -I$withval"; CPPFLAGS="-I$withval"])
-
-AC_ARG_WITH([pcap-lib-path],
-  [AS_HELP_STRING([--with-pcap-lib-path], [location of the libpcap libraries])],
-  [LIBS="$LIBS -L$withval"])
-
-AC_CHECK_LIB(pcap, pcap_loop, [], [AC_MSG_ERROR([pcap library is missing!])])
-
-old_cppflags=$CPPFLAGS
-CPPFLAGS=""
-
-# Headers
-
-LIBTINS_INCLUDE_DIR="include"
-AC_CHECK_HEADERS([pcap.h], [], [AC_MSG_ERROR([libpcap headers are missing!])])
-
-CPPFLAGS=$old_cppflags
-
-# Options
-
-wpa2_msg="WPA2 decryption(which requires openssl) can be disabled using the --disable-wpa2 flag."
-
-AC_ARG_ENABLE(
-    c++11, 
-    [  --enable-c++11          enable C++11 features], 
-    [AX_CXX_COMPILE_STDCXX_11(noext)]
-)
-
-AC_ARG_ENABLE(
-    wpa2, 
-    [  --disable-wpa2          disable WPA2 decryption features], 
-    [],
-    [
-        AC_CHECK_HEADERS(
-            [openssl/evp.h openssl/hmac.h openssl/aes.h], 
-            [], 
-            [AC_MSG_ERROR([openssl headers are missing! $wpa2_msg ])]
-            AC_DEFINE([HAVE_WPA2_DECRYPTION], 0, Have WPA2 decryption library)
-        )
-        AC_CHECK_LIB(
-            crypto, 
-            PKCS5_PBKDF2_HMAC_SHA1, 
-            [], 
-            [AC_MSG_ERROR([openssl library is missing! $wpa2_msg ])]
-        )
-        AC_DEFINE([HAVE_WPA2_DECRYPTION], 1, Have WPA2 decryption library)
-    ]
-)
-
-# Substitute options
-
-AC_SUBST(CXXFLAGS)
-AC_SUBST(LIBS)
-AC_SUBST(LIBTINS_INCLUDE_DIR)
-AC_SUBST([LIBTINS_VERSION], [1:1:0])
-AC_CONFIG_FILES([Makefile libtins.pc])
-AC_OUTPUT

depcomp

@@ -1,708 +0,0 @@
-#! /bin/sh
-# depcomp - compile a program generating dependencies as side-effects
-
-scriptversion=2012-03-27.16; # UTC
-
-# Copyright (C) 1999, 2000, 2003, 2004, 2005, 2006, 2007, 2009, 2010,
-# 2011, 2012 Free Software Foundation, Inc.
-
-# 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, 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, see <http://www.gnu.org/licenses/>.
-
-# As a special exception to the GNU General Public License, if you
-# distribute this file as part of a program that contains a
-# configuration script generated by Autoconf, you may include it under
-# the same distribution terms that you use for the rest of that program.
-
-# Originally written by Alexandre Oliva <oliva@dcc.unicamp.br>.
-
-case $1 in
-  '')
-     echo "$0: No command.  Try '$0 --help' for more information." 1>&2
-     exit 1;
-     ;;
-  -h | --h*)
-    cat <<\EOF
-Usage: depcomp [--help] [--version] PROGRAM [ARGS]
-
-Run PROGRAMS ARGS to compile a file, generating dependencies
-as side-effects.
-
-Environment variables:
-  depmode     Dependency tracking mode.
-  source      Source file read by 'PROGRAMS ARGS'.
-  object      Object file output by 'PROGRAMS ARGS'.
-  DEPDIR      directory where to store dependencies.
-  depfile     Dependency file to output.
-  tmpdepfile  Temporary file to use when outputting dependencies.
-  libtool     Whether libtool is used (yes/no).
-
-Report bugs to <bug-automake@gnu.org>.
-EOF
-    exit $?
-    ;;
-  -v | --v*)
-    echo "depcomp $scriptversion"
-    exit $?
-    ;;
-esac
-
-# A tabulation character.
-tab='	'
-# A newline character.
-nl='
-'
-
-if test -z "$depmode" || test -z "$source" || test -z "$object"; then
-  echo "depcomp: Variables source, object and depmode must be set" 1>&2
-  exit 1
-fi
-
-# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po.
-depfile=${depfile-`echo "$object" |
-  sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`}
-tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`}
-
-rm -f "$tmpdepfile"
-
-# Some modes work just like other modes, but use different flags.  We
-# parameterize here, but still list the modes in the big case below,
-# to make depend.m4 easier to write.  Note that we *cannot* use a case
-# here, because this file can only contain one case statement.
-if test "$depmode" = hp; then
-  # HP compiler uses -M and no extra arg.
-  gccflag=-M
-  depmode=gcc
-fi
-
-if test "$depmode" = dashXmstdout; then
-   # This is just like dashmstdout with a different argument.
-   dashmflag=-xM
-   depmode=dashmstdout
-fi
-
-cygpath_u="cygpath -u -f -"
-if test "$depmode" = msvcmsys; then
-   # This is just like msvisualcpp but w/o cygpath translation.
-   # Just convert the backslash-escaped backslashes to single forward
-   # slashes to satisfy depend.m4
-   cygpath_u='sed s,\\\\,/,g'
-   depmode=msvisualcpp
-fi
-
-if test "$depmode" = msvc7msys; then
-   # This is just like msvc7 but w/o cygpath translation.
-   # Just convert the backslash-escaped backslashes to single forward
-   # slashes to satisfy depend.m4
-   cygpath_u='sed s,\\\\,/,g'
-   depmode=msvc7
-fi
-
-if test "$depmode" = xlc; then
-   # IBM C/C++ Compilers xlc/xlC can output gcc-like dependency informations.
-   gccflag=-qmakedep=gcc,-MF
-   depmode=gcc
-fi
-
-case "$depmode" in
-gcc3)
-## gcc 3 implements dependency tracking that does exactly what
-## we want.  Yay!  Note: for some reason libtool 1.4 doesn't like
-## it if -MD -MP comes after the -MF stuff.  Hmm.
-## Unfortunately, FreeBSD c89 acceptance of flags depends upon
-## the command line argument order; so add the flags where they
-## appear in depend2.am.  Note that the slowdown incurred here
-## affects only configure: in makefiles, %FASTDEP% shortcuts this.
-  for arg
-  do
-    case $arg in
-    -c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;;
-    *)  set fnord "$@" "$arg" ;;
-    esac
-    shift # fnord
-    shift # $arg
-  done
-  "$@"
-  stat=$?
-  if test $stat -eq 0; then :
-  else
-    rm -f "$tmpdepfile"
-    exit $stat
-  fi
-  mv "$tmpdepfile" "$depfile"
-  ;;
-
-gcc)
-## There are various ways to get dependency output from gcc.  Here's
-## why we pick this rather obscure method:
-## - Don't want to use -MD because we'd like the dependencies to end
-##   up in a subdir.  Having to rename by hand is ugly.
-##   (We might end up doing this anyway to support other compilers.)
-## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like
-##   -MM, not -M (despite what the docs say).
-## - Using -M directly means running the compiler twice (even worse
-##   than renaming).
-  if test -z "$gccflag"; then
-    gccflag=-MD,
-  fi
-  "$@" -Wp,"$gccflag$tmpdepfile"
-  stat=$?
-  if test $stat -eq 0; then :
-  else
-    rm -f "$tmpdepfile"
-    exit $stat
-  fi
-  rm -f "$depfile"
-  echo "$object : \\" > "$depfile"
-  alpha=ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
-## The second -e expression handles DOS-style file names with drive letters.
-  sed -e 's/^[^:]*: / /' \
-      -e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile"
-## This next piece of magic avoids the "deleted header file" problem.
-## The problem is that when a header file which appears in a .P file
-## is deleted, the dependency causes make to die (because there is
-## typically no way to rebuild the header).  We avoid this by adding
-## dummy dependencies for each header file.  Too bad gcc doesn't do
-## this for us directly.
-  tr ' ' "$nl" < "$tmpdepfile" |
-## Some versions of gcc put a space before the ':'.  On the theory
-## that the space means something, we add a space to the output as
-## well.  hp depmode also adds that space, but also prefixes the VPATH
-## to the object.  Take care to not repeat it in the output.
-## Some versions of the HPUX 10.20 sed can't process this invocation
-## correctly.  Breaking it into two sed invocations is a workaround.
-    sed -e 's/^\\$//' -e '/^$/d' -e "s|.*$object$||" -e '/:$/d' \
-      | sed -e 's/$/ :/' >> "$depfile"
-  rm -f "$tmpdepfile"
-  ;;
-
-hp)
-  # This case exists only to let depend.m4 do its work.  It works by
-  # looking at the text of this script.  This case will never be run,
-  # since it is checked for above.
-  exit 1
-  ;;
-
-sgi)
-  if test "$libtool" = yes; then
-    "$@" "-Wp,-MDupdate,$tmpdepfile"
-  else
-    "$@" -MDupdate "$tmpdepfile"
-  fi
-  stat=$?
-  if test $stat -eq 0; then :
-  else
-    rm -f "$tmpdepfile"
-    exit $stat
-  fi
-  rm -f "$depfile"
-
-  if test -f "$tmpdepfile"; then  # yes, the sourcefile depend on other files
-    echo "$object : \\" > "$depfile"
-
-    # Clip off the initial element (the dependent).  Don't try to be
-    # clever and replace this with sed code, as IRIX sed won't handle
-    # lines with more than a fixed number of characters (4096 in
-    # IRIX 6.2 sed, 8192 in IRIX 6.5).  We also remove comment lines;
-    # the IRIX cc adds comments like '#:fec' to the end of the
-    # dependency line.
-    tr ' ' "$nl" < "$tmpdepfile" \
-    | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' | \
-    tr "$nl" ' ' >> "$depfile"
-    echo >> "$depfile"
-
-    # The second pass generates a dummy entry for each header file.
-    tr ' ' "$nl" < "$tmpdepfile" \
-   | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
-   >> "$depfile"
-  else
-    # The sourcefile does not contain any dependencies, so just
-    # store a dummy comment line, to avoid errors with the Makefile
-    # "include basename.Plo" scheme.
-    echo "#dummy" > "$depfile"
-  fi
-  rm -f "$tmpdepfile"
-  ;;
-
-xlc)
-  # This case exists only to let depend.m4 do its work.  It works by
-  # looking at the text of this script.  This case will never be run,
-  # since it is checked for above.
-  exit 1
-  ;;
-
-aix)
-  # The C for AIX Compiler uses -M and outputs the dependencies
-  # in a .u file.  In older versions, this file always lives in the
-  # current directory.  Also, the AIX compiler puts '$object:' at the
-  # start of each line; $object doesn't have directory information.
-  # Version 6 uses the directory in both cases.
-  dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
-  test "x$dir" = "x$object" && dir=
-  base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
-  if test "$libtool" = yes; then
-    tmpdepfile1=$dir$base.u
-    tmpdepfile2=$base.u
-    tmpdepfile3=$dir.libs/$base.u
-    "$@" -Wc,-M
-  else
-    tmpdepfile1=$dir$base.u
-    tmpdepfile2=$dir$base.u
-    tmpdepfile3=$dir$base.u
-    "$@" -M
-  fi
-  stat=$?
-
-  if test $stat -eq 0; then :
-  else
-    rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
-    exit $stat
-  fi
-
-  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
-  do
-    test -f "$tmpdepfile" && break
-  done
-  if test -f "$tmpdepfile"; then
-    # Each line is of the form 'foo.o: dependent.h'.
-    # Do two passes, one to just change these to
-    # '$object: dependent.h' and one to simply 'dependent.h:'.
-    sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
-    sed -e 's,^.*\.[a-z]*:['"$tab"' ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
-  else
-    # The sourcefile does not contain any dependencies, so just
-    # store a dummy comment line, to avoid errors with the Makefile
-    # "include basename.Plo" scheme.
-    echo "#dummy" > "$depfile"
-  fi
-  rm -f "$tmpdepfile"
-  ;;
-
-icc)
-  # Intel's C compiler anf tcc (Tiny C Compiler) understand '-MD -MF file'.
-  # However on
-  #    $CC -MD -MF foo.d -c -o sub/foo.o sub/foo.c
-  # ICC 7.0 will fill foo.d with something like
-  #    foo.o: sub/foo.c
-  #    foo.o: sub/foo.h
-  # which is wrong.  We want
-  #    sub/foo.o: sub/foo.c
-  #    sub/foo.o: sub/foo.h
-  #    sub/foo.c:
-  #    sub/foo.h:
-  # ICC 7.1 will output
-  #    foo.o: sub/foo.c sub/foo.h
-  # and will wrap long lines using '\':
-  #    foo.o: sub/foo.c ... \
-  #     sub/foo.h ... \
-  #     ...
-  # tcc 0.9.26 (FIXME still under development at the moment of writing)
-  # will emit a similar output, but also prepend the continuation lines
-  # with horizontal tabulation characters.
-  "$@" -MD -MF "$tmpdepfile"
-  stat=$?
-  if test $stat -eq 0; then :
-  else
-    rm -f "$tmpdepfile"
-    exit $stat
-  fi
-  rm -f "$depfile"
-  # Each line is of the form 'foo.o: dependent.h',
-  # or 'foo.o: dep1.h dep2.h \', or ' dep3.h dep4.h \'.
-  # Do two passes, one to just change these to
-  # '$object: dependent.h' and one to simply 'dependent.h:'.
-  sed -e "s/^[ $tab][ $tab]*/  /" -e "s,^[^:]*:,$object :," \
-    < "$tmpdepfile" > "$depfile"
-  sed '
-    s/[ '"$tab"'][ '"$tab"']*/ /g
-    s/^ *//
-    s/ *\\*$//
-    s/^[^:]*: *//
-    /^$/d
-    /:$/d
-    s/$/ :/
-  ' < "$tmpdepfile" >> "$depfile"
-  rm -f "$tmpdepfile"
-  ;;
-
-hp2)
-  # The "hp" stanza above does not work with aCC (C++) and HP's ia64
-  # compilers, which have integrated preprocessors.  The correct option
-  # to use with these is +Maked; it writes dependencies to a file named
-  # 'foo.d', which lands next to the object file, wherever that
-  # happens to be.
-  # Much of this is similar to the tru64 case; see comments there.
-  dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
-  test "x$dir" = "x$object" && dir=
-  base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
-  if test "$libtool" = yes; then
-    tmpdepfile1=$dir$base.d
-    tmpdepfile2=$dir.libs/$base.d
-    "$@" -Wc,+Maked
-  else
-    tmpdepfile1=$dir$base.d
-    tmpdepfile2=$dir$base.d
-    "$@" +Maked
-  fi
-  stat=$?
-  if test $stat -eq 0; then :
-  else
-     rm -f "$tmpdepfile1" "$tmpdepfile2"
-     exit $stat
-  fi
-
-  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2"
-  do
-    test -f "$tmpdepfile" && break
-  done
-  if test -f "$tmpdepfile"; then
-    sed -e "s,^.*\.[a-z]*:,$object:," "$tmpdepfile" > "$depfile"
-    # Add 'dependent.h:' lines.
-    sed -ne '2,${
-	       s/^ *//
-	       s/ \\*$//
-	       s/$/:/
-	       p
-	     }' "$tmpdepfile" >> "$depfile"
-  else
-    echo "#dummy" > "$depfile"
-  fi
-  rm -f "$tmpdepfile" "$tmpdepfile2"
-  ;;
-
-tru64)
-   # The Tru64 compiler uses -MD to generate dependencies as a side
-   # effect.  'cc -MD -o foo.o ...' puts the dependencies into 'foo.o.d'.
-   # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
-   # dependencies in 'foo.d' instead, so we check for that too.
-   # Subdirectories are respected.
-   dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
-   test "x$dir" = "x$object" && dir=
-   base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
-
-   if test "$libtool" = yes; then
-      # With Tru64 cc, shared objects can also be used to make a
-      # static library.  This mechanism is used in libtool 1.4 series to
-      # handle both shared and static libraries in a single compilation.
-      # With libtool 1.4, dependencies were output in $dir.libs/$base.lo.d.
-      #
-      # With libtool 1.5 this exception was removed, and libtool now
-      # generates 2 separate objects for the 2 libraries.  These two
-      # compilations output dependencies in $dir.libs/$base.o.d and
-      # in $dir$base.o.d.  We have to check for both files, because
-      # one of the two compilations can be disabled.  We should prefer
-      # $dir$base.o.d over $dir.libs/$base.o.d because the latter is
-      # automatically cleaned when .libs/ is deleted, while ignoring
-      # the former would cause a distcleancheck panic.
-      tmpdepfile1=$dir.libs/$base.lo.d   # libtool 1.4
-      tmpdepfile2=$dir$base.o.d          # libtool 1.5
-      tmpdepfile3=$dir.libs/$base.o.d    # libtool 1.5
-      tmpdepfile4=$dir.libs/$base.d      # Compaq CCC V6.2-504
-      "$@" -Wc,-MD
-   else
-      tmpdepfile1=$dir$base.o.d
-      tmpdepfile2=$dir$base.d
-      tmpdepfile3=$dir$base.d
-      tmpdepfile4=$dir$base.d
-      "$@" -MD
-   fi
-
-   stat=$?
-   if test $stat -eq 0; then :
-   else
-      rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
-      exit $stat
-   fi
-
-   for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
-   do
-     test -f "$tmpdepfile" && break
-   done
-   if test -f "$tmpdepfile"; then
-      sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
-      sed -e 's,^.*\.[a-z]*:['"$tab"' ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
-   else
-      echo "#dummy" > "$depfile"
-   fi
-   rm -f "$tmpdepfile"
-   ;;
-
-msvc7)
-  if test "$libtool" = yes; then
-    showIncludes=-Wc,-showIncludes
-  else
-    showIncludes=-showIncludes
-  fi
-  "$@" $showIncludes > "$tmpdepfile"
-  stat=$?
-  grep -v '^Note: including file: ' "$tmpdepfile"
-  if test "$stat" = 0; then :
-  else
-    rm -f "$tmpdepfile"
-    exit $stat
-  fi
-  rm -f "$depfile"
-  echo "$object : \\" > "$depfile"
-  # The first sed program below extracts the file names and escapes
-  # backslashes for cygpath.  The second sed program outputs the file
-  # name when reading, but also accumulates all include files in the
-  # hold buffer in order to output them again at the end.  This only
-  # works with sed implementations that can handle large buffers.
-  sed < "$tmpdepfile" -n '
-/^Note: including file:  *\(.*\)/ {
-  s//\1/
-  s/\\/\\\\/g
-  p
-}' | $cygpath_u | sort -u | sed -n '
-s/ /\\ /g
-s/\(.*\)/'"$tab"'\1 \\/p
-s/.\(.*\) \\/\1:/
-H
-$ {
-  s/.*/'"$tab"'/
-  G
-  p
-}' >> "$depfile"
-  rm -f "$tmpdepfile"
-  ;;
-
-msvc7msys)
-  # This case exists only to let depend.m4 do its work.  It works by
-  # looking at the text of this script.  This case will never be run,
-  # since it is checked for above.
-  exit 1
-  ;;
-
-#nosideeffect)
-  # This comment above is used by automake to tell side-effect
-  # dependency tracking mechanisms from slower ones.
-
-dashmstdout)
-  # Important note: in order to support this mode, a compiler *must*
-  # always write the preprocessed file to stdout, regardless of -o.
-  "$@" || exit $?
-
-  # Remove the call to Libtool.
-  if test "$libtool" = yes; then
-    while test "X$1" != 'X--mode=compile'; do
-      shift
-    done
-    shift
-  fi
-
-  # Remove '-o $object'.
-  IFS=" "
-  for arg
-  do
-    case $arg in
-    -o)
-      shift
-      ;;
-    $object)
-      shift
-      ;;
-    *)
-      set fnord "$@" "$arg"
-      shift # fnord
-      shift # $arg
-      ;;
-    esac
-  done
-
-  test -z "$dashmflag" && dashmflag=-M
-  # Require at least two characters before searching for ':'
-  # in the target name.  This is to cope with DOS-style filenames:
-  # a dependency such as 'c:/foo/bar' could be seen as target 'c' otherwise.
-  "$@" $dashmflag |
-    sed 's:^['"$tab"' ]*[^:'"$tab"' ][^:][^:]*\:['"$tab"' ]*:'"$object"'\: :' > "$tmpdepfile"
-  rm -f "$depfile"
-  cat < "$tmpdepfile" > "$depfile"
-  tr ' ' "$nl" < "$tmpdepfile" | \
-## Some versions of the HPUX 10.20 sed can't process this invocation
-## correctly.  Breaking it into two sed invocations is a workaround.
-    sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
-  rm -f "$tmpdepfile"
-  ;;
-
-dashXmstdout)
-  # This case only exists to satisfy depend.m4.  It is never actually
-  # run, as this mode is specially recognized in the preamble.
-  exit 1
-  ;;
-
-makedepend)
-  "$@" || exit $?
-  # Remove any Libtool call
-  if test "$libtool" = yes; then
-    while test "X$1" != 'X--mode=compile'; do
-      shift
-    done
-    shift
-  fi
-  # X makedepend
-  shift
-  cleared=no eat=no
-  for arg
-  do
-    case $cleared in
-    no)
-      set ""; shift
-      cleared=yes ;;
-    esac
-    if test $eat = yes; then
-      eat=no
-      continue
-    fi
-    case "$arg" in
-    -D*|-I*)
-      set fnord "$@" "$arg"; shift ;;
-    # Strip any option that makedepend may not understand.  Remove
-    # the object too, otherwise makedepend will parse it as a source file.
-    -arch)
-      eat=yes ;;
-    -*|$object)
-      ;;
-    *)
-      set fnord "$@" "$arg"; shift ;;
-    esac
-  done
-  obj_suffix=`echo "$object" | sed 's/^.*\././'`
-  touch "$tmpdepfile"
-  ${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@"
-  rm -f "$depfile"
-  # makedepend may prepend the VPATH from the source file name to the object.
-  # No need to regex-escape $object, excess matching of '.' is harmless.
-  sed "s|^.*\($object *:\)|\1|" "$tmpdepfile" > "$depfile"
-  sed '1,2d' "$tmpdepfile" | tr ' ' "$nl" | \
-## Some versions of the HPUX 10.20 sed can't process this invocation
-## correctly.  Breaking it into two sed invocations is a workaround.
-    sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
-  rm -f "$tmpdepfile" "$tmpdepfile".bak
-  ;;
-
-cpp)
-  # Important note: in order to support this mode, a compiler *must*
-  # always write the preprocessed file to stdout.
-  "$@" || exit $?
-
-  # Remove the call to Libtool.
-  if test "$libtool" = yes; then
-    while test "X$1" != 'X--mode=compile'; do
-      shift
-    done
-    shift
-  fi
-
-  # Remove '-o $object'.
-  IFS=" "
-  for arg
-  do
-    case $arg in
-    -o)
-      shift
-      ;;
-    $object)
-      shift
-      ;;
-    *)
-      set fnord "$@" "$arg"
-      shift # fnord
-      shift # $arg
-      ;;
-    esac
-  done
-
-  "$@" -E |
-    sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
-       -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' |
-    sed '$ s: \\$::' > "$tmpdepfile"
-  rm -f "$depfile"
-  echo "$object : \\" > "$depfile"
-  cat < "$tmpdepfile" >> "$depfile"
-  sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile"
-  rm -f "$tmpdepfile"
-  ;;
-
-msvisualcpp)
-  # Important note: in order to support this mode, a compiler *must*
-  # always write the preprocessed file to stdout.
-  "$@" || exit $?
-
-  # Remove the call to Libtool.
-  if test "$libtool" = yes; then
-    while test "X$1" != 'X--mode=compile'; do
-      shift
-    done
-    shift
-  fi
-
-  IFS=" "
-  for arg
-  do
-    case "$arg" in
-    -o)
-      shift
-      ;;
-    $object)
-      shift
-      ;;
-    "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI")
-	set fnord "$@"
-	shift
-	shift
-	;;
-    *)
-	set fnord "$@" "$arg"
-	shift
-	shift
-	;;
-    esac
-  done
-  "$@" -E 2>/dev/null |
-  sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile"
-  rm -f "$depfile"
-  echo "$object : \\" > "$depfile"
-  sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::'"$tab"'\1 \\:p' >> "$depfile"
-  echo "$tab" >> "$depfile"
-  sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile"
-  rm -f "$tmpdepfile"
-  ;;
-
-msvcmsys)
-  # This case exists only to let depend.m4 do its work.  It works by
-  # looking at the text of this script.  This case will never be run,
-  # since it is checked for above.
-  exit 1
-  ;;
-
-none)
-  exec "$@"
-  ;;
-
-*)
-  echo "Unknown depmode $depmode" 1>&2
-  exit 1
-  ;;
-esac
-
-exit 0
-
-# Local Variables:
-# mode: shell-script
-# sh-indentation: 2
-# eval: (add-hook 'write-file-hooks 'time-stamp)
-# time-stamp-start: "scriptversion="
-# time-stamp-format: "%:y-%02m-%02d.%02H"
-# time-stamp-time-zone: "UTC"
-# time-stamp-end: "; # UTC"
-# End:

docs/Doxyfile.in

@@ -31,14 +31,14 @@ PROJECT_NAME           = libtins
 # This could be handy for archiving the generated documentation or
 # if some version control system is used.
 
-PROJECT_NUMBER         = 1.2
+PROJECT_NUMBER         = @LIBTINS_VERSION@
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
 # base path where the generated documentation will be put.
 # If a relative path is entered, it will be relative to the location
 # where doxygen was started. If left blank the current directory will be used.
 
-OUTPUT_DIRECTORY       = ../docs/
+OUTPUT_DIRECTORY       = @CMAKE_CURRENT_BINARY_DIR@/docs/
 
 # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
 # 4096 sub-directories (in 2 levels) under the output directory of each output
@@ -581,7 +581,7 @@ WARN_LOGFILE           =
 # directories like "/usr/src/myproject". Separate the files or directories
 # with spaces.
 
-INPUT                  = include src
+INPUT                  = @CMAKE_CURRENT_SOURCE_DIR@/include @CMAKE_CURRENT_SOURCE_DIR@/src @CMAKE_CURRENT_SOURCE_DIR@/docs/mainpage.dox
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is

docs/mainpage.dox

@@ -0,0 +1,29 @@
+/** 
+ * \mainpage Documentation
+ *
+ * \section intro_sec Introduction
+ *
+ * <i>libtins</i> is a high-level, multiplatform <i>C++</i> network packet 
+ * sniffing and crafting library.
+ * 
+ * Its main purpose is to provide the <i>C++</i> developer an easy, efficient, 
+ * platform and endianess-independent way to create tools which need to 
+ * send, receive and manipulate network packets.
+ *
+ * \section install_sec Installation
+ * 
+ * Please visit the <a href="http://libtins.github.io/download/">downloads
+ * section</a> in order to see the installation instructions.
+ *
+ * \section tutorials_sec Tutorials
+ *
+ * If you want to learn about how the library works, please visit the
+ * <a href="http://libtins.github.io/tutorial/">tutorials</a> section.
+ *
+ * \section examples_sec Examples
+ *
+ * Make sure to visit the <a href="http://libtins.github.io/examples/">
+ * examples</a> section to see some short but illustrative examples on how 
+ * to send and sniff packets using <i>libtins</i>.
+ *
+ */

examples/CMakeLists.txt

@@ -0,0 +1,58 @@
+FIND_PACKAGE(libtins QUIET)
+FIND_PACKAGE(Threads QUIET)
+
+IF(libtins_FOUND)
+    SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/examples)
+    INCLUDE_DIRECTORIES(${LIBTINS_INCLUDE_DIRS})
+    LINK_LIBRARIES(${LIBTINS_LIBRARIES})
+
+    IF(HAVE_CXX11)
+        SET(LIBTINS_CXX11_EXAMPLES
+            arpmonitor
+            dns_queries
+            dns_spoof
+            dns_stats
+            wps_detect
+            traceroute
+        )
+    ELSE(HAVE_CXX11)
+        MESSAGE(WARNING "Disabling some examples since C++11 support is disabled.")
+    ENDIF(HAVE_CXX11)
+
+    ADD_CUSTOM_TARGET(
+        examples DEPENDS
+        arpspoofing
+        ${LIBTINS_CXX11_EXAMPLES}
+        beacon_display
+        portscan
+    )
+
+    ADD_EXECUTABLE(arpspoofing EXCLUDE_FROM_ALL arpspoofing.cpp)
+    IF(HAVE_CXX11)
+        ADD_EXECUTABLE(arpmonitor EXCLUDE_FROM_ALL arpmonitor.cpp)
+        ADD_EXECUTABLE(dns_queries EXCLUDE_FROM_ALL dns_queries.cpp)
+        ADD_EXECUTABLE(dns_spoof EXCLUDE_FROM_ALL dns_spoof.cpp)
+        ADD_EXECUTABLE(dns_stats EXCLUDE_FROM_ALL dns_stats.cpp)
+        ADD_EXECUTABLE(wps_detect EXCLUDE_FROM_ALL wps_detect.cpp)
+    ENDIF(HAVE_CXX11)
+
+    ADD_EXECUTABLE(beacon_display EXCLUDE_FROM_ALL beacon_display.cpp)
+
+    if(THREADS_FOUND)
+        IF(HAVE_CXX11)
+            ADD_EXECUTABLE(traceroute EXCLUDE_FROM_ALL traceroute.cpp)
+            TARGET_LINK_LIBRARIES(traceroute ${CMAKE_THREAD_LIBS_INIT})
+        ENDIF(HAVE_CXX11)
+
+        ADD_EXECUTABLE(portscan EXCLUDE_FROM_ALL portscan.cpp)
+        TARGET_LINK_LIBRARIES(portscan ${CMAKE_THREAD_LIBS_INIT})
+    ELSE(THREADS_FOUND)
+        MESSAGE(WARNING "Disabling portscan and traceroute examples since pthreads library was not found.")
+    ENDIF(THREADS_FOUND)
+ELSE(libtins_FOUND)
+    MESSAGE(
+        WARNING 
+        "Disabling examples since libtins is not installed. "
+        "Run cmake again once it is installed in order to compile them."
+    )
+ENDIF(libtins_FOUND)

examples/Makefile.in

@@ -1,28 +0,0 @@
-CXX=@CXX@
-CXXFLAGS=-Wall @CXXFLAGS@
-LDFLAGS=-ltins
-EXECUTABLES=arpspoof portscan traceroute beacon_display
-
-all: $(EXECUTABLES)
-
-compile: $(OBJECTS)
-
-recompile: clean all
-
-arpspoof: 
-	$(CXX) arpspoofing.cpp -o arpspoofing $(CXXFLAGS) $(LDFLAGS)
-
-beacon_display: 
-	$(CXX) beacon_display.cpp -o beacon_display $(CXXFLAGS) $(LDFLAGS) 	
-
-portscan:
-	$(CXX) portscan.cpp -o portscan $(CXXFLAGS) $(LDFLAGS) -lpthread
-	
-traceroute: 
-	$(CXX) traceroute.cpp -o traceroute -std=c++0x $(CXXFLAGS) $(LDFLAGS) -lpthread
-
-.cpp.o:
-	$(CXX) $(CXXFLAGS) $(INCLUDE) $< -o $@
-
-clean:
-	rm $(OBJECTS) $(EXECUTABLES)

examples/arpmonitor.cpp

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+ 
+#include <tins/tins.h>
+#include <map>
+#include <iostream>
+#include <functional>
+
+using namespace Tins;
+
+class arp_monitor {
+public:
+    void run(Sniffer &sniffer);
+private:
+    bool callback(const PDU &pdu);
+
+    std::map<IPv4Address, HWAddress<6>> addresses;
+};
+
+void arp_monitor::run(Sniffer &sniffer)
+{
+    sniffer.sniff_loop(
+        std::bind(
+            &arp_monitor::callback,
+            this,
+            std::placeholders::_1
+        )
+    );
+}
+
+bool arp_monitor::callback(const PDU &pdu)
+{
+    // Retrieve the ARP layer
+    const ARP &arp = pdu.rfind_pdu<ARP>();
+    // Is it an ARP reply?
+    if(arp.opcode() == ARP::REPLY) {
+        // Let's check if there's already an entry for this address
+        auto iter = addresses.find(arp.sender_ip_addr());
+        if(iter == addresses.end()) {
+            // We haven't seen this address. Save it.
+            addresses.insert({ arp.sender_ip_addr(), arp.sender_hw_addr()});
+            std::cout << "[INFO] " << arp.sender_ip_addr() << " is at "
+                      << arp.sender_hw_addr() << std::endl;
+        }
+        else {
+            // We've seen this address. If it's not the same HW address, inform it
+            if(arp.sender_hw_addr() != iter->second) {
+                std::cout << "[WARNING] " << arp.sender_ip_addr() << " is at " 
+                          << iter->second << " but also at " << arp.sender_hw_addr() 
+                          << std::endl;
+            }
+        }
+    }
+    return true;
+}
+
+int main(int argc, char *argv[]) 
+{
+    if(argc != 2) {
+        std::cout << "Usage: " << *argv << " <interface>\n";
+        return 1;
+    }
+    arp_monitor monitor;
+    // Sniffer configuration
+    SnifferConfiguration config;
+    config.set_promisc_mode(true);
+    config.set_filter("arp");
+
+    // Sniff on the provided interface in promiscuous mode
+    Sniffer sniffer(argv[1], config);
+    
+    // Only capture arp packets
+    monitor.run(sniffer);
+}

examples/arpspoofing.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without

examples/beacon_display.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -47,7 +47,11 @@ private:
 };
  
 void BeaconSniffer::run(const std::string &iface) {
-    Sniffer sniffer(iface, 1500, true, "type mgt subtype beacon");
+    SnifferConfiguration config;
+    config.set_promisc_mode(true);
+    config.set_filter("type mgt subtype beacon");
+    config.set_rfmon(true);
+    Sniffer sniffer(iface, config);
     sniffer.sniff_loop(make_sniffer_handler(this, &BeaconSniffer::callback));
 }
  

examples/configure.ac

@@ -1,16 +0,0 @@
-AC_INIT(myconfig, 0.1)
-
-AC_PROG_CXX()
-AC_LANG(C++)
-
-if test -n "$debug"
-then
-    CFLAGS="-DDEBUG -g"
-else
-    CFLAGS="-O3"
-fi
-
-AC_CHECK_HEADERS([pcap.h])
-AC_CHECK_LIB(pcap, pcap_loop, [], [AC_MSG_ERROR([pcap library is needed!])])
-AC_SUBST(CFLAGS)
-AC_OUTPUT(Makefile)

examples/dns_queries.cpp

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <tins/tins.h>
+#include <iostream>
+
+using namespace Tins;
+
+bool callback(const PDU &pdu) 
+{
+    // The packet probably looks like this:
+    //
+    // EthernetII / IP / UDP / RawPDU
+    //
+    // So we retrieve the RawPDU layer, and construct a 
+    // DNS PDU using its contents.
+    DNS dns = pdu.rfind_pdu<RawPDU>().to<DNS>();
+    
+    // Retrieve the queries and print the domain name:
+    for(const auto &query : dns.queries()) 
+        std::cout << query.dname() << std::endl;
+    return true;
+}
+
+int main(int argc, char *argv[]) 
+{
+    if(argc != 2) {
+        std::cout << "Usage: " << *argv << " <interface>" << std::endl;
+        return 1;
+    }
+    // Sniff on the provided interface in promiscuos mode
+    SnifferConfiguration config;
+    config.set_promisc_mode(true);
+    // Only capture udp packets sent to port 53
+    config.set_filter("udp and dst port 53");
+    Sniffer sniffer(argv[1], config);
+    
+    // Start the capture
+    sniffer.sniff_loop(callback);
+}

examples/dns_spoof.cpp

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <tins/tins.h>
+#include <iostream>
+
+using namespace Tins;
+
+PacketSender sender;
+
+bool callback(const PDU &pdu) 
+{
+    // The packet probably looks like this:
+    //
+    // EthernetII / IP / UDP / RawPDU
+    //
+    // So we retrieve each layer, and construct a 
+    // DNS PDU from the RawPDU layer contents.
+    EthernetII eth = pdu.rfind_pdu<EthernetII>();
+    IP ip = eth.rfind_pdu<IP>();
+    UDP udp = ip.rfind_pdu<UDP>();
+    DNS dns = udp.rfind_pdu<RawPDU>().to<DNS>();
+
+    // Is it a DNS query?
+    if(dns.type() == DNS::QUERY) {
+        // Let's see if there's any query for an "A" record.
+        for(const auto &query : dns.queries()) {
+            if(query.type() == DNS::A) {
+                // Here's one! Let's add an answer.
+                dns.add_answer(
+                    DNS::Resource(
+                        query.dname(), 
+                        "127.0.0.1",
+                        DNS::A, 
+                        query.query_class(), 
+                        // 777 is just a random TTL
+                        777
+                    )
+                );
+            }
+        }
+        // Have we added some answers?
+        if(dns.answers_count() > 0) {
+            // It's a response now
+            dns.type(DNS::RESPONSE);
+            // Recursion is available(just in case)
+            dns.recursion_available(1);
+            // Build our packet
+            auto pkt = EthernetII(eth.src_addr(), eth.dst_addr()) /
+                        IP(ip.src_addr(), ip.dst_addr()) /
+                        UDP(udp.sport(), udp.dport()) /
+                        dns;
+            // Send it!
+            sender.send(pkt);
+        }
+    }
+    return true;
+}
+
+int main(int argc, char *argv[]) 
+{
+    if(argc != 2) {
+        std::cout << "Usage: " << *argv << " <interface>" << std::endl;
+        return 1;
+    }
+    // Sniff on the provided interface in promiscuos mode
+    SnifferConfiguration config;
+    config.set_promisc_mode(true);
+    // Only capture udp packets sent to port 53
+    config.set_filter("udp and dst port 53");
+    Sniffer sniffer(argv[1], config);
+    
+    // All packets will be sent through the provided interface
+    sender.default_interface(argv[1]);
+    
+    // Start the capture
+    sniffer.sniff_loop(callback);
+}

examples/dns_stats.cpp

@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <iostream>
+#include <mutex>
+#include <chrono>
+#include <map>
+#include <thread>
+#include <algorithm>
+#include <tins/tins.h>
+
+using namespace Tins;
+
+// Holds the DNS response time statistics. The response time is 
+// represented using the Duration template parameter.
+template<typename Duration>
+class statistics {
+public:
+    using duration_type = Duration;
+    using locker_type = std::lock_guard<std::mutex>;
+    
+    struct information {
+        duration_type average, worst;
+        size_t count;
+    };
+    
+    statistics()
+    : m_duration(), m_worst(duration_type::min()), m_count()
+    {
+        
+    }
+    
+    void add_response_time(const duration_type& duration)
+    {
+        locker_type _(m_lock);
+        m_duration += duration;
+        m_count++;
+        m_worst = std::max(m_worst, duration);
+    }
+    
+    information get_information() const 
+    {
+        locker_type _(m_lock);
+        if(m_count == 0)
+            return { };
+        else 
+            return { m_duration / m_count, m_worst, m_count };
+    };
+private:
+    duration_type m_duration, m_worst;
+    size_t m_count;
+    mutable std::mutex m_lock;
+};
+
+// Sniffs and tracks DNS queries. When a matching DNS response is found,
+// the response time is added to a statistics object.
+//
+// This class performs *no cleanup* on data associated with queries that
+// weren't answered.
+class dns_monitor {
+public:
+    // The response times are measured in milliseconds
+    using duration_type = std::chrono::milliseconds;
+    // The statistics type used.
+    using statistics_type = statistics<duration_type>;
+    
+    void run(BaseSniffer& sniffer);
+    const statistics_type& stats() const {
+        return m_stats;
+    }
+private:
+    using packet_info = std::tuple<IPv4Address, IPv4Address, uint16_t>;
+    using clock_type = std::chrono::steady_clock;
+    using time_point_type = std::chrono::time_point<clock_type>;
+
+    bool callback(const PDU& pdu);
+    static packet_info make_packet_info(const PDU& pdu, const DNS& dns);
+    
+    statistics_type m_stats;    
+    std::map<packet_info, time_point_type> m_packet_info;
+};
+
+void dns_monitor::run(BaseSniffer& sniffer)
+{
+    sniffer.sniff_loop(
+        std::bind(
+            &dns_monitor::callback, 
+            this, 
+            std::placeholders::_1
+        )
+    );
+}
+
+bool dns_monitor::callback(const PDU& pdu)
+{
+    auto now = clock_type::now();
+    auto dns = pdu.rfind_pdu<RawPDU>().to<DNS>();
+    auto info = make_packet_info(pdu, dns);
+    // If it's a query, add the sniff time to our map.
+    if(dns.type() == DNS::QUERY) {
+        m_packet_info.insert(
+            std::make_pair(info, now)
+        );
+    }
+    else {
+        // It's a response, we need to find the query in our map.
+        auto iter = m_packet_info.find(info);
+        if(iter != m_packet_info.end()) {
+            // We found the query, let's add the response time to the
+            // statistics object.
+            m_stats.add_response_time(
+                std::chrono::duration_cast<duration_type>(now - iter->second)
+            );
+            // Forget about the query.
+            m_packet_info.erase(iter);
+        }
+    }
+    return true;
+}
+
+// It is required that we can identify packets sent and received that
+// hold the same DNS id as belonging to the same query. 
+// 
+// This function retrieves a tuple (addr, addr, id) that will achieve it.
+auto dns_monitor::make_packet_info(const PDU& pdu, const DNS& dns) -> packet_info
+{
+    const auto& ip = pdu.rfind_pdu<IP>();
+    return std::make_tuple( 
+        // smallest address first
+        std::min(ip.src_addr(), ip.dst_addr()),
+        // largest address second
+        std::max(ip.src_addr(), ip.dst_addr()),
+        dns.id()
+    );
+}
+
+int main(int argc, char *argv[]) {
+    if(argc != 2) {
+        std::cout << "Usage: " << *argv << " <interface>\n";
+        return 1;
+    }
+    try {
+        SnifferConfiguration config;
+        config.set_promisc_mode(true);
+        config.set_filter("udp and dst port 53");
+        Sniffer sniffer(argv[1], config);
+        dns_monitor monitor;
+        std::thread thread(
+            [&]() {
+                monitor.run(sniffer);
+            }
+        );
+        while(true) {
+            auto info = monitor.stats().get_information();
+            std::cout << "\rAverage " << info.average.count() 
+                        << "ms. Worst: " << info.worst.count() << "ms. Count: "
+                        << info.count;
+            std::cout.flush();
+            std::this_thread::sleep_for(std::chrono::seconds(1));
+        }
+    }
+    catch(std::exception& ex) {
+        std::cout << "[-] Error: " << ex.what() << std::endl;
+    }
+}

examples/portscan.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,6 +30,7 @@
 #include <iostream>
 #include <iomanip>
 #include <vector>
+#include <set>
 #include <string>
 #include <cstdlib>
 #include <pthread.h>
@@ -49,27 +50,88 @@ using namespace Tins;
 
 typedef std::pair<Sniffer*, std::string> sniffer_data;
 
+class Scanner {
+public:
+    Scanner(const NetworkInterface& interface, const IPv4Address& address, 
+        const vector<string>& ports);
+    
+    void run();
+private:
+    void send_syns(const NetworkInterface &iface, IPv4Address dest_ip);
+    bool callback(PDU &pdu);
+    static void *thread_proc(void *param);
+    void launch_sniffer();
+    
+    NetworkInterface iface;
+    IPv4Address host_to_scan;
+    set<uint16_t> ports_to_scan;
+    Sniffer sniffer;
+};
+
+Scanner::Scanner(const NetworkInterface& interface, const IPv4Address& address, 
+    const vector<string>& ports)
+: iface(interface), host_to_scan(address), sniffer(interface.name())
+{
+    sniffer.set_filter(
+        "tcp and ip src " + address.to_string() + " and tcp[tcpflags] & (tcp-rst|tcp-syn) != 0"
+    );
+    for(size_t i = 0; i < ports.size(); ++i) {
+        ports_to_scan.insert(atoi(ports[i].c_str()));
+    }
+}
+
+void *Scanner::thread_proc(void *param) {
+    Scanner *data = (Scanner*)param;
+    data->launch_sniffer();
+    return 0;
+}
+
+void Scanner::launch_sniffer()
+{
+    sniffer.sniff_loop(make_sniffer_handler(this, &Scanner::callback));
+}
 
 /* Our scan handler. This will receive SYNs and RSTs and inform us
  * the scanned port's status.
  */
-bool handler(PDU &pdu) {
+bool Scanner::callback(PDU &pdu) 
+{
+    // Find the layers we want.
+    const IP &ip = pdu.rfind_pdu<IP>();
     const TCP &tcp = pdu.rfind_pdu<TCP>();
-    // Ok, it's a TCP PDU. Is RST flag on? Then port is closed.
-    if(tcp.get_flag(TCP::RST)) {
-        // This indicates we should stop sniffing.
-        if(tcp.get_flag(TCP::SYN))
-            return false;
-        cout << "Port: " << setw(5) << tcp.sport() << " closed\n";
+    // Check if the host that we're scanning sent this packet and
+    // the source port is one of those that we scanned.
+    if(ip.src_addr() == host_to_scan && ports_to_scan.count(tcp.sport()) == 1) {
+        // Ok, it's a TCP PDU. Is RST flag on? Then port is closed.
+        if(tcp.get_flag(TCP::RST)) {
+            // This indicates we should stop sniffing.
+            if(tcp.get_flag(TCP::SYN))
+                return false;
+            cout << "Port: " << setw(5) << tcp.sport() << " closed\n";
+        }
+        // Is SYN flag on? Then port is open!
+        else if(tcp.flags() == (TCP::SYN | TCP::ACK)) {
+            cout << "Port: " << setw(5) << tcp.sport() << " open\n";
+        }
     }
-    // Is SYN flag on? Then port is open!
-    else if(tcp.flags() == (TCP::SYN | TCP::ACK))
-        cout << "Port: " << setw(5) << tcp.sport() << " open\n";
     return true;
 }
 
+void Scanner::run()
+{
+    pthread_t thread;
+    // Launch our sniff thread.
+    pthread_create(&thread, 0, &Scanner::thread_proc, this); 
+    // Start sending SYNs to port.
+    send_syns(iface, host_to_scan);
+
+    // Wait for our sniffer.
+    void *dummy;
+    pthread_join(thread, &dummy);
+}
+
 // Send syns to the given ip address, using the destination ports provided.
-void send_syns(const NetworkInterface &iface, IPv4Address dest_ip, const vector<string> &ips) {
+void Scanner::send_syns(const NetworkInterface &iface, IPv4Address dest_ip) {
     // Retrieve the addresses.
     NetworkInterface::Info info = iface.addresses();
     PacketSender sender;
@@ -82,9 +144,9 @@ void send_syns(const NetworkInterface &iface, IPv4Address dest_ip, const vector<
     // Just some random port. 
     tcp.sport(1337);
     cout << "Sending SYNs..." << endl;
-    for(vector<string>::const_iterator it = ips.begin(); it != ips.end(); ++it) {
+    for(set<uint16_t>::const_iterator it = ports_to_scan.begin(); it != ports_to_scan.end(); ++it) {
         // Set the new port and send the packet!
-        tcp.dport(atoi(it->c_str()));
+        tcp.dport(*it);
         sender.send(ip);
     }
     // Wait 1 second.
@@ -93,6 +155,7 @@ void send_syns(const NetworkInterface &iface, IPv4Address dest_ip, const vector<
      * by our function, which will in turn return false.  
      */
     tcp.set_flag(TCP::RST, 1);
+    tcp.sport(*ports_to_scan.begin());
     // Pretend we're the scanned host...
     ip.src_addr(dest_ip);
     // We use an ethernet pdu, otherwise the kernel will drop it.
@@ -100,38 +163,17 @@ void send_syns(const NetworkInterface &iface, IPv4Address dest_ip, const vector<
     sender.send(eth, iface);
 }
 
-void *thread_proc(void *param) {
-    // IP address is our parameter.
-    sniffer_data *data = (sniffer_data*)param;
-    Sniffer *sniffer = data->first;
-    sniffer->set_filter("tcp and ip src " + data->second + " and tcp[tcpflags] & (tcp-rst|tcp-syn) != 0");
-    // Sniff loop. Only sniff TCP PDUs comming from the given IP and have either RST or SYN flag on.
-    sniffer->sniff_loop(handler);
-    return 0;
-}
-
 void scan(int argc, char *argv[]) {
     IPv4Address ip(argv[1]);
     // Resolve the interface which will be our gateway
     NetworkInterface iface(ip);
     cout << "Sniffing on interface: " << iface.name() << endl;
-
-    // 300 bytes are enough to receive SYNs and RSTs.
-    Sniffer sniffer(iface.name(), 300);
-    sniffer_data data(&sniffer, argv[1]);
-    pthread_t thread;
-    // Launch our sniff thread.
-    pthread_create(&thread, 0, thread_proc, &data); 
     
     // Consume arguments
     argv += 2;
     argc -= 2;
-    // Start sending SYNs to port.
-    send_syns(iface, ip, vector<string>(argv, argv + (argc)));
-    
-    // Wait for our sniffer.
-    void *dummy;
-    pthread_join(thread, &dummy);
+    Scanner scanner(iface, ip, vector<string>(argv, argv + (argc)));
+    scanner.run();
 }
 
 int main(int argc, char *argv[]) {

examples/traceroute.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -47,10 +47,12 @@ public:
     
     result_type trace() {
         // ICMPs that aren't sent from us.
-        Sniffer sniffer(
-            iface.name(), 500, false, 
-            "ip proto \\icmp and not src host " + iface.addresses().ip_addr.to_string()
-        );
+        SnifferConfiguration config;
+        config.set_snap_len(500);
+        config.set_promisc_mode(false);
+        config.set_filter(
+            "ip proto \\icmp and not src host " + iface.addresses().ip_addr.to_string());
+        Sniffer sniffer(iface.name(), config);
         
         PacketSender sender;
         // Create our handler

examples/wps_detect.cpp

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <tins/tins.h>
+#include <iostream>
+#include <set>
+#include <string>
+
+using namespace Tins;
+
+// BSSIDs which we've already seen
+std::set<HWAddress<6>> addrs;
+// This will be the content of the OUI field in the vendor specific 
+// tagged option if it's a WPS tag.
+const HWAddress<3> expected_oui("00:50:F2");
+
+bool handler(const PDU& pdu) {
+    const Dot11Beacon &beacon = pdu.rfind_pdu<Dot11Beacon>();
+    // Only process it once
+    if(addrs.insert(beacon.addr3()).second) {
+        // Iterate the tagged options
+        for(const auto &opt : beacon.options()) {
+            // Is this a vendor-specific tag?
+            if(opt.option() == Dot11::VENDOR_SPECIFIC) {
+                // Make sure there's enough size for the OUI + identifier
+                if(opt.data_size() >= 4) { 
+                    // Retrieve the OUI field
+                    HWAddress<3> addr = opt.data_ptr();
+                    // Are we interested in this OUI and is it a WPS tag?
+                    if(addr == expected_oui && opt.data_ptr()[3] == 0x04) {
+                        std::cout << "[+] Access point: " << beacon.ssid() << " uses WPS\n";
+                    }
+                }
+            }
+        }
+    }
+    return true;
+}
+
+int main(int argc, char *argv[]) {
+    if(argc != 2) {
+        std::cout << "Usage: " << *argv << " <DEVICE>\n";
+        return 1;
+    }
+    // Only sniff beacons
+    SnifferConfiguration config;
+    config.set_snap_len(2000);
+    config.set_promisc_mode(true);
+    config.set_filter("wlan type mgt subtype beacon");
+    Sniffer sniffer(argv[1], config);
+    sniffer.sniff_loop(handler);
+}

include/CMakeLists.txt

@@ -0,0 +1 @@
+ADD_SUBDIRECTORY(tins)

include/config.h.in

@@ -1,86 +0,0 @@
-/* include/config.h.in.  Generated from configure.ac by autoheader.  */
-
-/* define if the compiler supports basic C++11 syntax */
-#undef HAVE_CXX11
-
-/* Define to 1 if you have the <dlfcn.h> header file. */
-#undef HAVE_DLFCN_H
-
-/* Define to 1 if you have the <inttypes.h> header file. */
-#undef HAVE_INTTYPES_H
-
-/* Define to 1 if you have the `crypto' library (-lcrypto). */
-#undef HAVE_LIBCRYPTO
-
-/* Define to 1 if you have the `pcap' library (-lpcap). */
-#undef HAVE_LIBPCAP
-
-/* Define to 1 if you have the <memory.h> header file. */
-#undef HAVE_MEMORY_H
-
-/* Define to 1 if you have the <openssl/aes.h> header file. */
-#undef HAVE_OPENSSL_AES_H
-
-/* Define to 1 if you have the <openssl/evp.h> header file. */
-#undef HAVE_OPENSSL_EVP_H
-
-/* Define to 1 if you have the <openssl/hmac.h> header file. */
-#undef HAVE_OPENSSL_HMAC_H
-
-/* Define to 1 if you have the <pcap.h> header file. */
-#undef HAVE_PCAP_H
-
-/* Define to 1 if you have the <stdint.h> header file. */
-#undef HAVE_STDINT_H
-
-/* Define to 1 if you have the <stdlib.h> header file. */
-#undef HAVE_STDLIB_H
-
-/* Define to 1 if you have the <strings.h> header file. */
-#undef HAVE_STRINGS_H
-
-/* Define to 1 if you have the <string.h> header file. */
-#undef HAVE_STRING_H
-
-/* Define to 1 if you have the <sys/stat.h> header file. */
-#undef HAVE_SYS_STAT_H
-
-/* Define to 1 if you have the <sys/types.h> header file. */
-#undef HAVE_SYS_TYPES_H
-
-/* Define to 1 if you have the <unistd.h> header file. */
-#undef HAVE_UNISTD_H
-
-/* Have WPA2 decryption library */
-#undef HAVE_WPA2_DECRYPTION
-
-/* Define to the sub-directory in which libtool stores uninstalled libraries.
-   */
-#undef LT_OBJDIR
-
-/* Name of package */
-#undef PACKAGE
-
-/* Define to the address where bug reports for this package should be sent. */
-#undef PACKAGE_BUGREPORT
-
-/* Define to the full name of this package. */
-#undef PACKAGE_NAME
-
-/* Define to the full name and version of this package. */
-#undef PACKAGE_STRING
-
-/* Define to the one symbol short name of this package. */
-#undef PACKAGE_TARNAME
-
-/* Define to the home page for this package. */
-#undef PACKAGE_URL
-
-/* Define to the version of this package. */
-#undef PACKAGE_VERSION
-
-/* Define to 1 if you have the ANSI C header files. */
-#undef STDC_HEADERS
-
-/* Version number of package */
-#undef VERSION

include/dns_record.h

@@ -1,272 +0,0 @@
-/*
- * Copyright (c) 2012, Matias Fontanini
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- * * Redistributions of source code must retain the above copyright
- *   notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- *   copyright notice, this list of conditions and the following disclaimer
- *   in the documentation and/or other materials provided with the
- *   distribution.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef TINS_DNS_RECORD_H
-#define TINS_DNS_RECORD_H
-
-#include <string>
-#include <vector>
-#include <stdint.h>
-#include "cxxstd.h"
-#include "macros.h"
-
-namespace Tins {
-/** 
- * \cond
- */
-class DNSRRImpl {
-public:
-    virtual ~DNSRRImpl() {}
-    virtual uint32_t size() const = 0;
-    virtual uint32_t do_write(uint8_t *buffer) const = 0;
-    virtual bool matches(const std::string &dname) const { return false; }
-    virtual DNSRRImpl *clone() const = 0;
-};
-
-/**
- * \brief Abstracts a DNS resource record.
- */
-class DNSResourceRecord {
-public:
-    /**
-     * \brief The type used to store resource records' information.
-     */
-    TINS_BEGIN_PACK
-    struct info {
-        uint16_t type, qclass;
-        uint32_t ttl;
-        
-        info(uint16_t tp, uint16_t qc, uint32_t tm) 
-          : type(tp), qclass(qc), ttl(tm) { }
-        
-        info() : type(), qclass(), ttl() {}
-    } TINS_END_PACK;
-    
-    /**
-     * \brief Constructs a record.
-     * \param impl A pointer to the impl object.
-     * \param data A pointer to the start of the data buffer.
-     * \param len The length of the data.
-     */
-    DNSResourceRecord(DNSRRImpl *impl = 0, const uint8_t *data = 0, uint16_t len = 0);
-    
-    /**
-     * \brief Constructs a record.
-     * 
-     * If the input data is malformed, a malformed_packet exception
-     * is thrown.
-     * 
-     * \param buffer A pointer to the start of the data buffer.
-     * \param len The length of the data.
-     */
-    DNSResourceRecord(const uint8_t *buffer, uint32_t size);
-    
-    /**
-     * \brief Constructs a record from an input range.
-     * \param impl A pointer to the impl object.
-     * \param start The begining of the range.
-     * \param end The end of the range.
-     */
-    template<typename ForwardIterator>
-    DNSResourceRecord(DNSRRImpl *impl, ForwardIterator start, ForwardIterator end) 
-    : impl(impl), data(start, end)
-    {  }
-    
-    /**
-     * \brief Copy constructor.
-     * 
-     * This handles cloning the impl object.
-     * \param rhs The record which will be copied.
-     */
-    DNSResourceRecord(const DNSResourceRecord &rhs);
-    
-    /**
-     * \brief Copy assignment operator.
-     * 
-     * This handles cloning the impl object.
-     * \param rhs The record which will be copied.
-     */
-    DNSResourceRecord& operator=(const DNSResourceRecord &rhs);
-    
-    #if TINS_IS_CXX11
-        /**
-         * Move constructor.
-         */
-        DNSResourceRecord(DNSResourceRecord &&rhs) noexcept 
-        : info_(rhs.info_), data(std::move(rhs.data)), impl(0) {
-            std::swap(impl, rhs.impl);
-        }
-        
-        /**
-         * Move assignment operator.
-         */
-        DNSResourceRecord& operator=(DNSResourceRecord &&rhs) noexcept 
-        {
-            info_ = rhs.info_;
-            data = std::move(rhs.data);
-            delete impl;
-            impl = 0;
-            std::swap(impl, rhs.impl);
-            return *this;
-        }
-    #endif // TINS_IS_CXX11
-    
-    /**
-     * \brief Destructor.
-     * 
-     * This frees the impl object.
-     */
-    ~DNSResourceRecord();
-
-    /**
-     * \brief Writes this record to a buffer.
-     * 
-     * \param buffer The buffer in which to store the serialization.
-     * \return uint32_t containing the number of bytes written.
-     */
-    uint32_t write(uint8_t *buffer) const;
-    
-    /**
-     * \brief Returns the size of the data in this record.
-     */
-    uint32_t data_size() const {
-        return data.size();
-    }
-    
-    /**
-     * \brief Returns the pointer to the start of the data buffer.
-     */
-    const uint8_t *data_ptr() const {
-        return &data[0];
-    }
-    
-    /**
-     * \brief Returns a bool indicating whether this record contains
-     * a domain name as the name being resolved.
-     */
-    bool has_domain_name() const;
-    
-    /**
-     * \brief Returns a pointer to the domain name stored in this record.
-     * 
-     * This will throw a std::bad_cast exception if the impl object is
-     * not of the type NamedDNSRRImpl.
-     */
-    const std::string *dname() const;
-    
-    /**
-     * \brief Returns the offset stored in this record.
-     * 
-     * This will throw a std::bad_cast exception if the impl object is
-     * not of the type OffsetedDNSRRImpl.
-     */
-    uint16_t offset() const;
-    
-    /**
-     * \brief Returns the size of this record.
-     */
-    uint32_t size() const;
-    
-    /**
-     * \brief Returns a reference to the info field.
-     */
-    info &information() {
-        return info_;
-    }
-    
-    /**
-     * \brief Returns a const reference to the info field.
-     */
-    const info &information() const {
-        return info_;
-    }
-    
-    /**
-     * \brief Checks if the domain name stored in this record matches
-     * the given one.
-     * 
-     * This is a shortcut 
-     */
-    bool matches(const std::string &dname) const;
-private:
-    DNSRRImpl *clone_impl() const;
-    size_t impl_size() const;
-
-    info info_;
-    std::vector<uint8_t> data;
-    DNSRRImpl *impl;
-};
-
-class OffsetedDNSRRImpl : public DNSRRImpl {
-public:
-    OffsetedDNSRRImpl(uint16_t off);
-    
-    uint32_t do_write(uint8_t *buffer) const;
-    uint32_t size() const;
-    OffsetedDNSRRImpl *clone() const;
-    uint16_t offset() const;
-private:
-    uint16_t offset_;
-};
-
-class NamedDNSRRImpl : public DNSRRImpl {
-public:
-    NamedDNSRRImpl(const std::string &nm);
-    
-    template<typename ForwardIterator>
-    NamedDNSRRImpl(ForwardIterator start, ForwardIterator end)
-    : name(start, end) 
-    { }
-    
-    uint32_t do_write(uint8_t *buffer) const;
-    
-    uint32_t size() const;
-    
-    bool matches(const std::string &dname) const;
-    
-    const std::string *dname_pointer() const;
-    NamedDNSRRImpl *clone() const;
-private:
-    std::string name;
-};
-
-/** 
- * \endcond
- */
-
-inline DNSResourceRecord make_offseted_record(uint16_t offset, const uint8_t *data = 0, uint32_t size = 0) {
-    return DNSResourceRecord(new OffsetedDNSRRImpl(offset), data, size);
-}
-
-inline DNSResourceRecord make_named_record(const std::string &name, const uint8_t *data = 0, uint32_t size = 0) {
-    return DNSResourceRecord(new NamedDNSRRImpl(name), data, size);
-}
-}
-
-#endif // TINS_DNS_RECORD_H

include/pdu_option.h

@@ -1,167 +0,0 @@
-/*
- * Copyright (c) 2012, Matias Fontanini
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- * * Redistributions of source code must retain the above copyright
- *   notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- *   copyright notice, this list of conditions and the following disclaimer
- *   in the documentation and/or other materials provided with the
- *   distribution.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef TINS_PDU_OPTION_H
-#define TINS_PDU_OPTION_H
-
-#include <vector>
-#include <iterator>
-#include <stdint.h>
-#include "exceptions.h"
-
-namespace Tins {
-/**
- * \class PDUOption
- * \brief Represents a PDU option field.
- * 
- * Several PDUs, such as TCP, IP, Dot11 or DHCP contain options. All
- * of them behave exactly the same way. This class represents those
- * options.
- * 
- * The OptionType template parameter indicates the type that will be
- * used to store this option's identifier.
- * 
- * The Container template parameter indicates the container which will
- * be used to store this option's data. The container <b>must</b>
- * store data sequentially. std::vector<uint8_t> is the default
- * container.
- */
-template<typename OptionType, class Container = std::vector<uint8_t> >
-class PDUOption {
-public:
-    typedef Container container_type;
-    typedef typename container_type::value_type data_type;
-    typedef OptionType option_type;
-
-    /**
-     * \brief Constructs a PDUOption.
-     * \param opt The option type.
-     * \param length The option's data length.
-     * \param data The option's data(if any).
-     */
-    PDUOption(option_type opt = option_type(), size_t length = 0, const data_type *data = 0) 
-    : option_(opt), size_(length), value_(data, data + (data ? length : 0)) {
-        
-    }
-    
-    /**
-     * \brief Constructs a PDUOption from iterators, which 
-     * indicate the data to be stored in it.
-     * 
-     * \param opt The option type.
-     * \param start The beginning of the option data.
-     * \param end The end of the option data.
-     */
-    template<typename ForwardIterator>
-    PDUOption(option_type opt, ForwardIterator start, ForwardIterator end) 
-    : option_(opt), size_(std::distance(start, end)), value_(start, end) {
-        
-    }
-    
-    /**
-     * \brief Constructs a PDUOption from iterators, which 
-     * indicate the data to be stored in it.
-     * 
-     * The length parameter indicates the contents of the length field
-     * when this option is serialized. Note that this can be different
-     * to std::distance(start, end).
-     * 
-     * \sa length_field
-     * 
-     * \param opt The option type.
-     * \param length The length of this option.
-     * \param start The beginning of the option data.
-     * \param end The end of the option data.
-     */
-    template<typename ForwardIterator>
-    PDUOption(option_type opt, size_t length, ForwardIterator start, ForwardIterator end) 
-    : option_(opt), size_(length), value_(start, end) {
-        
-    }
-    
-    /**
-     * Retrieves this option's type.
-     * \return uint8_t containing this option's size.
-     */
-    option_type option() const {
-        return option_;
-    }
-    
-    /**
-     * Sets this option's type
-     * \param opt The option type to be set.
-     */
-    void option(option_type opt) {
-        option_ = opt;
-    }
-    
-    /**
-     * Retrieves this option's data.
-     * 
-     * If this method is called when data_size() == 0, 
-     * dereferencing the returned pointer will result in undefined
-     * behaviour.
-     * 
-     * \return const data_type& containing this option's value.
-     */
-    const data_type *data_ptr() const {
-        return &*value_.begin();
-    }
-    
-    /**
-     * \brief Retrieves the length of this option's data.
-     * 
-     * This is the actual size of the data.
-     */
-    size_t data_size() const {
-        return value_.size();
-    }
-    
-    /**
-     * \brief Retrieves the data length field.
-     * 
-     * This is what the size field will contain when this option is 
-     * serialized. It can differ from the actual data size. 
-     * 
-     * This will be equal to data_size unless the constructor that takes
-     * both a data length and two iterators is used.
-
-     * 
-     * \sa data_size.
-     */
-    size_t length_field() const {
-        return size_;
-    }
-private:
-    option_type option_;
-    uint16_t size_;
-    container_type value_;
-};
-} // namespace Tins
-#endif // TINS_PDU_OPTION_H

include/rsn_information.h

@@ -1,186 +0,0 @@
-/*
- * Copyright (c) 2012, Matias Fontanini
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- * * Redistributions of source code must retain the above copyright
- *   notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- *   copyright notice, this list of conditions and the following disclaimer
- *   in the documentation and/or other materials provided with the
- *   distribution.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef TINS_RSN_INFORMATION
-#define TINS_RSN_INFORMATION
-
-#include <stdint.h>
-#include <vector>
-#include "endianness.h"
-
-namespace Tins{
-    /**
-     * \brief Class that models the RSN information structure.
-     */
-    class RSNInformation {
-    public:
-        /**
-         * \brief Enum that represents the different cypher suites.
-         */
-        enum CypherSuites {
-            WEP_40  = 0x01ac0f00,
-            TKIP    = 0x02ac0f00,
-            CCMP    = 0x04ac0f00,
-            WEP_104 = 0x05ac0f00
-        };
-
-        /**
-         * \brief Enum that represents the different akm suites.
-         */
-        enum AKMSuites {
-            PMKSA = 0x01ac0f00,
-            PSK   = 0x02ac0f00
-        };
-
-        /**
-         * The type used to store the cypher suites.
-         */
-        typedef std::vector<CypherSuites> cyphers_type;
-        
-        /**
-         * The type used to store the AKM suites.
-         */
-        typedef std::vector<AKMSuites> akm_type;
-        
-        /**
-         * The type returned on serialization.
-         */
-        typedef std::vector<uint8_t> serialization_type;
-
-        /**
-         * \brief Constructs an RSNInformation object.
-         *
-         * By default, the version is set to 1.
-         */
-        RSNInformation();
-        
-        /**
-         * \brief Constructs an RSNInformation object from a 
-         * serialization_type object.
-         * 
-         * \param buffer The buffer from which to construct this object.
-         */
-        RSNInformation(const serialization_type &buffer);
-        
-        /**
-         * \brief Constructs a RSNInformation from a buffer.
-         * 
-         * If the input is malformed, a malformed_packet exception is
-         * thrown.
-         * 
-         * \param buffer The buffer from which this object will be constructed.
-         * \param total_sz The total size of the buffer.
-         */
-        RSNInformation(const uint8_t *buffer, uint32_t total_sz);
-
-        /**
-         * \brief Helper function to create a WPA2-PSK RSNInformation
-         * \return An instance RSNInformation which contains information
-         * for a WPA2-PSK AP.
-         */
-        static RSNInformation wpa2_psk();
-
-        /**
-         * \brief Adds a pairwise cypher suite.
-         * \param cypher The pairwise cypher suite to be added.
-         */
-        void add_pairwise_cypher(CypherSuites cypher);
-
-        /**
-         * \brief Adds an akm suite.
-         * \param akm The akm suite to be added.
-         */
-        void add_akm_cypher(AKMSuites akm);
-
-        /**
-         * \brief Sets the group suite cypher.
-         * \param group The group suite cypher to be set.
-         */
-        void group_suite(CypherSuites group);
-
-        /**
-         * \brief Sets the version.
-         * \param ver The version to be set.
-         */
-        void version(uint16_t ver);
-
-        /**
-         * \brief Sets the capabilities field.
-         * \param cap The capabilities to be set.
-         */
-        void capabilities(uint16_t cap);
-
-        /* Getters */
-
-        /**
-         * \brief Getter for the group suite field.
-         * \return The group suite field.
-         */
-        CypherSuites group_suite() const { return _group_suite; }
-
-        /**
-         * \brief Getter for the version field.
-         * \return The version field.
-         */
-        uint16_t version() const { return Endian::le_to_host(_version); }
-        
-        /**
-         * \brief Getter for the capabilities field.
-         * \return The version field.
-         */
-        uint16_t capabilities() const { return Endian::le_to_host(_capabilities); }
-
-        /**
-         * \brief Getter for the pairwise cypher suite list.
-         * \return A list of pairwise cypher suites.
-         */
-        const cyphers_type &pairwise_cyphers() const { return _pairwise_cyphers; }
-
-        /**
-         * \brief Getter for the akm suite list.
-         * \return A list of akm suites.
-         */
-        const akm_type &akm_cyphers() const { return _akm_cyphers; }
-
-        /**
-         * \brief Serializes this object.
-         * \return The result of the serialization. 
-         */
-         serialization_type serialize() const;
-    private:
-        void init(const uint8_t *buffer, uint32_t total_sz);
-    
-        uint16_t _version, _capabilities;
-        CypherSuites _group_suite;
-        akm_type _akm_cyphers;
-        cyphers_type _pairwise_cyphers;
-    };
-} // namespace Tins
-
-#endif // TINS_RSN_INFORMATION

include/tins/CMakeLists.txt

@@ -0,0 +1,7 @@
+FILE(GLOB INCLUDE_FILES "*.h")
+INSTALL(
+    FILES ${INCLUDE_FILES} 
+    DESTINATION include/tins
+    COMPONENT Headers
+)
+ADD_SUBDIRECTORY(dot11)

include/tins/address_range.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without

include/tins/arp.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -42,7 +42,8 @@ namespace Tins {
     class EthernetII;
 
     /**
-     * \brief Class that represents an ARP PDU.
+     * \class ARP
+     * \brief Represents an ARP PDU.
      *
      */
     class ARP : public PDU {

include/tins/bootp.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -43,6 +43,7 @@
 namespace Tins {
 
     /**
+     * \class BootP
      * \brief Class representing a BootP packet.
      */
     class BootP : public PDU {

include/tins/config.h.in

@@ -0,0 +1,13 @@
+#ifndef TINS_CONFIG_H
+#define TINS_CONFIG_H
+
+/* Define if the compiler supports basic C++11 syntax */
+#cmakedefine HAVE_CXX11
+
+/* Have IEEE 802.11 support */
+#cmakedefine HAVE_DOT11
+
+/* Have WPA2 decryption library */
+#cmakedefine HAVE_WPA2_DECRYPTION
+
+#endif // TINS_CONFIG_H

include/tins/constants.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -85,6 +85,7 @@ namespace Tins {
                 IPX = 0x8137,	  /* IPX */
                 IPV6 = 0x86dd,    /* IP protocol version 6 */
                 PPPOED = 0x8863, /* PPPoE Discovery */
+                PPPOES = 0x8864, /* PPPoE Session */
                 EAPOL = 0x888e,   /* EAPOL */
                 LOOPBACK = 0x9000 /* used to test interfaces */
             };

include/tins/crypto.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,7 +27,9 @@
  *
  */
 
-#ifndef TINS_CRYPTO_H
+#include "config.h"
+
+#if !defined(TINS_CRYPTO_H) && defined(HAVE_DOT11)
 #define TINS_CRYPTO_H
 
 #include <map>
@@ -38,7 +40,6 @@
 #include "snap.h"
 #include "rawpdu.h"
 #include "handshake_capturer.h"
-#include "config.h"
 
 namespace Tins {
 class PDU;
@@ -49,7 +50,7 @@ namespace Crypto {
     /**
      * \cond
      */
-    class RC4Key;
+    struct RC4Key;
     #ifdef HAVE_WPA2_DECRYPTION
     namespace WPA2 {
         class invalid_handshake : public std::exception {

include/tins/cxxstd.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -38,7 +38,9 @@
     #define TINS_CXXSTD_GCC_FIX 0
 #endif // __GXX_EXPERIMENTAL_CXX0X__
 
-#define TINS_IS_CXX11 (__cplusplus > 199711L || TINS_CXXSTD_GCC_FIX == 1)
+#ifndef TINS_IS_CXX11
+#define TINS_IS_CXX11 (__cplusplus > 199711L || TINS_CXXSTD_GCC_FIX == 1 || _MSC_VER >= 1800)
+#endif  // TINS_IS_CXX11
 
 namespace Tins{
 namespace Internals {

include/tins/data_link_type.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_DATA_LINK_TYPE_H
+#define TINS_DATA_LINK_TYPE_H
+
+#include <pcap.h>
+
+namespace Tins {
+
+class EthernetII;
+class RadioTap;
+class Dot11;
+class Dot3;
+class SLL;
+class Loopback;
+class PPI;
+
+/**
+ * \struct DataLinkType
+ * \brief Maps a libtins link layer PDU to a libpcap data link identifier.
+ *
+ * This is an empty class that should be instantiated with any object that 
+ * represents a link layer PDU (EthernetII, Dot11, RadioTap, etc):
+ *
+ * \code
+ * // Instantiate it and pass it to PacketWriter's constructor.
+ * PacketWriter writer("file.pcap", DataLinkType<RadioTap>());
+ * \endcode
+ */
+template<typename T>
+struct DataLinkType;
+
+#define TINS_MAKE_DATA_LINK_TYPE(tins_type, pcap_type) \
+template<> \
+struct DataLinkType<tins_type> { \
+    static const int type = pcap_type; \
+    int get_type() const { \
+        return type; \
+    } \
+}; 
+
+TINS_MAKE_DATA_LINK_TYPE(EthernetII, DLT_EN10MB)
+TINS_MAKE_DATA_LINK_TYPE(Dot3, DLT_EN10MB)
+TINS_MAKE_DATA_LINK_TYPE(SLL, DLT_LINUX_SLL)
+TINS_MAKE_DATA_LINK_TYPE(Loopback, DLT_LOOP)
+TINS_MAKE_DATA_LINK_TYPE(PPI, DLT_PPI)
+TINS_MAKE_DATA_LINK_TYPE(Dot11, DLT_IEEE802_11)
+TINS_MAKE_DATA_LINK_TYPE(RadioTap, DLT_IEEE802_11_RADIO)
+
+#undef TINS_MAKE_DATA_LINK_TYPE
+
+} // Tins
+
+#endif // TINS_DATA_LINK_TYPE_H

include/tins/dhcp.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -32,6 +32,7 @@
 
 
 #include <list>
+#include <vector>
 #include <string>
 #include "bootp.h"
 #include "pdu_option.h"
@@ -39,11 +40,29 @@
 
 namespace Tins {
     /** 
-     * \brief Class that represents the DHCP PDU.
+     * \class DHCP
+     * \brief Represents the DHCP PDU.
      *
-     * When adding options, the "End" option is not added automatically. 
+     * This class represents a DHCP PDU. It contains helpers methods
+     * which make it easy to set/get specific option values.
+     * 
+     * Note that when adding options, the "End" option is not added 
+     * automatically, so you will have to add it yourself.
      *
-     * \sa DHCP::end
+     * Options can be retrieved easily from DHCP PDUs:
+     *
+     * \code
+     * // Sniff a packet from somewhere
+     * DHCP dhcp = get_dhcp_from_somewhere();
+     * 
+     * // This retrieves the Domain Name Servers option and converts
+     * // it to a std::vector<IPv4Address>. Note that if this option
+     * // is not present, an option_not_found exception is thrown.
+     * for(const auto& address : dhcp.domain_name_servers()) {
+     *     // address is an ip
+     * }
+     * 
+     * \endcode
      */
     class DHCP : public BootP {
     public:
@@ -145,7 +164,7 @@ namespace Tins {
         /**
          * The DHCP option type.
          */
-        typedef PDUOption<uint8_t> option;
+        typedef PDUOption<uint8_t, DHCP> option;
         
         /**
          * The type used to store the DHCP options.
@@ -271,7 +290,7 @@ namespace Tins {
          * 
          * \param routers A list of ip addresses.
          */
-        void routers(const std::list<ipaddress_type> &routers);
+        void routers(const std::vector<ipaddress_type> &routers);
         
         /** 
          * \brief Adds a domain name servers option.
@@ -280,7 +299,7 @@ namespace Tins {
          * 
          * \param dns A list of ip addresses.
          */
-        void domain_name_servers(const std::list<ipaddress_type> &dns);
+        void domain_name_servers(const std::vector<ipaddress_type> &dns);
         
         /** 
          * \brief Adds a broadcast address option.
@@ -308,6 +327,15 @@ namespace Tins {
          * \param name The domain name.
          */
         void domain_name(const std::string &name);
+
+        /** 
+         * \brief Adds a hostname option.
+         * 
+         * The new option is appended at the end of the list.
+         * 
+         * \param name The hostname.
+         */
+        void hostname(const std::string &name);
         
         // Option getters
         
@@ -377,10 +405,10 @@ namespace Tins {
          * If the option is not found, an option_not_found exception
          * is thrown.
          * 
-         * \return std::list<ipaddress_type> Containing the routers 
+         * \return std::vector<ipaddress_type> Containing the routers 
          * option data.
          */
-        std::list<ipaddress_type> routers() const;
+        std::vector<ipaddress_type> routers() const;
         
         /**
          * \brief Searchs for a dns option.
@@ -391,7 +419,7 @@ namespace Tins {
          * \return std::list<ipaddress_type> Contanining the DNS servers
          * provided.
          */
-        std::list<ipaddress_type> domain_name_servers() const; 
+        std::vector<ipaddress_type> domain_name_servers() const; 
         
         /**
          * \brief Searchs for a broadcast option.
@@ -422,6 +450,16 @@ namespace Tins {
          * \return std::string Containing the domain name.
          */
         std::string domain_name() const;
+
+        /**
+         * \brief Searchs for a hostname option.
+         * 
+         * If the option is not found, an option_not_found exception
+         * is thrown.
+         * 
+         * \return std::string Containing the hostname.
+         */
+        std::string hostname() const;
         
         /** 
          * \brief Getter for the options list.
@@ -450,27 +488,19 @@ namespace Tins {
         }
     private:
         static const uint32_t MAX_DHCP_SIZE;
-        
-        template<typename T>
-        struct type2type {};
       
         void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
-        
+
         template<class T> 
-        T generic_search(OptionTypes opt, type2type<T>) const {
+        T search_and_convert(OptionTypes opt) const {
             const option *option = search_option(opt);
-            if(option && option->data_size() == sizeof(T))
-                return *(const T*)option->data_ptr();
-            else
+            if(!option)
                 throw option_not_found();
+            return option->to<T>();
         }
         
         void internal_add_option(const option &opt);
-        std::list<ipaddress_type> generic_search(OptionTypes opt, type2type<std::list<ipaddress_type> >) const;
-        std::string generic_search(OptionTypes opt, type2type<std::string>) const;
-        ipaddress_type generic_search(OptionTypes opt, type2type<ipaddress_type>) const;
-        
-        serialization_type serialize_list(const std::list<ipaddress_type> &ip_list);
+        serialization_type serialize_list(const std::vector<ipaddress_type> &ip_list);
         
         options_type _options;
         uint32_t _size;

include/tins/dhcpv6.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,6 +30,7 @@
 #ifndef TINS_DHCPV6_H
 #define TINS_DHCPV6_H
 
+#include <cstring>
 #include <list>
 #include "pdu.h"
 #include "endianness.h"
@@ -39,14 +40,15 @@
 
 namespace Tins {    
 /**
- * Represents a DHCPv6 PDU.
+ * \class DHCPv6
+ * \brief Represents a DHCPv6 PDU.
  */
 class DHCPv6 : public PDU {
 public:
     /**
      * Represents a DHCPv6 option. 
      */
-    typedef PDUOption<uint16_t> option;
+    typedef PDUOption<uint16_t, DHCPv6> option;
 
     /**
      * The message types.
@@ -179,6 +181,8 @@ public:
         ia_na_type(uint32_t id = 0, uint32_t t1 = 0, uint32_t t2 = 0,
           const options_type& options = options_type())
         : id(id), t1(t1), t2(t2), options(options) {}
+
+        static ia_na_type from_option(const option &opt);
     };
     
     /**
@@ -194,6 +198,8 @@ public:
         ia_ta_type(uint32_t id = 0,
           const options_type& options = options_type())
         : id(id), options(options) {}
+
+        static ia_ta_type from_option(const option &opt);
     };
 
     /**
@@ -211,6 +217,8 @@ public:
           const options_type& options = options_type())
         : address(address), preferred_lifetime(preferred_lifetime), 
           valid_lifetime(valid_lifetime), options(options) {}
+
+        static ia_address_type from_option(const option &opt);
     };
     
     /**
@@ -228,6 +236,8 @@ public:
           const auth_info_type &auth_info = auth_info_type())
         : protocol(protocol), algorithm(algorithm), rdm(rdm),
         replay_detection(replay_detection), auth_info(auth_info) {}
+
+        static authentication_type from_option(const option &opt);
     };
     
     /**
@@ -239,6 +249,8 @@ public:
         
         status_code_type(uint16_t code = 0, const std::string &message = "")
         : code(code), message(message) { }
+
+        static status_code_type from_option(const option &opt);
     };
     
     /**
@@ -253,6 +265,8 @@ public:
         vendor_info_type(uint32_t enterprise_number = 0, 
           const data_type &data = data_type())
         : enterprise_number(enterprise_number), data(data) { }
+
+        static vendor_info_type from_option(const option &opt);
     };
     
     
@@ -264,7 +278,19 @@ public:
     /**
      * The type used to store the User Class option.
      */
-    typedef std::vector<class_option_data_type> user_class_type;
+    //typedef std::vector<class_option_data_type> user_class_type;
+    struct user_class_type {
+        typedef std::vector<class_option_data_type> data_type;
+        data_type data;
+
+        user_class_type(const data_type &data = data_type())
+        : data(data)
+        {
+
+        }
+
+        static user_class_type from_option(const option &opt);
+    };
     
     /**
      * The type used to store the Vendor Class option.
@@ -279,6 +305,8 @@ public:
           const class_data_type &vendor_class_data = class_data_type())
         : enterprise_number(enterprise_number), 
         vendor_class_data(vendor_class_data) { }
+
+        static vendor_class_type from_option(const option &opt);
     };
     
     /**
@@ -361,12 +389,14 @@ public:
         
         duid_type(const duid_ll &identifier)
         : id(duid_en::duid_id), data(identifier.serialize()) {}
+
+        static duid_type from_option(const option &opt);
     };
         
     /**
      * The type used to store the Option Request option.
      */
-    typedef std::vector<OptionTypes> option_request_type;
+    typedef std::vector<uint16_t> option_request_type;
     
     /**
      * The type used to store the Relay Message option.
@@ -837,52 +867,63 @@ private:
             throw option_not_found();
         return option;
     }
-    
-    template<typename InputIterator>
-    void class_option_data2option(InputIterator start, InputIterator end, 
-      std::vector<uint8_t>& buffer, size_t start_index = 0) 
-    {
-        size_t index = start_index;
-        while(start != end) {
-            buffer.resize(buffer.size() + sizeof(uint16_t) + start->size());
-            *(uint16_t*)&buffer[index] = Endian::host_to_be<uint16_t>(start->size());
-            index += sizeof(uint16_t);
-            std::copy(start->begin(), start->end(), buffer.begin() + index);
-            index += start->size();
-            
-            start++;
-        }
-    }
-    
-    template<typename OutputType>
-    OutputType option2class_option_data(const uint8_t *ptr, uint32_t total_sz) const
-    {
-        typedef typename OutputType::value_type value_type;
-        OutputType output;
-        size_t index = 0;
-        while(index + 2 < total_sz) {
-            uint16_t size = Endian::be_to_host(
-                *(const uint16_t*)(ptr + index)
-            );
-            index += sizeof(uint16_t);
-            if(index + size > total_sz)
-                throw option_not_found();
-            output.push_back(
-                value_type(ptr + index, ptr + index + size)
-            );
-            index += size;
-        }
-        if(index != total_sz)
+
+    template<typename T>
+    T search_and_convert(OptionTypes opt) const {
+        const option *option = search_option(opt);
+        if(!option)
             throw option_not_found();
-        return output;
+        return option->to<T>();
     }
-    
 
     uint8_t header_data[4];
     uint32_t options_size;
     ipaddress_type link_addr, peer_addr;
     options_type options_;
-};    
+};   
+
+namespace Internals {
+template<typename InputIterator>
+void class_option_data2option(InputIterator start, InputIterator end, 
+  std::vector<uint8_t>& buffer, size_t start_index = 0) 
+{
+    size_t index = start_index;
+    uint16_t uint16_t_buffer;
+    while(start != end) {
+        buffer.resize(buffer.size() + sizeof(uint16_t) + start->size());
+        uint16_t_buffer = Endian::host_to_be<uint16_t>(start->size());
+        std::memcpy(&buffer[index], &uint16_t_buffer, sizeof(uint16_t));
+        index += sizeof(uint16_t);
+        std::copy(start->begin(), start->end(), buffer.begin() + index);
+        index += start->size();
+        
+        start++;
+    }
+}
+
+template<typename OutputType>
+OutputType option2class_option_data(const uint8_t *ptr, uint32_t total_sz)
+{
+    typedef typename OutputType::value_type value_type;
+    OutputType output;
+    size_t index = 0;
+    while(index + 2 < total_sz) {
+        uint16_t size;
+        std::memcpy(&size, ptr + index, sizeof(uint16_t));
+        size = Endian::be_to_host(size);
+        index += sizeof(uint16_t);
+        if(index + size > total_sz)
+            throw option_not_found();
+        output.push_back(
+            value_type(ptr + index, ptr + index + size)
+        );
+        index += size;
+    }
+    if(index != total_sz)
+        throw malformed_option();
+    return output;
+}
+} 
 }
 
 #endif // TINS_DHCPV6_H

include/tins/dns.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -39,7 +39,6 @@
 #include "macros.h"
 #include "pdu.h"
 #include "endianness.h"
-#include "dns_record.h"
 
 namespace Tins {
     class IPv4Address;
@@ -48,6 +47,27 @@ namespace Tins {
     /**
      * \class DNS
      * \brief Represents a DNS PDU.
+     *
+     * This class represents the DNS PDU, and allows easy access
+     * to queries and answer records. 
+     *
+     * The DNS PDU is not parsed automatically while sniffing, so you will
+     * have to parse it manually from an UDP packet's payload, for example:
+     *
+     * \code
+     * // Assume we get an udp packet from somewhere.
+     * UDP udp = get_udp_packet();
+     *
+     * // Now:
+     * // 1 - Get the RawPDU layer (contains the payload).
+     * // 2 - Construct a DNS object over its contents.
+     * DNS dns = udp.rfind_pdu<RawPDU>().to<DNS>();
+     *
+     * // Now use the DNS object!
+     * for(const auto& query : dns.queries()) {
+     *     // Process a query
+     * }
+     * \endcode
      */
     class DNS : public PDU {
     public:
@@ -200,14 +220,24 @@ namespace Tins {
          */
         class Resource {
         public:
-            Resource(const std::string &nm, const std::string &ad, 
-              uint16_t t, uint16_t c, uint32_t tt) 
-            : dname_(nm), addr_(ad), type_(t), qclass_(c), ttl_(tt) {}
+            /**
+             * Constructs a Resource object.
+             *
+             * \param dname The domain name for which this records 
+             * provides an answer.
+             * \param data The resource's payload.
+             * \param type The type of this record.
+             * \param rclass The class of this record.
+             * \param ttl The time-to-live of this record.
+             */
+            Resource(const std::string &dname, const std::string &data, 
+              uint16_t type, uint16_t rclass, uint32_t ttl) 
+            : dname_(dname), data_(data), type_(type), qclass_(rclass), ttl_(ttl) {}
             
             Resource() : type_(), qclass_(), ttl_() {}
             
             /**
-             * \brief Getter for the dname field.
+             * \brief Getter for the domain name field.
              * 
              * This returns the domain name for which this record 
              * provides an answer.
@@ -215,9 +245,9 @@ namespace Tins {
             const std::string &dname() const { return dname_; }
             
             /**
-             * Getter for the type field.
+             * Getter for the data field. 
              */
-            const std::string &data() const { return addr_; }
+            const std::string &data() const { return data_; }
             
             /**
              * Getter for the query type field.
@@ -233,8 +263,52 @@ namespace Tins {
              * Getter for the type field.
              */
             uint32_t ttl() const { return ttl_; }
+
+            /**
+             * Setter for the domain name field.
+             */
+            void dname(const std::string &data) {
+                dname_ = data;
+            }
+
+            /**
+             * \brief Setter for the data field.
+             *
+             * The data will be encoded properly by the DNS class before
+             * being added to this packet. That means that if the type is
+             * A or AAAA, it will be properly encoded as an IPv4 or
+             * IPv6 address. 
+             * 
+             * The same happens for records that contain domain names,
+             * such as NS or CNAME. This data will be encoded using 
+             * DNS domain name encoding.
+             */
+            void data(const std::string &data) {
+                data_ = data;
+            }
+
+            /**
+             * Setter for the type field.
+             */
+            void type(uint16_t data) {
+                type_ = data;
+            }
+
+            /**
+             * Setter for the class field.
+             */
+            void query_class(uint16_t data) {
+                qclass_ = data;
+            }
+
+            /**
+             * Setter for the time-to-live field.
+             */
+            void ttl(uint16_t data) {
+                ttl_ = data;
+            }
         private:
-            std::string dname_, addr_;
+            std::string dname_, data_;
             uint16_t type_, qclass_;
             uint32_t ttl_;
         };
@@ -482,100 +556,71 @@ namespace Tins {
         void add_query(const Query &query);
         
         /**
-         * \brief Add a query response.
+         * \brief Add an answer resource record.
          * 
-         * \param name The resolved name.
-         * \param type The type of this answer.
-         * \param qclass The class of this answer.
-         * \param ttl The time-to-live of this answer.
-         * \param ip The ip address of the resolved name.
+         * \param resource The resource to be added.
          */
-        void add_answer(const std::string &name, 
-          const DNSResourceRecord::info &info, address_type ip);
-          
+        void add_answer(const Resource &resource);
+
         /**
-         * \brief Add a query response.
+         * \brief Add an authority resource record.
          * 
-         * \param name The resolved name.
-         * \param type The type of this answer.
-         * \param qclass The class of this answer.
-         * \param ttl The time-to-live of this answer.
-         * \param ip The ip address of the resolved name.
+         * \param resource The resource to be added.
          */
-        void add_answer(const std::string &name, 
-          const DNSResourceRecord::info &info, address_v6_type ip);
-                        
-        /**
-         * \brief Add a query response.
-         * 
-         * \param name The resolved name.
-         * \param type The type of this answer.
-         * \param qclass The class of this answer.
-         * \param ttl The time-to-live of this answer.
-         * \param dname The domain of the resolved name.
-         */
-        void add_answer(const std::string &name, 
-          const DNSResourceRecord::info &info, const std::string &dname);
-                        
-        /**
-         * \brief Add a query response.
-         * 
-         * \param name The resolved name.
-         * \param type The type of this answer.
-         * \param qclass The class of this answer.
-         * \param ttl The time-to-live of this answer.
-         * \param data The data of this option.
-         * \param sz The size of the data.
-         */
-        void add_answer(const std::string &name, 
-          const DNSResourceRecord::info &info, const uint8_t *data, uint32_t sz);
+        void add_authority(const Resource &resource);
         
         /**
-         * \brief Add an authority record.
+         * \brief Add an additional resource record.
          * 
-         * \param name The resolved name.
-         * \param type The type of this record.
-         * \param qclass The class of this record.
-         * \param ttl The time-to-live of this record.
-         * \param data The data of this option.
-         * \param sz The size of the data.
+         * \param resource The resource to be added.
          */
-        void add_authority(const std::string &name, 
-          const DNSResourceRecord::info &info, const uint8_t *data, uint32_t sz);
-        
-        /**
-         * \brief Add an additional record.
-         * 
-         * \param name The resolved name.
-         * \param type The type of this record.
-         * \param qclass The class of this record.
-         * \param ttl The time-to-live of this record.
-         * \param ip The ip address of the resolved name.
-         */
-        void add_additional(const std::string &name, 
-          const DNSResourceRecord::info &info, uint32_t ip);
-                        
+        void add_additional(const Resource &resource);
         
         /**
          * \brief Getter for this PDU's DNS queries.
          * 
-         * This method is <b>not thread safe</b>.
-         * 
-         * \return std::list<Query> containing the queries in this
-         * record.
+         * \return The query records in this PDU.
          */
         queries_type queries() const;
         
         /**
          * \brief Getter for this PDU's DNS answers
          * 
-         * This method is <b>not thread safe</b>.
-         * 
-         * \return std::list<Resource> containing the answers in this
-         * record.
+         * \return The answer records in this PDU.
          */
         resources_type answers() const;
+
+        /**
+         * \brief Getter for this PDU's DNS authority records.
+         * 
+         * \return The authority records in this PDU.
+         */
+        resources_type authority() const;
+
+        /**
+         * \brief Getter for this PDU's DNS additional records.
+         * 
+         * \return The additional records in this PDU.
+         */
+        resources_type additional() const;
         
+        /**
+         * \brief Encodes a domain name.
+         *
+         * This processes the input domain name and returns the encoded 
+         * version. Each label in the original domain name will be 
+         * prefixed with a byte that indicates the label's length. 
+         * The null-terminator byte <b>will</b> be included in the encoded
+         * string. No compression is performed.
+         *
+         * For example, given the input "www.example.com", the output would
+         * be "\x03www\x07example\x03com\x00".
+         * 
+         * \param domain_name The domain name to encode.
+         * \return The encoded domain name.
+         */
+        static std::string encode_domain_name(const std::string &domain_name);
+
         /** 
          * \brief Check wether ptr points to a valid response for this PDU.
          *
@@ -591,17 +636,6 @@ namespace Tins {
         DNS *clone() const {
             return new DNS(*this);
         }
-        
-        /**
-         * Helper function to create a resource record information.
-         * 
-         * \param type The type of the query.
-         * \param qclass The class of the query.
-         * \param ttl The time-to-live of the query.
-         */
-        static DNSResourceRecord::info make_info(QueryType type, QueryClass qclass, uint32_t ttl) {
-            return DNSResourceRecord::info((uint16_t)type, (uint16_t)qclass, ttl);
-        }
     private:
         TINS_BEGIN_PACK
         struct dnshdr {
@@ -635,35 +669,23 @@ namespace Tins {
                      authority, additional;
         } TINS_END_PACK;
         
-        typedef std::map<uint16_t, std::string> SuffixMap;
-        typedef std::map<uint16_t, uint16_t> SuffixIndices;
-        typedef std::list<DNSResourceRecord> ResourcesType;
         typedef std::list<Query> QueriesType;
+        typedef std::vector<std::pair<uint32_t*, uint32_t> > sections_type;
         
-        const uint8_t *build_resource_list(ResourcesType &lst, const uint8_t *ptr, uint32_t &sz, uint16_t nrecs);
-        uint32_t find_domain_name(const std::string &dname);
-        bool find_domain_name(const std::string &dname, const ResourcesType &lst, uint16_t &out);
-        void parse_domain_name(const std::string &dn, std::string &out) const;
-        void unparse_domain_name(const std::string &dn, std::string &out) const;
-        void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
-        uint8_t *serialize_list(const ResourcesType &lst, uint8_t *buffer) const;
-        void compose_name(const uint8_t *ptr, uint32_t sz, std::string &out) const;
-        void convert_resources(const ResourcesType &lst, std::list<Resource> &res) const;
-        DNSResourceRecord make_record(const std::string &name, const DNSResourceRecord::info &info, uint32_t ip);
-        DNSResourceRecord make_record(const std::string &name, const DNSResourceRecord::info &info, const std::string &dname);
-        DNSResourceRecord make_record(const std::string &name, const DNSResourceRecord::info &info, const uint8_t *ptr, uint32_t len);
-        void add_suffix(uint32_t index, const uint8_t *data, uint32_t sz) const;
-        uint32_t build_suffix_map(uint32_t index, const ResourcesType &lst) const;
-        uint32_t build_suffix_map(uint32_t index, const QueriesType &lst) const;
-        void build_suffix_map() const ;
+        const uint8_t* compose_name(const uint8_t *ptr, char *out_ptr) const;
+        void convert_records(const uint8_t *ptr, const uint8_t *end, resources_type &res) const;
+        const uint8_t* find_section_end(const uint8_t *ptr, const uint32_t num_records) const;
+        const uint8_t* find_dname_end(const uint8_t *ptr) const;
+        void update_records(uint32_t &section_start, uint32_t num_records, uint32_t threshold, uint32_t offset);
+        uint8_t *update_dname(uint8_t *ptr, uint32_t threshold, uint32_t offset);
+        static void inline_convert_v4(uint32_t value, char *output);
         static bool contains_dname(uint16_t type);
+        void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
+        void add_record(const Resource &resource, const sections_type &sections);
         
         dnshdr dns;
-        uint32_t extra_size;
-        std::list<Query> queries_;
-        ResourcesType ans, arity, addit;
-        mutable SuffixMap suffixes;
-        mutable SuffixIndices suffix_indices;
+        byte_array records_data;
+        uint32_t answers_idx, authority_idx, additional_idx;
     };
 }
 

include/tins/dot11.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,7 +27,9 @@
  *
  */
 
-#ifndef TINS_DOT_11
+#include "config.h"
+
+#if !defined(TINS_DOT_11) && defined(HAVE_DOT11)
 #define TINS_DOT_11
 
 #include "dot11/dot11_base.h"

include/tins/dot11/CMakeLists.txt

@@ -0,0 +1,6 @@
+FILE(GLOB INCLUDE_FILES "*.h")
+INSTALL(
+    FILES ${INCLUDE_FILES} 
+    DESTINATION include/tins/dot11
+    COMPONENT Headers
+)

include/tins/dot11/dot11_assoc.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,7 +27,9 @@
  *
  */
 
-#ifndef TINS_DOT11_DOT11_ASSOC_H
+#include "../config.h"
+
+#if !defined(TINS_DOT11_DOT11_ASSOC_H) && defined(HAVE_DOT11)
 #define TINS_DOT11_DOT11_ASSOC_H
 
 #include "../dot11/dot11_mgmt.h"
@@ -617,4 +619,4 @@ private:
 };
 } // namespace Tins
 
-#endif // TINS_DOT11_DOT11_ASSOC_H
+#endif // TINS_DOT11_DOT11_ASSOC_H

include/tins/dot11/dot11_auth.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,7 +27,9 @@
  *
  */
 
-#ifndef TINS_DOT11_DOT11_AUTH_H
+#include "../config.h"
+
+#if !defined(TINS_DOT11_DOT11_AUTH_H) && defined(HAVE_DOT11)
 #define TINS_DOT11_DOT11_AUTH_H
 
 #include "../dot11/dot11_mgmt.h"
@@ -255,4 +257,4 @@ private:
 } // namespace Tins
 
 
-#endif // TINS_DOT11_DOT11_AUTH_H
+#endif // TINS_DOT11_DOT11_AUTH_H

include/tins/dot11/dot11_base.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,7 +27,9 @@
  *
  */ 
 
-#ifndef TINS_DOT11_DOT11_H
+#include "../config.h"
+
+#if !defined(TINS_DOT11_DOT11_H) && defined(HAVE_DOT11)
 #define TINS_DOT11_DOT11_H
 
 #include <list>
@@ -55,7 +57,7 @@ public:
     /**
      * \brief IEEE 802.11 options struct.
      */
-    typedef PDUOption<uint8_t> option;
+    typedef PDUOption<uint8_t, Dot11> option;
 
     /**
      * The type used to store tagged options.
@@ -72,6 +74,11 @@ public:
      */
     static const address_type BROADCAST;
 
+    /**
+     * The endianness used by Dot11.
+     */
+    static const endian_type endianness = LE;
+
     /**
      * \brief Enum for the different types of 802.11 frames.
      *

include/tins/dot11/dot11_beacon.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,7 +27,9 @@
  *
  */    
 
-#ifndef TINS_DOT11_DOT11_BEACON_H
+#include "../config.h"
+
+#if !defined(TINS_DOT11_DOT11_BEACON_H) && defined(HAVE_DOT11)
 #define TINS_DOT11_DOT11_BEACON_H
 
 #include "../dot11/dot11_mgmt.h"
@@ -161,4 +163,4 @@ namespace Tins {
     };
 } // namespace Tins
 
-#endif // TINS_DOT11_DOT11_BEACON_H
+#endif // TINS_DOT11_DOT11_BEACON_H

include/tins/dot11/dot11_control.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,7 +27,10 @@
  *
  */
 
-#ifndef TINS_DOT11_DOT11_CONTROL_H
+#include "../config.h"
+
+#if !defined(TINS_DOT11_DOT11_CONTROL_H) && defined(HAVE_DOT11)
+
 #define TINS_DOT11_DOT11_CONTROL_H
 
 #include "../dot11/dot11_base.h"

include/tins/dot11/dot11_data.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,7 +27,9 @@
  *
  */
 
-#ifndef TINS_DOT11_DOT11_DATA_H
+#include "../config.h"
+
+#if !defined(TINS_DOT11_DOT11_DATA_H) && defined(HAVE_DOT11)
 #define TINS_DOT11_DOT11_DATA_H
 
 #include "../dot11/dot11_base.h"

include/tins/dot11/dot11_mgmt.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,7 +27,10 @@
  *
  */
 
-#ifndef TINS_DOT11_DOT11_MGMT_H
+#include "../config.h"
+
+#if !defined(TINS_DOT11_DOT11_MGMT_H) && defined(HAVE_DOT11)
+
 #define TINS_DOT11_DOT11_MGMT_H
 
 #include <vector>
@@ -376,6 +379,8 @@ public:
           uint8_t hop_pattern, uint8_t hop_index) 
         : dwell_time(dwell_time), hop_set(hop_set), 
           hop_pattern(hop_pattern), hop_index(hop_index) {}
+
+        static fh_params_set from_option(const option &opt);
     };
     
     /**
@@ -392,6 +397,8 @@ public:
         : cfp_count(cfp_count), cfp_period(cfp_period), 
           cfp_max_duration(cfp_max_duration), 
           cfp_dur_remaining(cfp_dur_remaining) {}
+
+        static cf_params_set from_option(const option &opt);
     };
     
     /**
@@ -410,6 +417,8 @@ public:
           uint8_t recovery_interval, const channels_type &channels)
         : dfs_owner(addr), recovery_interval(recovery_interval),
           channel_map(channels) {}
+
+        static ibss_dfs_params from_option(const option &opt);
     };
     
     /**
@@ -428,6 +437,8 @@ public:
           const byte_array &number, const byte_array &max) 
         : country(country), first_channel(first), number_channels(number),
           max_transmit_power(max) {}
+
+        static country_params from_option(const option &opt);
     };
     
     /**
@@ -445,6 +456,8 @@ public:
           uint8_t offset, const byte_array& table) 
         : flag(flag), number_of_sets(sets), modulus(modulus), 
           offset(offset), random_table(table) {}
+
+        static fh_pattern_type from_option(const option &opt);
     };
     
     /**
@@ -457,6 +470,8 @@ public:
         
         channel_switch_type(uint8_t mode, uint8_t channel, uint8_t count)
         : switch_mode(mode), new_channel(channel), switch_count(count) { }
+
+        static channel_switch_type from_option(const option &opt);
     };
     
     /**
@@ -472,6 +487,8 @@ public:
           uint16_t offset)
         : quiet_count(count), quiet_period(period), 
         quiet_duration(duration), quiet_offset(offset) {}
+
+        static quiet_type from_option(const option &opt);
     };
 
     /**
@@ -488,6 +505,8 @@ public:
           uint16_t capacity) 
         : station_count(count), available_capacity(capacity),
         channel_utilization(utilization) {}
+
+        static bss_load_type from_option(const option &opt);
     };
     
     /**
@@ -503,6 +522,8 @@ public:
           const byte_array &bitmap) 
         : dtim_count(count), dtim_period(period), bitmap_control(control),
         partial_virtual_bitmap(bitmap) {}
+
+        static tim_type from_option(const option &opt);
     };
 
     /**
@@ -520,6 +541,11 @@ public:
 
         static vendor_specific_type from_bytes(const uint8_t *buffer, uint32_t sz);
     };
+    
+    /**
+     * The type used to store the QOS capability tagged option data.
+     */
+    typedef uint8_t qos_capability_type;
 
     /**
      * \brief Getter for the second address.
@@ -638,7 +664,7 @@ public:
      *
      * \param new_qos_capabilities uint8_t with the capabilities.
      */
-    void qos_capability(uint8_t new_qos_capability);
+    void qos_capability(qos_capability_type new_qos_capability);
 
     /**
      * \brief Helper method to set the power capabilities option.
@@ -848,7 +874,7 @@ public:
      * 
      * \return uint8_t containing the QOS capability.
      */
-    uint8_t qos_capability() const;
+    qos_capability_type qos_capability() const;
 
     /**
      * \brief Helper method to get the power capability.
@@ -1117,6 +1143,14 @@ protected:
 private:
     static uint8_t *serialize_rates(const rates_type &rates);
     static rates_type deserialize_rates(const option *option);
+    
+    template<typename T>
+    T search_and_convert(OptionTypes opt_type) const {
+        const option *opt = search_option(opt_type);
+        if(!opt)
+            throw option_not_found();
+        return opt->to<T>();
+    }
 
     ExtendedHeader _ext_header;
     address_type _addr4;

include/tins/dot11/dot11_probe.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,7 +27,10 @@
  *
  */
 
-#ifndef TINS_DOT11_DOT11_PROBE_H
+#include "../config.h"
+
+#if !defined(TINS_DOT11_DOT11_PROBE_H) && defined(HAVE_DOT11)
+
 #define TINS_DOT11_DOT11_PROBE_H
 
 #include "../dot11/dot11_mgmt.h"
@@ -227,4 +230,4 @@ private:
     uint32_t write_fixed_parameters(uint8_t *buffer, uint32_t total_sz);
 };
 } // namespace Tins
-#endif // TINS_DOT11_DOT11_PROBE_H
+#endif // TINS_DOT11_DOT11_PROBE_H

include/tins/dot1q.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -36,6 +36,7 @@
 
 namespace Tins {
 /**
+ * \class Dot1Q
  * Represents an IEEE 802.1q PDU.
  */
 class Dot1Q : public PDU {

include/tins/dot3.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -39,7 +39,8 @@
 namespace Tins {
 
     /** 
-     * \brief Class representing an Ethernet II PDU.
+     * \class Dot3
+     * \brief Class representing an IEEE 802.3 PDU.
      */
     class Dot3 : public PDU {
     public:

include/tins/eapol.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -46,7 +46,8 @@ namespace Tins {
     /** \endcond */
     
     /**
-     * \brief Class that represents the EAP encapsulation over LAN.
+     * \class EAPOL
+     * \brief Represents the EAP encapsulation over LAN.
      */
     class EAPOL : public PDU {
     public:

include/tins/endianness.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -55,6 +55,16 @@
 
 namespace Tins {
 namespace Endian {
+    /** 
+     * \brief "Changes" a 8-bit integral value's endianess. This is an
+     * identity function.
+     *
+     * \param data The data to convert.
+     */
+    inline uint8_t do_change_endian(uint8_t data) {
+        return data;
+    }
+    
     /** 
      * \brief Changes a 16-bit integral value's endianess.
      *
@@ -100,6 +110,11 @@ namespace Endian {
     template<size_t>
     struct conversion_dispatcher;
     
+    template<>
+    struct conversion_dispatcher<sizeof(uint8_t)> 
+    : public conversion_dispatch_helper<uint8_t> 
+    { };
+    
     template<>
     struct conversion_dispatcher<sizeof(uint16_t)> 
     : public conversion_dispatch_helper<uint16_t> 

include/tins/ethernetII.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -39,7 +39,8 @@
 namespace Tins {
 
     /**
-     * \brief Class representing an Ethernet II PDU.
+     * \class EthernetII
+     * \brief Represents an Ethernet II PDU.
      */
     class EthernetII : public PDU {
     public:

include/tins/exceptions.h

@@ -1,18 +1,18 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
- * 
+ *
  * * Redistributions of source code must retain the above copyright
  *   notice, this list of conditions and the following disclaimer.
  * * Redistributions in binary form must reproduce the above
  *   copyright notice, this list of conditions and the following disclaimer
  *   in the documentation and/or other materials provided with the
  *   distribution.
- * 
+ *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
@@ -30,6 +30,7 @@
 #ifndef TINS_EXCEPTIONS_H
 #define TINS_EXCEPTIONS_H
 
+#include <string>
 #include <stdexcept>
 
 namespace Tins {
@@ -54,7 +55,7 @@ class malformed_packet : public std::runtime_error {
 public:
     malformed_packet()
     : std::runtime_error(std::string()) { }
-    
+
     const char* what() const throw() {
         return "Malformed packet";
     }
@@ -67,7 +68,7 @@ class pdu_not_found : public std::runtime_error {
 public:
     pdu_not_found()
     : std::runtime_error(std::string()) { }
-    
+
     const char* what() const throw() {
         return "PDU not found";
     }
@@ -81,18 +82,30 @@ class invalid_interface : public std::runtime_error {
 public:
     invalid_interface()
     : std::runtime_error(std::string()) { }
-    
+
     const char* what() const throw() {
         return "Invalid interface";
     }
 };
 
+/**
+ * \brief Exception thrown when a field is not present in frame.
+ */
+class field_not_present : public std::runtime_error {
+public:
+    field_not_present()
+    : std::runtime_error(std::string()) { }
+    const char* what() const throw() {
+        return "Field not present";
+    }
+};
+
 /**
  * \brief Exception thrown when PacketSender fails to open a socket.
  */
 class socket_open_error : public std::runtime_error {
 public:
-    socket_open_error(const std::string &msg) 
+    socket_open_error(const std::string &msg)
     : std::runtime_error(msg) { }
 };
 
@@ -101,7 +114,7 @@ public:
  */
 class socket_close_error : public std::runtime_error {
 public:
-    socket_close_error(const std::string &msg) 
+    socket_close_error(const std::string &msg)
     : std::runtime_error(msg) { }
 };
 
@@ -110,7 +123,7 @@ public:
  */
 class socket_write_error : public std::runtime_error {
 public:
-    socket_write_error(const std::string &msg) 
+    socket_write_error(const std::string &msg)
     : std::runtime_error(msg) { }
 };
 
@@ -126,7 +139,7 @@ public:
 };
 
 /**
- * \brief Exception thrown when an unkown link layer PDU type is 
+ * \brief Exception thrown when an unkown link layer PDU type is
  * found while sniffing.
  */
 class unknown_link_type : public std::exception {
@@ -145,6 +158,28 @@ public:
         return "Malformed option";
     }
 };
-}
+
+/**
+ * \brief Exception thrown when a call to tins_cast fails.
+ */
+class bad_tins_cast : public std::exception {
+public:
+    const char *what() const throw() {
+        return "Bad Tins cast";
+    }
+};
+
+/**
+ * \brief Exception thrown when sniffing a protocol that
+ * has been disabled at compile time.
+ */
+class protocol_disabled : public std::exception {
+public:
+    const char *what() const throw() {
+        return "Protocol disabled";
+    }
+};
+
+} // Tins
 
 #endif // TINS_EXCEPTIONS_H

include/tins/handshake_capturer.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,7 +27,9 @@
  *
  */
 
-#ifndef TINS_HANDSHAKE_CAPTURER_H
+#include "config.h"
+
+#if !defined(TINS_HANDSHAKE_CAPTURER_H)  && defined(HAVE_DOT11)
 #define TINS_HANDSHAKE_CAPTURER_H
 
 #include <vector>
@@ -164,4 +166,4 @@ namespace Tins {
     };
 }
 
-#endif // TINS_HANDSHAKE_CAPTURER_H
+#endif // TINS_HANDSHAKE_CAPTURER_H

include/tins/hw_address.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -43,6 +43,22 @@ namespace Tins {
 /**
  * \class HWAddress
  * \brief Represents a hardware address.
+ *
+ * This class represents a hardware (MAC) address. It can 
+ * be constructed from it's string representation and you can
+ * iterate over the bytes that compose it.
+ *
+ * For example:
+ *
+ * \code
+ * // Construct it from a string.
+ * HWAddress<6> address("00:01:fa:9e:1a:cd");
+ *
+ * // Iterate over its bytes.
+ * for(auto element : address) {
+ *     // element will be each of the bytes(\x00, \x01, \xfa, etc)
+ * }
+ * \endcode
  */
 template<size_t n, typename Storage = uint8_t>
 class HWAddress {
@@ -79,7 +95,8 @@ public:
      * \brief Constructor from a const storage_type*.
      * 
      * If no pointer or a null pointer is provided, the address is 
-     * initialized to 00:00:..... 
+     * initialized to 00:00:00:00:00:00.
+     * 
      * This constructor is very usefull when passing zero initialized
      * addresses as arguments to other functions. You can use a 
      * literal 0, which will be implicitly converted to the empty address.

include/tins/icmp.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,13 +30,28 @@
 #ifndef TINS_ICMP_H
 #define TINS_ICMP_H
 
+// Windows likes to define macros with not-so-common-names, which break
+// this code
+#ifdef WIN32
+    #ifdef TIMESTAMP_REQUEST
+        #undef TIMESTAMP_REQUEST
+    #endif // TIMESTAMP_REQUEST
+
+    #ifdef TIMESTAMP_REPLY
+        #undef TIMESTAMP_REPLY
+    #endif // TIMESTAMP_REPLY
+#endif // WIN32
+
 #include "macros.h"
 #include "pdu.h"
 #include "endianness.h"
+#include "ip_address.h"
 
 namespace Tins {
 
-    /** \brief Class that represents an ICMP PDU.
+    /** 
+     * \class ICMP
+     * \brief Class that represents an ICMP PDU.
      *
      * ICMP is the representation of the ICMP PDU. Instances of this class
      * must be sent over a level 3 PDU, this will otherwise fail.
@@ -48,6 +63,11 @@ namespace Tins {
          */
         static const PDU::PDUType pdu_flag = PDU::ICMP;
     
+        /**
+         * The type used to store addresses.
+         */
+        typedef IPv4Address address_type;
+
         /** \brief ICMP flags
          */
         enum Flags {
@@ -58,8 +78,12 @@ namespace Tins {
             ECHO_REQUEST     = 8,
             TIME_EXCEEDED    = 11,
             PARAM_PROBLEM    = 12,
+            TIMESTAMP_REQUEST = 13,
+            TIMESTAMP_REPLY  = 14,
             INFO_REQUEST     = 15,
-            INFO_REPLY       = 16
+            INFO_REPLY       = 16,
+            ADDRESS_MASK_REQUEST = 17,
+            ADDRESS_MASK_REPLY = 18
         };
 
         /**
@@ -113,9 +137,9 @@ namespace Tins {
         /**
          * \brief Setter for the gateway field.
          *
-         * \param new_gw uint32_t with the new gateway.
+         * \param new_gw The new value for the gateway field.
          */
-        void gateway(uint32_t new_gw);
+        void gateway(address_type new_gw);
 
         /**
          * \brief Setter for the mtu field.
@@ -131,6 +155,34 @@ namespace Tins {
          */
         void pointer(uint8_t new_pointer);
 
+        /**
+         * \brief Setter for the original timestamp field.
+         *
+         * \param new_timestamp the value to be set.
+         */
+        void original_timestamp(uint32_t new_timestamp);
+
+        /**
+         * \brief Setter for the receive timestamp field.
+         *
+         * \param new_timestamp the value to be set.
+         */
+        void receive_timestamp(uint32_t new_timestamp);
+
+        /**
+         * \brief Setter for the transmit timestamp field.
+         *
+         * \param new_timestamp the value to be set.
+         */
+        void transmit_timestamp(uint32_t new_timestamp);
+
+        /**
+         * \brief Setter for the address mask field.
+         *
+         * \param new_mask the value to be set.
+         */
+        void address_mask(address_type new_mask);
+
         /**
          * \brief Sets echo request flag for this PDU.
          *
@@ -199,7 +251,7 @@ namespace Tins {
          * \param address Address of the gateway to which traffic should
          * be sent.
          */
-        void set_redirect(uint8_t icode, uint32_t address);
+        void set_redirect(uint8_t icode, address_type address);
 
         /**
          * \brief Getter for the ICMP type flag.
@@ -220,7 +272,7 @@ namespace Tins {
          *
          * \return Returns the checksum as an unit16_t.
          */
-        uint16_t check() const { return Endian::be_to_host(_icmp.check); }
+        uint16_t checksum() const { return Endian::be_to_host(_icmp.check); }
 
         /**
          * \brief Getter for the echo id.
@@ -239,24 +291,56 @@ namespace Tins {
         /**
          * \brief Getter for the gateway field.
          *
-         * \return Returns the gateways in an unit32_t.
+         * \return Returns the gateway field value.
          */
-         uint32_t gateway() const { return Endian::be_to_host(_icmp.un.gateway); }
+        address_type gateway() const { 
+            return address_type(Endian::be_to_host(_icmp.un.gateway)); 
+        }
 
          /**
           * \brief Getter for the pointer field.
           *
-          * \return Returns the pointer value.
+          * \return Returns the pointer field value.
           */
         uint8_t pointer() const { return this->_icmp.un.pointer; }
         
         /**
           * \brief Getter for the mtu field.
           *
-          * \return Returns the mtu value in an uint16_t.
+          * \return Returns the mtu field value.
           */
         uint16_t mtu() const { return Endian::be_to_host(_icmp.un.frag.mtu); }
 
+        /**
+          * \brief Getter for the original timestamp field.
+          *
+          * \return Returns the original timestamp value.
+          */
+        uint32_t original_timestamp() const { return Endian::be_to_host(_orig_timestamp_or_address_mask); }
+
+        /**
+          * \brief Getter for the receive timestamp field.
+          *
+          * \return Returns the receive timestamp value.
+          */
+        uint32_t receive_timestamp() const { return Endian::be_to_host(_recv_timestamp); }
+
+        /**
+          * \brief Getter for the transmit timestamp field.
+          *
+          * \return Returns the transmit timestamp value.
+          */
+        uint32_t transmit_timestamp() const { return Endian::be_to_host(_trans_timestamp); }
+
+        /**
+          * \brief Getter for the address mask field.
+          *
+          * \return Returns the address mask value.
+          */
+        address_type address_mask() const { 
+            return address_type(Endian::be_to_host(_orig_timestamp_or_address_mask)); 
+        }
+
         /**
          * \brief Returns the header size.
          *
@@ -307,7 +391,7 @@ namespace Tins {
             } un;
         } TINS_END_PACK;
 
-        void check(uint16_t new_check);
+        void checksum(uint16_t new_check);
         
         /** \brief Serialices this ICMP PDU.
          * \param buffer The buffer in which the PDU will be serialized.
@@ -317,6 +401,7 @@ namespace Tins {
         void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
 
         icmphdr _icmp;
+        uint32_t _orig_timestamp_or_address_mask, _recv_timestamp, _trans_timestamp;
     };
 }
 

include/tins/icmpv6.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -44,7 +44,8 @@
 
 namespace Tins {
 /**
- * Represents an ICMPv6 PDU.
+ * \class ICMPv6
+ * \brief Represents an ICMPv6 PDU.
  */
 class ICMPv6 : public PDU {
 public:
@@ -135,7 +136,7 @@ public:
     /**
      * The type used to represent ICMPv6 options.
      */
-    typedef PDUOption<uint8_t> option;
+    typedef PDUOption<uint8_t, ICMPv6> option;
     
     /**
      * The type used to store options.
@@ -145,30 +146,53 @@ public:
     /**
      * \brief The type used to store the new home agent information 
      * option data.
-     * 
-     * The first member contains the home agent preference field, while
-     * the second one contains the home agent lifetime.
      */
-    typedef std::pair<uint16_t, uint16_t> new_ha_info_type;
+    typedef std::vector<uint16_t> new_ha_info_type;
     
     /**
      * The type used to store the source/target address list options.
      */
-    typedef std::vector<ipaddress_type> addr_list_type;
+    struct addr_list_type {
+        typedef std::vector<ipaddress_type> addresses_type;
+        
+        uint8_t reserved[6];
+        addresses_type addresses;
+        
+        addr_list_type(const addresses_type &addresses = addresses_type())
+        : addresses(addresses) 
+        {
+            std::fill(reserved, reserved + sizeof(reserved), 0);
+        }
+        
+        static addr_list_type from_option(const option &opt);
+    };
     
     /**
      * The type used to store the nonce option data.
      */
     typedef std::vector<uint8_t> nonce_type;
     
+    /**
+     * The type used to store the MTU option.
+     */
+    typedef std::pair<uint16_t, uint32_t> mtu_type;
+    
     /**
      * \brief The type used to store the neighbour advertisement 
      * acknowledgement option data.
-     * 
-     * The first member contains the option code field, while
-     * the second one contains the status.
      */
-    typedef std::pair<uint8_t, uint8_t> naack_type;
+    struct naack_type {
+        uint8_t code, status;
+        uint8_t reserved[4];
+        
+        naack_type(uint8_t code = 0, uint8_t status = 0)
+        : code(code), status(status)
+        {
+            std::fill(reserved, reserved + 4, 0);
+        }
+        
+        static naack_type from_option(const option &opt);
+    };
     
     /**
      * \brief The type used to store the link layer address option data.
@@ -207,6 +231,8 @@ public:
         {
             
         }
+        
+        static lladdr_type from_option(const option &opt);
     };
     
     /**
@@ -226,6 +252,8 @@ public:
         : prefix_len(prefix_len), A(A), L(L), 
           valid_lifetime(valid_lifetime), preferred_lifetime(preferred_lifetime),
           prefix(prefix) { }
+          
+        static prefix_info_type from_option(const option &opt);
     };
     
     /**
@@ -290,6 +318,8 @@ public:
         {
             std::fill(key_hash, key_hash + sizeof(key_hash), 0);
         }
+
+        static rsa_sign_type from_option(const option &opt);
     };
     
     /**
@@ -303,6 +333,8 @@ public:
           const ipaddress_type &address = ipaddress_type())
         : option_code(option_code), prefix_len(prefix_len), address(address)
         {}
+
+        static ip_prefix_type from_option(const option &opt);
     };
     
     /**
@@ -319,6 +351,8 @@ public:
           const ipaddress_type &address = ipaddress_type())
         : dist(dist), pref(pref), r(r), valid_lifetime(valid_lifetime),
           address(address) { }
+
+        static map_type from_option(const option &opt);
     };
     
     /**
@@ -336,6 +370,8 @@ public:
           uint32_t route_lifetime = 0, const prefix_type &prefix = prefix_type())
         : prefix_len(prefix_len), pref(pref), route_lifetime(route_lifetime),
           prefix(prefix) { }
+
+        static route_info_type from_option(const option &opt);
     };
     
     /**
@@ -350,6 +386,8 @@ public:
         recursive_dns_type(uint32_t lifetime = 0, 
           const servers_type &servers = servers_type())
         : lifetime(lifetime), servers(servers) {}
+
+        static recursive_dns_type from_option(const option &opt);
     };
     
     /**
@@ -364,6 +402,8 @@ public:
         handover_key_req_type(small_uint<4> AT = 0,
           const key_type &key = key_type())
         : AT(AT), key(key) { }
+
+        static handover_key_req_type from_option(const option &opt);
     };
     
     /**
@@ -375,6 +415,8 @@ public:
         handover_key_reply_type(uint16_t lifetime = 0, small_uint<4> AT = 0,
           const key_type &key = key_type())
         : handover_key_req_type(AT, key), lifetime(lifetime) { }
+
+        static handover_key_reply_type from_option(const option &opt);
     };
     
     /**
@@ -389,6 +431,8 @@ public:
         handover_assist_info_type(uint8_t option_code=0, 
           const hai_type &hai = hai_type())
         : option_code(option_code), hai(hai) { }
+
+        static handover_assist_info_type from_option(const option &opt);
     };
     
     /**
@@ -403,6 +447,8 @@ public:
         mobile_node_id_type(uint8_t option_code=0, 
           const mn_type &mn = mn_type())
         : option_code(option_code), mn(mn) { }
+
+        static mobile_node_id_type from_option(const option &opt);
     };
     
     /**
@@ -417,8 +463,58 @@ public:
         dns_search_list_type(uint32_t lifetime = 0,
           const domains_type &domains = domains_type())
         : lifetime(lifetime), domains(domains) { }
+
+        static dns_search_list_type from_option(const option &opt);
     };
-    
+
+    /**
+     * The type used to store the timestamp option.
+     */
+    struct timestamp_type {
+        uint8_t reserved[6];
+        uint64_t timestamp;
+
+        timestamp_type(uint64_t timestamp = 0)
+        : timestamp(timestamp)
+        {
+            std::fill(reserved, reserved + sizeof(reserved), 0);
+        }
+
+        static timestamp_type from_option(const option &opt);
+    };
+
+    /**
+     * The type used to store the shortcut limit option.
+     */
+    struct shortcut_limit_type {
+        uint8_t limit, reserved1;
+        uint32_t reserved2;
+
+        shortcut_limit_type(uint8_t limit = 0)
+        : limit(limit), reserved1(), reserved2()
+        {
+
+        }
+
+        static shortcut_limit_type from_option(const option &opt);
+    };
+
+    /**
+     * The type used to store new advertisement interval option.
+     */
+    struct new_advert_interval_type {
+        uint16_t reserved;
+        uint32_t interval;
+
+        new_advert_interval_type(uint32_t interval = 0)
+        : reserved(), interval(interval)
+        {
+
+        }
+
+        static new_advert_interval_type from_option(const option &opt);
+    };
+
     /**
      * \brief Constructs an ICMPv6 object.
      * 
@@ -820,33 +916,30 @@ public:
     /**
      * \brief Setter for the redirect header option.
      * 
-     * This method appends the 6 reserved bytes and inserts the 
-     * necessary padding at the end.
-     * 
      * \param data The redirect header option data.
      */
-    void redirect_header(PDU::serialization_type data);
+    void redirect_header(const byte_array &data);
     
     /**
      * \brief Setter for the MTU option.
      * 
      * \param value The MTU option data.
      */
-    void mtu(uint32_t value);
+    void mtu(const mtu_type& value);
     
     /**
      * \brief Setter for the shortcut limit option.
      * 
      * \param value The shortcut limit option data.
      */
-    void shortcut_limit(uint8_t value);
+    void shortcut_limit(const shortcut_limit_type& value);
     
     /**
      * \brief Setter for the new advertisement interval option.
      * 
      * \param value The new advertisement interval option data.
      */
-    void new_advert_interval(uint32_t value);
+    void new_advert_interval(const new_advert_interval_type &value);
     
     /**
      * \brief Setter for the new home agent information option.
@@ -881,7 +974,7 @@ public:
      * 
      * \param value The new timestamp option data.
      */
-    void timestamp(uint64_t value);
+    void timestamp(const timestamp_type &value);
     
     /**
      * \brief Setter for the new nonce option.
@@ -1001,7 +1094,7 @@ public:
      * This method will throw an option_not_found exception if the
      * option is not found.
      */
-    PDU::serialization_type redirect_header() const;
+    byte_array redirect_header() const;
     
     /**
      * \brief Getter for the MTU option.
@@ -1009,7 +1102,7 @@ public:
      * This method will throw an option_not_found exception if the
      * option is not found.
      */
-    uint32_t mtu() const;
+    mtu_type mtu() const;
     
     /**
      * \brief Getter for the shortcut limit option.
@@ -1017,7 +1110,7 @@ public:
      * This method will throw an option_not_found exception if the
      * option is not found.
      */
-    uint8_t shortcut_limit() const;
+    shortcut_limit_type shortcut_limit() const;
     
     /**
      * \brief Getter for the new advertisement interval option.
@@ -1025,7 +1118,7 @@ public:
      * This method will throw an option_not_found exception if the
      * option is not found.
      */
-    uint32_t new_advert_interval() const;
+    new_advert_interval_type new_advert_interval() const;
     
     /**
      * \brief Getter for the new home agent information option.
@@ -1065,7 +1158,7 @@ public:
      * This method will throw an option_not_found exception if the
      * option is not found.
      */
-    uint64_t timestamp() const;
+    timestamp_type timestamp() const;
     
     /**
      * \brief Getter for the nonce option.
@@ -1225,6 +1318,14 @@ private:
         return option;
     }
 
+    template<typename T>
+    T search_and_convert(OptionTypes type) const {
+        const option *opt = search_option(type);
+        if(!opt)
+            throw option_not_found();
+        return opt->to<T>();
+    }
+
     icmp6hdr _header;
     ipaddress_type _target_address, _dest_address;
     options_type _options;

include/tins/ieee802_3.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without

include/tins/internals.h

@@ -1,18 +1,18 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
- * 
+ *
  * * Redistributions of source code must retain the above copyright
  *   notice, this list of conditions and the following disclaimer.
  * * Redistributions in binary form must reproduce the above
  *   copyright notice, this list of conditions and the following disclaimer
  *   in the documentation and/or other materials provided with the
  *   distribution.
- * 
+ *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
@@ -26,10 +26,14 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  */
- 
+
 #ifndef TINS_INTERNALS_H
 #define TINS_INTERNALS_H
 
+#if TINS_IS_CXX11
+#include <type_traits>
+#endif
+
 #include <sstream>
 #include <string>
 #include <stdint.h>
@@ -50,16 +54,16 @@ class byte_array {
 public:
     typedef uint8_t* iterator;
     typedef const uint8_t* const_iterator;
-    
+
     byte_array() {
         std::fill(begin(), end(), 0);
     }
-    
+
     template<typename InputIterator>
     byte_array(InputIterator start, InputIterator last) {
-        std::copy(start, end, data);
+        std::copy(start, last, data);
     }
-    
+
     template<typename InputIterator>
     byte_array(InputIterator start) {
         std::copy(start, n, data);
@@ -72,23 +76,23 @@ public:
     uint8_t operator[](size_t i) const{
         return data[i];
     }
-    
+
     iterator begin() {
         return data;
     }
-    
+
     iterator end() {
         return data + n;
     }
-    
+
     const_iterator begin() const {
         return data;
     }
-    
+
     const_iterator end() const {
         return data + n;
     }
-    
+
     size_t size() const {
         return n;
     }
@@ -99,22 +103,26 @@ private:
 void skip_line(std::istream &input);
 bool from_hex(const std::string &str, uint32_t &result);
 
-template<bool, typename>
+template<bool, typename T = void>
 struct enable_if {
-    
-};
-
-template<typename T>
-struct enable_if<true, T> {
     typedef T type;
 };
 
-PDU *pdu_from_flag(Constants::Ethernet::e flag, const uint8_t *buffer, 
-  uint32_t size, bool rawpdu_on_no_match = true);
+template<typename T>
+struct enable_if<false, T> {
 
+};
+
+PDU *pdu_from_flag(Constants::Ethernet::e flag, const uint8_t *buffer,
+  uint32_t size, bool rawpdu_on_no_match = true);
+PDU *pdu_from_flag(Constants::IP::e flag, const uint8_t *buffer,
+  uint32_t size, bool rawpdu_on_no_match = true);
+PDU *pdu_from_dlt_flag(int flag, const uint8_t *buffer,
+  uint32_t size, bool rawpdu_on_no_match = true);
 PDU *pdu_from_flag(PDU::PDUType type, const uint8_t *buffer, uint32_t size);
 
 Constants::Ethernet::e pdu_flag_to_ether_type(PDU::PDUType flag);
+Constants::IP::e pdu_flag_to_ip_type(PDU::PDUType flag);
 
 template<typename T>
 bool increment_buffer(T &addr) {
@@ -171,6 +179,64 @@ HWAddress<n> last_address_from_mask(HWAddress<n> addr, const HWAddress<n> &mask)
 inline bool is_dot3(const uint8_t *ptr, size_t sz) {
     return (sz >= 13 && ptr[12] < 8);
 }
+
+template<typename T>
+struct is_unsigned_integral {
+    static const bool value = false;
+};
+
+template<>
+struct is_unsigned_integral<uint8_t> {
+    static const bool value = true;
+};
+
+template<>
+struct is_unsigned_integral<uint16_t> {
+    static const bool value = true;
+};
+
+template<>
+struct is_unsigned_integral<uint32_t> {
+    static const bool value = true;
+};
+
+template<>
+struct is_unsigned_integral<uint64_t> {
+    static const bool value = true;
+};
+
+#if TINS_IS_CXX11
+
+// Part of C++14 standard library
+template<bool B, class T = void>
+using enable_if_t = typename std::enable_if<B,T>::type;
+
+// Template metaprogramming trait to determine if a functor can accept another parameter as an argument
+template <class T, class P, class=void>
+struct accepts_type : std::false_type { };
+
+template <class T, class P>
+struct accepts_type<T, P, enable_if_t<
+  std::is_same<  decltype(  std::declval<T>()(std::declval<P>())  ), bool>::value
+>> : std::true_type { };
+
+// use enable_if to invoke the Packet&& version of the sniff_loop handler if possible - otherwise fail to old behavior
+template <class Functor, class Packet>
+bool invoke_loop_cb(Functor& f, Packet& p, typename std::enable_if<accepts_type<Functor, Packet>::value, bool>::type* = 0) {
+  return f(std::move(p));
+}
+
+template <class Functor, class Packet>
+bool invoke_loop_cb(Functor& f, Packet& p, typename std::enable_if<!accepts_type<Functor, Packet>::value && accepts_type<Functor, Packet&>::value, bool>::type* = 0) {
+  return f(p);
+}
+
+template <class Functor, class Packet>
+bool invoke_loop_cb(Functor& f, Packet& p, typename std::enable_if<!accepts_type<Functor, Packet>::value && !accepts_type<Functor, Packet&>::value, bool>::type* = 0) {
+  return f(*p.pdu());
+}
+#endif
+
 } // namespace Internals
 } // namespace Tins
 /**

include/tins/ip.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -42,6 +42,7 @@
 namespace Tins {
 
     /**
+     * \class IP
      * \brief Class that represents an IP PDU.
      * 
      * By default, IP PDUs are initialized, setting TTL to IP::DEFAULT_TTL,
@@ -169,7 +170,7 @@ namespace Tins {
         /**
          * The IP options type.
          */
-        typedef PDUOption<option_identifier> option;
+        typedef PDUOption<option_identifier, IP> option;
 
         /**
          * The type of the security option.
@@ -184,6 +185,8 @@ namespace Tins {
             : security(sec), compartments(comp), 
               handling_restrictions(hand_res), transmission_control(tcc) 
               {}
+            
+            static security_type from_option(const option &opt);
         };
         
         /**
@@ -198,6 +201,8 @@ namespace Tins {
             generic_route_option_type(uint8_t ptr = 0, 
               routes_type rts = routes_type())
             : pointer(ptr), routes(rts) {}
+            
+            static generic_route_option_type from_option(const option &opt);
         };
         
         /**
@@ -364,6 +369,17 @@ namespace Tins {
         /**
          * \brief Setter for the protocol field.
          *
+         * Note that this protocol will be overwritten using the 
+         * inner_pdu's protocol type during serialization unless the IP 
+         * datagram is fragmented. 
+         * 
+         * If the packet is fragmented and was originally sniffed, the
+         * original protocol type will be kept when serialized.
+         * 
+         * If this packet has been crafted manually and the inner_pdu
+         * is, for example, a RawPDU, then setting the protocol yourself
+         * is necessary.
+         * 
          * \param new_protocol The new protocol.
          */
         void protocol(uint8_t new_protocol);
@@ -411,6 +427,20 @@ namespace Tins {
                 internal_add_option(opt);
                 _ip_options.push_back(std::move(opt));
             }
+
+            /**
+             * \brief Adds an IP option.
+             * 
+             * The option is constructed from the provided parameters.
+             * 
+             * \param args The arguments to be used in the option's 
+             * constructor.
+             */
+            template<typename... Args>
+            void add_option(Args&&... args) {
+                _ip_options.emplace_back(std::forward<Args>(args)...);
+                internal_add_option(_ip_options.back());
+            }
         #endif
 
         /**
@@ -568,6 +598,13 @@ namespace Tins {
          */
         PDU *recv_response(PacketSender &sender, const NetworkInterface &);
 
+        /**
+         * Indicates whether this PDU is fragmented.
+         *
+         * \return true if this PDU is fragmented, false otherwise.
+         */
+        bool is_fragmented() const;
+
         /**
          * \brief Getter for the PDU's type.
          * \sa PDU::pdu_type

include/tins/ip_address.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -177,7 +177,7 @@ public:
      */
     friend std::ostream &operator<<(std::ostream &output, const IPv4Address &addr);
 private:
-    uint32_t ip_to_int(const std::string &ip);
+    uint32_t ip_to_int(const char* ip);
 
     uint32_t ip_addr;
 };

include/tins/ip_reassembler.h

@@ -0,0 +1,216 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_IP_REASSEMBLER_H
+#define TINS_IP_REASSEMBLER_H
+
+#include <vector>
+#include <map>
+#include "pdu.h"
+#include "ip_address.h"
+
+namespace Tins {
+/** 
+ * \cond
+ */
+class IP;
+namespace Internals {
+class IPv4Fragment {
+public:
+    typedef PDU::serialization_type payload_type;
+
+    IPv4Fragment() : offset_() { }
+
+    template<typename T>
+    IPv4Fragment(T *pdu, uint16_t offset)
+    : payload_(pdu->serialize()), offset_(offset) 
+    {
+        
+    }
+    
+    const payload_type &payload() const {
+        return payload_;
+    }
+    
+    uint16_t offset() const {
+        return offset_;
+    }
+private:
+    payload_type payload_;
+    uint16_t offset_;
+};
+
+class IPv4Stream {
+public:
+    IPv4Stream();
+    
+    void add_fragment(IP *ip);
+    bool is_complete() const;
+    PDU *allocate_pdu() const;
+private:
+    typedef std::vector<IPv4Fragment> fragments_type;
+    
+    uint16_t extract_offset(const IP *ip);
+    bool extract_more_frag(const IP *ip);
+
+    fragments_type fragments;
+    bool received_end;
+    uint8_t transport_proto;
+    size_t received_size, total_size;
+};
+} // namespace Internals
+
+/** 
+ * \endcond
+ */
+
+/**
+ * \brief Reassembles fragmented IP packets.
+ */
+class IPv4Reassembler {
+public:
+    /**
+     * The status of each processed packet.
+     */
+    enum packet_status {
+        NOT_FRAGMENTED,
+        FRAGMENTED,
+        REASSEMBLED
+    };
+
+    /**
+     * The type used to represent the overlapped segment 
+     * reassembly technique to be used.
+     */
+    enum overlapping_technique {
+        NONE
+    };
+
+    /**
+     * Constructs an IPV4Reassembler.
+     * \param technique The technique to be used for reassembling
+     * overlapped fragments.
+     */
+    IPv4Reassembler(overlapping_technique technique = NONE);
+
+    /**
+     * \brief Processes a PDU and tries to reassemble it.
+     *
+     * This method tries to reassemble the provided packet. If
+     * the packet is successfully reassembled using previously
+     * processed packets, its contents will be modified so that
+     * it contains the whole payload and not just a fragment.
+     * 
+     * \param pdu The PDU to process.
+     * \return NOT_FRAGMENTED if the PDU does not contain an IP
+     * layer or is not fragmented, FRAGMENTED if the packet is 
+     * fragmented or REASSEMBLED if the packet was fragmented 
+     * but has now been reassembled.
+     */
+    packet_status process(PDU &pdu);
+
+    /**
+     * Removes all of the packets and data stored.
+     */
+    void clear_streams();
+
+    /**
+     * \brief Removes all of the packets and data stored that 
+     * belongs to IP headers whose identifier, source and destination
+     * addresses are equal to the provided parameters.
+     * 
+     * \param id The idenfier to search.
+     * \param addr1 The source address to search.
+     * \param addr2 The destinatin address to search.
+     * \sa IP::id
+     */
+    void remove_stream(uint16_t id, IPv4Address addr1, IPv4Address addr2);
+private:
+    typedef std::pair<IPv4Address, IPv4Address> address_pair;
+    typedef std::pair<uint16_t, address_pair> key_type;
+    typedef std::map<key_type, Internals::IPv4Stream> streams_type;
+
+    key_type make_key(const IP *ip) const;
+    address_pair make_address_pair(IPv4Address addr1, IPv4Address addr2) const;
+    
+    streams_type streams;
+    overlapping_technique technique;
+};
+
+/**
+ * Proxy functor class that reassembles PDUs.
+ */
+template<typename Functor>
+class IPv4ReassemblerProxy {
+public:
+    /**
+     * Constructs the proxy from a functor object.
+     *
+     * \param func The functor object.
+     */
+    IPv4ReassemblerProxy(Functor func)
+    : functor_(func)
+    {
+
+    }
+
+    /**
+     * \brief Tries to reassemble the packet and forwards it to 
+     * the functor.
+     * 
+     * \param pdu The packet to process
+     * \return true if the packet wasn't forwarded, otherwise
+     * the value returned by the functor.
+     */
+    bool operator()(PDU &pdu) {
+        // Forward it unless it's fragmented.
+        if(reassembler.process(pdu) != IPv4Reassembler::FRAGMENTED)
+            return functor_(pdu);
+        else
+            return true;
+    }
+private:
+    IPv4Reassembler reassembler;
+    Functor functor_;
+};
+
+/**
+ * Helper function that creates an IPv4ReassemblerProxy.
+ *
+ * \param func The functor object to use in the IPv4ReassemblerProxy.
+ * \return An IPv4ReassemblerProxy.
+ */
+template<typename Functor>
+IPv4ReassemblerProxy<Functor> make_ipv4_reassembler_proxy(Functor func) {
+    return IPv4ReassemblerProxy<Functor>(func);
+}
+}
+
+
+#endif // TINS_IP_REASSEMBLER_H

include/tins/ipsec.h

@@ -0,0 +1,265 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_IPSEC_H
+#define TINS_IPSEC_H
+
+#include "pdu.h"
+#include "endianness.h"
+#include "small_uint.h"
+
+namespace Tins {
+/**
+ * \class IPSecAH
+ * \brief Represents an IPSec Authentication Header.
+ */
+class IPSecAH : public PDU {
+public:
+    /**
+     * This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::IPSEC_AH;
+
+    /**
+     * \brief Default constructor.
+     *
+     * The ICV field is initialized with four 0 bytes. The length
+     * field is initialized appropriately.
+     */
+    IPSecAH();
+    
+    /**
+     * \brief Constructs an IPSecAH object from a buffer and adds all 
+     * identifiable PDUs found in the buffer as children of this 
+     * one.
+     * 
+     * If there is not enough size for an IPSecAH header, a 
+     * malformed_packet exception is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    IPSecAH(const uint8_t *buffer, uint32_t total_sz);
+
+    // Getters
+
+    /**
+     *  \brief Getter for the Next header field.
+     *  \return The stored Next header field value.
+     */
+    uint8_t next_header() const {
+        return _header.next_header;
+    }
+
+    /**
+     *  \brief Getter for the Length field.
+     *  \return The stored Length field value.
+     */
+    uint8_t length() const {
+        return _header.length;
+    }
+
+    /**
+     *  \brief Getter for the Security Parameters Index field.
+     *  \return The stored Security Parameters Index field value.
+     */
+    uint32_t spi() const {
+        return Endian::be_to_host(_header.spi);
+    }
+
+    /**
+     *  \brief Getter for the Sequence number field.
+     *  \return The stored Sequence number field value.
+     */
+    uint32_t seq_number() const {
+        return Endian::be_to_host(_header.seq_number);
+    }
+    
+    /**
+     *  \brief Getter for the ICV field.
+     *  \return The stored ICV field value.
+     */
+    const byte_array &icv() const {
+        return _icv;
+    }
+
+    // Setters
+
+    /**
+     *  \brief Setter for the Next header field.
+     *  \param new_next_header The new Next header field value.
+     */
+    void next_header(uint8_t new_next_header);
+
+    /**
+     *  \brief Setter for the Length field.
+     *  \param new_length The new Length field value.
+     */
+    void length(uint8_t new_length);
+
+    /**
+     *  \brief Setter for the Security Parameters Index field.
+     *  \param new_spi The new Security Parameters Index field value.
+     */
+    void spi(uint32_t new_spi);
+
+    /**
+     *  \brief Setter for the Sequence number field.
+     *  \param new_seq_number The new Sequence number field value.
+     */
+    void seq_number(uint32_t new_seq_number);
+    
+    /**
+     *  \brief Setter for the ICV field.
+     *  \param new_icv The new ICV field value.
+     */
+    void icv(const byte_array &new_icv);
+
+    /**
+     * \brief Returns the header size.
+     *
+     * This metod overrides PDU::header_size. \sa PDU::header_size
+     */
+    uint32_t header_size() const;
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+
+    /**
+     * \sa PDU::clone
+     */
+    IPSecAH *clone() const {
+        return new IPSecAH(*this);
+    }
+private:
+    struct header {
+        uint8_t next_header, length;
+        uint32_t spi, seq_number;
+    };
+
+    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *);
+    
+    header _header;
+    byte_array _icv;
+};
+
+/**
+ * \brief Represents an IPSec Authentication Header.
+ */
+class IPSecESP : public PDU {
+public:
+    /**
+     * This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::IPSEC_ESP;
+
+    /**
+     * \brief Default constructor.
+     */
+    IPSecESP();
+    
+    /**
+     * \brief Constructs an IPSecESP object from a buffer and adds all 
+     * identifiable PDUs found in the buffer as children of this 
+     * one.
+     * 
+     * If there is not enough size for an IPSecESP header, a 
+     * malformed_packet exception is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    IPSecESP(const uint8_t *buffer, uint32_t total_sz);
+
+    // Getters
+    
+    /**
+     *  \brief Getter for the Security Parameters Index field.
+     *  \return The stored Security Parameters Index field value.
+     */
+    uint32_t spi() const {
+        return Endian::be_to_host(_header.spi);
+    }
+
+    /**
+     *  \brief Getter for the Sequence number field.
+     *  \return The stored Sequence number field value.
+     */
+    uint32_t seq_number() const {
+        return Endian::be_to_host(_header.seq_number);
+    }
+
+    // Setters
+
+    /**
+     *  \brief Setter for the Security Parameters Index field.
+     *  \param new_spi The new Security Parameters Index field value.
+     */
+    void spi(uint32_t new_spi);
+
+    /**
+     *  \brief Setter for the Sequence number field.
+     *  \param new_seq_number The new Sequence number field value.
+     */
+    void seq_number(uint32_t new_seq_number);
+
+    /**
+     * \brief Returns the header size.
+     *
+     * This metod overrides PDU::header_size. \sa PDU::header_size
+     */
+    uint32_t header_size() const;
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+
+    /**
+     * \sa PDU::clone
+     */
+    IPSecESP *clone() const {
+        return new IPSecESP(*this);
+    }
+private:
+    struct header {
+        uint32_t spi, seq_number;
+    };
+
+    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *);
+    
+    header _header;
+};
+}
+
+#endif // TINS_IPSEC_H

include/tins/ipv6.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -43,6 +43,7 @@ namespace Tins {
 class PacketSender;
     
 /**
+ * \class IPv6
  * Represents an IPv6 PDU.
  */
 class IPv6 : public PDU {
@@ -60,7 +61,7 @@ public:
     /**
      * The type used to represent IPv6 extension headers.
      */
-    typedef PDUOption<uint8_t> ext_header;
+    typedef PDUOption<uint8_t, IPv6> ext_header;
     
     /**
      * The type used to store the extension headers.

include/tins/ipv6_address.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without

include/tins/llc.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Matias Fontanini
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -40,7 +40,8 @@
 namespace Tins {
 
     /**
-     * \brief Class representing a LLC frame.
+     * \class LLC
+     * \brief Representing a LLC frame.
      *
      * This PDU follows the standard LLC frame described in the IEEE 802.2 specs.
      */