Update changelog for version 4.1

* Add QinQ Frame

* Fix serialization for QinQ

AUTHORS

@@ -1,9 +0,0 @@
-# Below is a list of people and organizations that have contributed source
-# code to libtins. Names are listed using the following format:
-#
-# Name/Organization <email address>
-
-Matias Fontanini <matias.fontanini@gmail.com>
-Santiago Alessandri <san.lt.ss@gmail.com>
-Bruno Nery <brunonery@brunonery.com>
-Piotr Haber <piotr.haber@sens.us>

CHANGES.md

@@ -1,4 +1,164 @@
-v3.4 - Wed Mar  9 20:24:54 PST 2016
+##### v4.1 - Tue Dec 11 02:08:48 UTC 2018
+
+- Fix serialization for QinQ (#316)
+
+- Added base class access specifier for socket_close_error (#306)
+
+- Rewrote hw_address_to_string to not require a stringstream (#299)
+
+- Make RadioTapParser::skip_to_field check for end of buffer (#296)
+
+- Ensure local include directory comes before system. (#293)
+
+- Calculate IP option sizes properly (#288)
+
+- Add parsing of well known IPv6 extension headers (#287)
+
+- Add missing operators to address classes (#275)
+
+- Add version macros in config.h
+
+- Don't assume IPv6 uses ICMPv6 underneath
+
+- Allow users to specify library install dir
+
+- Use Sleep windows function passing milliseconds as parameter
+
+- Implement IPv6::recv_response
+
+- Don't use nullptr in non C++11 code
+
+- Ignore (possibly malformed) options after EOL (#281)
+
+- Don't include dot11.h in tins.h if it is not configured in the library (#277)
+
+- Fix memory leak in PDU's move assignment operator
+
+- Append padding to IPv6 options
+
+##### v4.0 - Mon Dec  4 00:04:30 UTC 2017
+
+- Add parent PDU to each PDU.
+
+- Removed parent PDU parameter on `PDU::write_serialization`.
+
+- Split `utils.h` into multiple files under the `utils` directory.
+
+- Split `internals.h` into multiple files under the `detail` directory.
+
+- Improve compilation times by removing useless include directives.
+
+- Refactor `PDUOption` conversions so that heavy headers are not included in source file.
+
+- Use `std::vector` instead of `std::list` in `TCP`, `IP`, `IPv6`, `DHCP`, `DHCPv6`, `DNS`, `LLC`, `Dot11` and `PPPoE`.
+
+- Improve performance on `IP`, `IPv6` and `TCP` by compiting option sizes during serialization.
+
+- Minor performance improvements in `DNS`.
+
+- Fix `IPv6` next header handling. Now each one contains its own type and the next type is only set during serialization for ease of use.
+
+- Refactor `RadioTap` parsing and serialization using a generic parser/writer.
+
+- Add `BaseSniffer::set_pcap_sniffing_method` to specify whether `pcap_loop` or `pcap_dispatch` should be used when sniffing.
+
+- Use `IFF_POINTOPOINT` on BSD when getting broadcast address for an interface.
+
+- Added cipher and akm suites from 802.11-2016.
+
+- Add IPv6 layer parsing on `Loopback` packets.
+
+- Allow serializing `Loopback` on Windows.
+
+- Use the right flag on `Loopback` for `IPv6`.
+
+- Use the first fragment as a base when reassembling `IP` packets in `IPv4Reassembler`.
+
+- Restructure CMake files removing useless `CMakeLists.txt` in `include` paths.
+
+- Add getter/setter for "more data" field in `Dot11Base`.
+
+- Implemented matching for ND protocol related ICMPv6 messages.
+
+- Ensure TCP::OptionTypes has 8-bit range.
+
+- Add header files into CMake sources so IDE can pick them up.
+
+- Add MPLS "experimental" field.
+
+- Fix dhcpv6::duid_type constructor from duid_ll.
+
+##### v3.5 - Sat Apr  1 09:11:58 PDT 2017
+
+- Added Utils::route6_entries
+
+- Allow masking IPv4/6 and hardware addresses via `operator&`
+
+- Add IPv4Address::from_prefix_length
+
+- Move `stream_id` into a new file and rename it `StreamIdentifier`
+
+- Allow disabling TCPIP classes
+
+- Properly handle out of order SACKs on `AckTracker`
+
+- Move TCP data tracking into a separate class
+
+- Allow constructing `StreamIdentifier` from a `Stream`
+
+- Allow configuring pcap timestamp precision
+
+- Allow building libtins using MinGW
+
+- Allow including libtins using `add_subdirectory` via CMake
+
+- Allow setting customer user data to each TCP stream
+
+- Allow skipping data forward in TCP streams
+
+- Allow attaching to already existing TCP streams
+
+- Fix: AddressRange masks first address as well
+
+- Fix: Add TINS_API to `IPv4Address::operator<<`, `DataTracker` and `AckTracker`
+
+- Fix: Don't always set `key_t` to 0 on `RSNEAPOL`
+
+- Fix: Handle MLDv1 properly on ICMP
+
+- Fix: Make Utils::resolve_hwaddress work on Windows
+
+- Fix: Interface was sometimes considered down when it was up (BSD/Linux)
+
+- Fix: Don't set `Dot1Q`'s payload type if next protocol type is unknown
+
+- Fix: Use recvfrom on BSD/OSX when capturing layer 3 packets
+
+- Fix: Make `Timestamp::current_time` work on Windows
+
+- Fix: Forward `NetworkInterface` argument when calling `PacketSender::send_l2`
+
+- Fix: `Timestamp` overflow issue
+
+- Fix: boost's include directories variable incorrectly used on build system
+
+- Fix: Configuring auto cleanup of `Stream`'s server data not working
+
+- Fix: Set `EthernetII` payload type to `UNKNOWN` if there's no inner PDU
+
+- Fix: Set payload type to 0 if there's no inner PDU in `IP`, `Dot1Q` and `IPv6`
+
+- Fix: Buffer length check issues on `Dot11QosData`
+
+- Fix: Use AF_INET6 flag when opening L3 IPv6 socket
+
+- Fix: Check expecter size properly on `DNS::extract_metadata`
+
+- Fix: several unused parameter warnings
+
+- Fix: CCMP decryption issue when `Dot11QoSData` has a TID != 0
+
+##### v3.4 - Wed Mar  9 20:24:54 PST 2016
 
 - Check the secure bit on HandshakeCapturer to detect 2nd packet
 
@@ -50,7 +210,7 @@ v3.4 - Wed Mar  9 20:24:54 PST 2016
 
 - Fix invalid endian on IP fragment offset on OSX
 
-v3.3 - Sun Jan 31 21:06:04 PST 2016
+##### v3.3 - Sun Jan 31 21:06:04 PST 2016
 
 - Add TCP connection close example
 
@@ -215,7 +375,7 @@ immutable
 
 -------------------------------------------------------------------------------
 
-v3.2 - Fri Mar 20 22:12:23 PST 2015
+##### v3.2 - Fri Mar 20 22:12:23 PST 2015
 
 - Added include guard for config.h.
 
@@ -298,7 +458,7 @@ conversion on integral constant.
 
 -------------------------------------------------------------------------------
 
-v3.1 - Sun Aug 24 21:39:43 ART 2014
+##### v3.1 - Sun Aug 24 21:39:43 ART 2014
 
 - Fixed ICMPv6 checksum error on serialization.
 
@@ -308,7 +468,7 @@ v3.1 - Sun Aug 24 21:39:43 ART 2014
 
 -------------------------------------------------------------------------------
 
-v3.0 - Thu Aug  7 21:39:09 ART 2014
+##### v3.0 - Thu Aug  7 21:39:09 ART 2014
 
 - Timestamps can now be constructed from std::chrono::duration.
 
@@ -373,7 +533,7 @@ PDU types.
 
 -------------------------------------------------------------------------------
 
-v2.0 - Thu Jan 23 11:09:38 ART 2014 
+##### v2.0 - Thu Jan 23 11:09:38 ART 2014 
 
 - DNSResourceRecord was removed. Now DNS records are added using 
 DNS::Resource.
@@ -429,7 +589,7 @@ capture size.
 
 -------------------------------------------------------------------------------
 
-v1.2 - Mon oct  7 23:33:49 ART 2013
+##### v1.2 - Mon oct  7 23:33:49 ART 2013
 
 - Added BaseSniffer::begin and BaseSniffer::end.
 
@@ -525,7 +685,7 @@ that used them.
 
 -------------------------------------------------------------------------------
 
-v0.3 - Thu Jan 31 16:47:27 ART 2013
+##### v0.3 - Thu Jan 31 16:47:27 ART 2013
 
 - Added IPv6, ICMPv6 and DHCPv6 classes.
 
@@ -546,7 +706,7 @@ pseudo protocol.
 
 -------------------------------------------------------------------------------
 
-v0.2 - Sat Oct 20 11:26:40 2012
+##### v0.2 - Sat Oct 20 11:26:40 2012
 
 - Added support for big endian architectures. 
 

CMakeLists.txt

@@ -1,10 +1,13 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 2.8.1)
 PROJECT(libtins)
 
+OPTION(LIBTINS_BUILD_EXAMPLES "Build examples" ON)
+OPTION(LIBTINS_BUILD_TESTS "Build tests" ON)
+
 # 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) 
+    SET(CMAKE_BUILD_TYPE RelWithDebInfo)
 ELSE(NOT CMAKE_BUILD_TYPE)
     MESSAGE(STATUS "Using specified '${CMAKE_BUILD_TYPE}' build type.")
 ENDIF(NOT CMAKE_BUILD_TYPE)
@@ -18,11 +21,11 @@ IF(MSVC)
     ADD_DEFINITIONS("-D_SCL_SECURE_NO_WARNINGS=1")
     ADD_DEFINITIONS("-DNOGDI=1")
 ELSE()
-    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
+    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra")
 ENDIF()
 
 IF(APPLE)
-    # This is set to ON as of policy CMP0042 
+    # This is set to ON as of policy CMP0042
     SET(CMAKE_MACOSX_RPATH ON)
 ENDIF()
 
@@ -30,7 +33,7 @@ ENDIF()
 OPTION(LIBTINS_BUILD_SHARED "Build libtins as a shared library." ON)
 IF(LIBTINS_BUILD_SHARED)
     MESSAGE(
-        STATUS 
+        STATUS
         "Build will generate a shared library. "
         "Use LIBTINS_BUILD_SHARED=0 to perform a static build"
     )
@@ -42,15 +45,22 @@ ELSE(LIBTINS_BUILD_SHARED)
 ENDIF(LIBTINS_BUILD_SHARED)
 
 # The version number.
-SET(LIBTINS_VERSION_MAJOR 3)
-SET(LIBTINS_VERSION_MINOR 4)
-SET(LIBTINS_VERSION "${LIBTINS_VERSION_MAJOR}.${LIBTINS_VERSION_MINOR}")
+SET(TINS_VERSION_MAJOR 4)
+SET(TINS_VERSION_MINOR 1)
+SET(TINS_VERSION_PATCH 0)
+SET(LIBTINS_VERSION "${TINS_VERSION_MAJOR}.${TINS_VERSION_MINOR}")
 
 # Required Packages
-SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/")
+SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/")
+
+# Allow disabling packet capture mechanism
+OPTION(LIBTINS_ENABLE_PCAP "Enable capturing packets via libpcap" ON)
 
 # Look for libpcap
-FIND_PACKAGE(PCAP REQUIRED)
+IF(LIBTINS_ENABLE_PCAP)
+    FIND_PACKAGE(PCAP REQUIRED)
+    SET(TINS_HAVE_PCAP ON)
+ENDIF()
 
 # Set some Windows specific flags
 IF(WIN32)
@@ -59,6 +69,22 @@ IF(WIN32)
 
     # Add the NOMINMAX macro to avoid Windows' min and max macros.
     ADD_DEFINITIONS(-DNOMINMAX)
+
+    # MinWG need some extra definitions to compile properly (WIN32 for PCAP and WIN32_WINNT version for ws2tcpip.h)
+    IF(MINGW)
+        ADD_DEFINITIONS(-DWIN32)
+        MACRO(get_WIN32_WINNT version)
+        IF (WIN32 AND CMAKE_SYSTEM_VERSION)
+            SET(ver ${CMAKE_SYSTEM_VERSION})
+            STRING(REPLACE "." "" ver ${ver})
+            STRING(REGEX REPLACE "([0-9])" "0\\1" ver ${ver})
+            SET(${version} "0x${ver}")
+        ENDIF()
+        ENDMACRO()
+        get_WIN32_WINNT(ver)
+        ADD_DEFINITIONS(-D_WIN32_WINNT=${ver})
+    ENDIF(MINGW)
+
 ENDIF(WIN32)
 
 INCLUDE(ExternalProject)
@@ -80,7 +106,7 @@ IF(LIBTINS_ENABLE_CXX11)
     # We only use declval and decltype on gcc/clang as VC fails to build that code,
     # at least on VC2013
     IF(HAS_CXX11_RVALUE_REFERENCES AND HAS_CXX11_FUNCTIONAL AND HAS_CXX11_CHRONO AND
-       ((HAS_CXX11_DECLVAL AND HAS_CXX11_DECLTYPE) OR MSVC))
+       HAS_CXX11_NOEXCEPT AND ((HAS_CXX11_DECLVAL AND HAS_CXX11_DECLTYPE) OR MSVC))
         SET(TINS_HAVE_CXX11 ON)
         MESSAGE(STATUS "Enabling C++11 features")
         SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX11_COMPILER_FLAGS}")
@@ -90,7 +116,7 @@ IF(LIBTINS_ENABLE_CXX11)
     ENDIF()
 ELSE(LIBTINS_ENABLE_CXX11)
     MESSAGE(
-        WARNING 
+        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")
@@ -118,12 +144,25 @@ IF(LIBTINS_ENABLE_DOT11)
     ENDIF(LIBTINS_ENABLE_WPA2)
 ENDIF(LIBTINS_ENABLE_DOT11)
 
+# Optionally enable TCPIP classes (on by default)
+OPTION(LIBTINS_ENABLE_TCPIP "Enable TCPIP classes" ON)
+IF(LIBTINS_ENABLE_TCPIP AND TINS_HAVE_CXX11)
+    SET(TINS_HAVE_TCPIP ON)
+    MESSAGE(STATUS "Enabling TCPIP classes")
+ELSE()
+    SET(TINS_HAVE_TCPIP OFF)
+    MESSAGE(STATUS "Disabling TCPIP classes")
+ENDIF()
+
+# Search for libboost
+FIND_PACKAGE(Boost)
+
+# Optionally enable the ACK tracker (on by default)
 OPTION(LIBTINS_ENABLE_ACK_TRACKER "Enable TCP ACK tracking support" ON)
 IF(LIBTINS_ENABLE_ACK_TRACKER AND TINS_HAVE_CXX11)
-    FIND_PACKAGE(Boost)
     IF (Boost_FOUND)
         MESSAGE(STATUS "Enabling TCP ACK tracking support.")
-        INCLUDE_DIRECTORIES(Boost_INCLUDE_DIRS)
+        INCLUDE_DIRECTORIES(${Boost_INCLUDE_DIRS})
         SET(TINS_HAVE_ACK_TRACKER ON)
     ELSE()
         MESSAGE(WARNING "Disabling ACK tracking support as boost.icl was not found")
@@ -134,6 +173,22 @@ ELSE()
     MESSAGE(STATUS "Disabling ACK tracking support")
 ENDIF()
 
+# Optionally enable the TCP stream custom data (on by default)
+OPTION(LIBTINS_ENABLE_TCP_STREAM_CUSTOM_DATA "Enable TCP stream custom data support" ON)
+IF(LIBTINS_ENABLE_TCP_STREAM_CUSTOM_DATA AND TINS_HAVE_CXX11)
+    IF (Boost_FOUND)
+        MESSAGE(STATUS "Enabling TCP stream custom data support.")
+        INCLUDE_DIRECTORIES(${Boost_INCLUDE_DIRS})
+        SET(TINS_HAVE_TCP_STREAM_CUSTOM_DATA ON)
+    ELSE()
+        MESSAGE(WARNING "Disabling TCP stream custom data support as boost.any was not found")
+        SET(TINS_HAVE_TCP_STREAM_CUSTOM_DATA OFF)
+    ENDIF()
+ELSE()
+    SET(TINS_HAVE_TCP_STREAM_CUSTOM_DATA OFF)
+    MESSAGE(STATUS "Disabling TCP stream custom data support")
+ENDIF()
+
 OPTION(LIBTINS_ENABLE_WPA2_CALLBACKS "Enable WPA2 callback interface" ON)
 IF(LIBTINS_ENABLE_WPA2_CALLBACKS AND TINS_HAVE_WPA2_DECRYPTION AND TINS_HAVE_CXX11)
     SET(STATUS "Enabling WPA2 callback interface")
@@ -149,17 +204,17 @@ ENDIF(WIN32)
 
 OPTION(LIBTINS_USE_PCAP_SENDPACKET "Use pcap_sendpacket to send l2 packets"
         ${USE_PCAP_SENDPACKET_DEFAULT})
-IF(LIBTINS_USE_PCAP_SENDPACKET)
+IF(LIBTINS_ENABLE_PCAP AND LIBTINS_USE_PCAP_SENDPACKET)
     SET(TINS_HAVE_PACKET_SENDER_PCAP_SENDPACKET ON)
     MESSAGE(STATUS "Using pcap_sendpacket to send l2 packets.")
-ENDIF(LIBTINS_USE_PCAP_SENDPACKET)
+ENDIF()
 
 # 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 
+        ${CMAKE_CURRENT_SOURCE_DIR}/docs/Doxyfile.in
+        ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
         @ONLY
     )
     ADD_CUSTOM_TARGET(
@@ -170,18 +225,19 @@ IF(DOXYGEN_FOUND)
     )
 ENDIF(DOXYGEN_FOUND)
 
-# The library output directory
-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"
 )
 
+IF (NOT CMAKE_INSTALL_LIBDIR)
+    SET(CMAKE_INSTALL_LIBDIR lib)
+ENDIF()
+# The library output directory
+SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR})
+SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR})
 # 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})
@@ -209,34 +265,43 @@ ADD_CUSTOM_TARGET(uninstall
 # ******************
 # Add subdirectories
 # ******************
-ADD_SUBDIRECTORY(include)
-ADD_SUBDIRECTORY(examples)
 ADD_SUBDIRECTORY(src)
 
-# Only include googletest if the git submodule has been fetched
-IF(EXISTS "${CMAKE_SOURCE_DIR}/googletest/CMakeLists.txt")
-    # Enable tests and add the test directory
-    MESSAGE(STATUS "Tests have been enabled")
-    SET(GOOGLETEST_ROOT ${CMAKE_SOURCE_DIR}/googletest)
-    SET(GOOGLETEST_INCLUDE ${GOOGLETEST_ROOT}/googletest/include)
-    SET(GOOGLETEST_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/googletest)
-    SET(GOOGLETEST_LIBRARY ${GOOGLETEST_BINARY_DIR}/googletest)
+IF(LIBTINS_BUILD_EXAMPLES)
+    IF(LIBTINS_ENABLE_PCAP)
+        ADD_SUBDIRECTORY(examples)
+    ELSE()
+        MESSAGE(STATUS "Not building examples as pcap support is disabled")
+    ENDIF()
+ENDIF()
 
-    ExternalProject_Add(
-        googletest
-        DOWNLOAD_COMMAND ""
-        SOURCE_DIR ${GOOGLETEST_ROOT}
-        BINARY_DIR ${GOOGLETEST_BINARY_DIR}
-        CMAKE_CACHE_ARGS "-DBUILD_GTEST:bool=ON" "-DBUILD_GMOCK:bool=OFF"
-                         "-Dgtest_force_shared_crt:bool=ON"
-        INSTALL_COMMAND ""
-    )
-    # Make sure we build googletest before anything else
-    ADD_DEPENDENCIES(tins googletest)
-    ENABLE_TESTING()
-    ADD_SUBDIRECTORY(tests)
-ELSE()
-    MESSAGE(STATUS "googletest git submodule is absent. Run `git submodule init && git submodule update` to get it")
+IF(LIBTINS_BUILD_TESTS)
+    # Only include googletest if the git submodule has been fetched
+    IF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/googletest/CMakeLists.txt")
+        # Enable tests and add the test directory
+        MESSAGE(STATUS "Tests have been enabled")
+        SET(GOOGLETEST_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/googletest)
+        SET(GOOGLETEST_INCLUDE ${GOOGLETEST_ROOT}/googletest/include)
+        SET(GOOGLETEST_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/googletest)
+        SET(GOOGLETEST_LIBRARY ${GOOGLETEST_BINARY_DIR}/googletest)
+
+        ExternalProject_Add(
+            googletest
+            DOWNLOAD_COMMAND ""
+            SOURCE_DIR ${GOOGLETEST_ROOT}
+            BINARY_DIR ${GOOGLETEST_BINARY_DIR}
+            CMAKE_CACHE_ARGS "-DBUILD_GTEST:bool=ON" "-DBUILD_GMOCK:bool=OFF"
+                            "-Dgtest_force_shared_crt:bool=ON"
+                            "-DCMAKE_CXX_COMPILER:path=${CMAKE_CXX_COMPILER}"
+            INSTALL_COMMAND ""
+        )
+        # Make sure we build googletest before anything else
+        ADD_DEPENDENCIES(tins googletest)
+        ENABLE_TESTING()
+        ADD_SUBDIRECTORY(tests)
+    ELSE()
+        MESSAGE(STATUS "googletest git submodule is absent. Run `git submodule init && git submodule update` to get it")
+    ENDIF()
 ENDIF()
 
 # **********************************

CONTRIBUTING.md

@@ -22,9 +22,6 @@ easier.
 
 Pull requests are very welcomed. When doing a pull request please:
 
-* Base your PR branch on the `develop` branch. This is **almost always** pointing to the
-same commit as `master`, so you shouldn't have any issues changing the destination branch
-to `develop` at the time you try to do the pull request if you based your code on `master`.
-* Your code will be compiled and tests will be run automatically by the travis and 
+* Notice that your code will be compiled and tests will be run automatically by the travis and 
 appveyor CI tools. If your code has issues on any of the tested platforms (GNU/Linux, Windows
 and OSX), please fix it or otherwise the PR won't be merged. 

LICENSE

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

README.md

@@ -49,7 +49,7 @@ _build/lib_ directory.
 
 ### C++11 support
 
-libtins is noticeable faster if you enable _C++11_ support. Therefore, 
+libtins is noticeably 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:
 
@@ -144,4 +144,4 @@ http://libtins.github.io/examples/
 ## Contributing ##
 
 If you want to report a bug or make a pull request, please have a look at 
-the [contributing](CONTRIBUTING.md) file before doing so.
+the [contributing](CONTRIBUTING.md) file before doing so.

cmake/Modules/CheckCXXFeatures.cmake

@@ -125,23 +125,11 @@ function(cxx11_check_feature FEATURE_NAME RESULT_VAR)
     endif (NOT DEFINED ${RESULT_VAR})
 endfunction(cxx11_check_feature)
 
-#cxx11_check_feature("regex" HAS_CXX11_LIB_REGEX)
-#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("lambda" HAS_CXX11_LAMBDA)
-#cxx11_check_feature("long_long" HAS_CXX11_LONG_LONG)
-#cxx11_check_feature("nullptr" HAS_CXX11_NULLPTR)
-#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)
 cxx11_check_feature("decltype" HAS_CXX11_DECLTYPE)
 cxx11_check_feature("declval" HAS_CXX11_DECLVAL)
 cxx11_check_feature("initializer_list" HAS_CXX11_INITIALIZER_LIST)
 cxx11_check_feature("rvalue-references" HAS_CXX11_RVALUE_REFERENCES)
 cxx11_check_feature("functional" HAS_CXX11_FUNCTIONAL)
 cxx11_check_feature("chrono" HAS_CXX11_CHRONO)
+cxx11_check_feature("noexcept" HAS_CXX11_NOEXCEPT)
 cxx11_check_feature("builtin-swap" HAS_GCC_BUILTIN_SWAP)

cmake/Modules/CheckCXXFeatures/cxx-test-noexcept.cpp

@@ -0,0 +1,7 @@
+int foo() noexcept {
+    return 0;
+}
+
+int main() {
+    return foo();
+}

cmake/Modules/FindPCAP.cmake

@@ -75,6 +75,7 @@ include(CheckFunctionExists)
 set(CMAKE_REQUIRED_LIBRARIES ${PCAP_LIBRARY})
 check_function_exists(pcap_get_pfring_id HAVE_PF_RING)
 check_function_exists(pcap_set_immediate_mode HAVE_PCAP_IMMEDIATE_MODE)
+check_function_exists(pcap_set_tstamp_precision HAVE_PCAP_TIMESTAMP_PRECISION)
 set(CMAKE_REQUIRED_LIBRARIES)
 
 mark_as_advanced(

cmake/appveyor.yml

@@ -5,6 +5,11 @@ configuration:
 platform: 
 - Win32
 - x64
+environment:
+  matrix:
+    - compiler: vs2013
+    - compiler: vs2015
+  BOOST_ROOT: C:/Libraries/boost
 clone_depth: 1
 install:
 - git clone https://github.com/mfontanini/winpcap-installer.git
@@ -18,8 +23,12 @@ install:
 before_build:
 - mkdir build
 - cd build
-- if "%platform%"=="x64" ( set GENERATOR="Visual Studio 12 Win64" ) else ( set GENERATOR="Visual Studio 12" )
-- cmake .. -G %GENERATOR% -DPCAP_ROOT_DIR=c:\WpdPack -DLIBTINS_BUILD_SHARED=0 -DLIBTINS_ENABLE_WPA2=0
+- if "%compiler%"=="vs2013" (set VS_VERSION=12) else (set VS_VERSION=14)
+- set VS=Visual Studio %VS_VERSION%
+- if "%platform%"=="Win32" (set GENERATOR="%VS%" & set ARCH_BITS=32)
+- if "%platform%"=="x64" (set GENERATOR="%VS% Win64" & set ARCH_BITS=64)
+- set BOOST_LIBRARYDIR=C:\Libraries\boost\lib%ARCH_BITS%-msvc-%VS_VERSION%.0
+- cmake .. -G %GENERATOR% -DPCAP_ROOT_DIR=c:\WpdPack -DLIBTINS_BUILD_SHARED=0 -DLIBTINS_ENABLE_WPA2=0 -DBOOST_ROOT="%BOOST_ROOT%" -DBOOST_LIBRARYDIR="%BOOST_LIBRARYDIR%" -DBoost_USE_STATIC_LIBS="ON"
 build:
   project: C:/projects/libtins/build/libtins.sln
   verbosity: minimal
@@ -34,11 +43,11 @@ after_build:
 - del include\tins\config.h.in
 - del include\tins\dot11\CMakeLists.txt
 - cd ..\
-- 7z a libtins-%platform%-%Configuration%.zip libtins
+- 7z a libtins-%compiler%-%platform%-%Configuration%.zip libtins
 test_script:
 - cd c:\projects\libtins\build
 - ctest -C %Configuration% -V
 deploy_script:
-- ps: Push-AppveyorArtifact "install\libtins-$env:Platform-$env:Configuration.zip"
+- ps: Push-AppveyorArtifact "install\libtins-$env:Compiler-$env:Platform-$env:Configuration.zip"
 skip_commits:
   message: /Update documentation.*/

docs/Doxyfile.in

@@ -1366,7 +1366,8 @@ INCLUDE_FILE_PATTERNS  =
 # instead of the = operator.
 
 PREDEFINED             = "TINS_IS_CXX11=1" \
-                         "TINS_HAVE_WPA2_CALLBACKS=1"
+                         "TINS_HAVE_WPA2_CALLBACKS=1" \
+                         "TINS_HAVE_DOT11=1"
 
 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
 # this tag can be used to specify a list of macro names that should be expanded.

examples/arpmonitor.cpp

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

examples/arpspoofing.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -88,7 +88,7 @@ void do_arp_spoofing(NetworkInterface iface,
         sender.send(to_gw, iface);
         sender.send(to_victim, iface);
         #ifdef _WIN32
-            Sleep(5);
+            Sleep(5000);
         #else
             sleep(5);
         #endif

examples/beacon_display.cpp

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

examples/defragmenter.cpp

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

examples/dns_queries.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -56,7 +56,7 @@ int main(int argc, char* argv[]) {
         cout << "Usage: " <<* argv << " <interface>" << endl;
         return 1;
     }
-    // Sniff on the provided interface in promiscuos mode
+    // Sniff on the provided interface in promiscuous mode
     SnifferConfiguration config;
     config.set_promisc_mode(true);
     // Only capture udp packets sent to port 53

examples/dns_spoof.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -56,7 +56,7 @@ bool callback(const PDU& pdu) {
             if (query.query_type() == DNS::A) {
                 // Here's one! Let's add an answer.
                 dns.add_answer(
-                    DNS::Resource(
+                    DNS::resource(
                         query.dname(), 
                         "127.0.0.1",
                         DNS::A, 
@@ -90,9 +90,11 @@ int main(int argc, char* argv[]) {
         cout << "Usage: " <<* argv << " <interface>" << endl;
         return 1;
     }
-    // Sniff on the provided interface in promiscuos mode
+    // Sniff on the provided interface in promiscuous mode
     SnifferConfiguration config;
     config.set_promisc_mode(true);
+    // Use immediate mode so we get the packets as fast as we can
+    config.set_immediate_mode(true);
     // Only capture udp packets sent to port 53
     config.set_filter("udp and dst port 53");
     Sniffer sniffer(argv[1], config);

examples/dns_stats.cpp

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

examples/http_requests.cpp

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

examples/portscan.cpp

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

examples/route_table.cpp

@@ -40,13 +40,30 @@ using std::vector;
 using namespace Tins;
 
 int main() {
-    vector<Utils::RouteEntry> entries = Utils::route_entries();
-    for (size_t i = 0; i < entries.size(); ++i) {
+    vector<Utils::RouteEntry> v4_entries = Utils::route_entries();
+    cout << "IPv4 route table entries: " << endl
+         << "========================= " << endl;
+    for (size_t i = 0; i < v4_entries.size(); ++i) {
         cout << "Entry " << setw(2) << i << ": " << endl
-             << "Interface:   " << entries[i].interface << endl
-             << "Destination: " << entries[i].destination << endl
-             << "Gateway:     " << entries[i].gateway << endl
-             << "Genmask:     " << entries[i].mask << endl
-             << "Metric:      " << entries[i].metric << endl << endl;
+             << "Interface:   " << v4_entries[i].interface << endl
+             << "Destination: " << v4_entries[i].destination << endl
+             << "Gateway:     " << v4_entries[i].gateway << endl
+             << "Genmask:     " << v4_entries[i].mask << endl
+             << "Metric:      " << v4_entries[i].metric << endl << endl;
+    }
+
+    vector<Utils::Route6Entry> v6_entries = Utils::route6_entries();
+    if (!v6_entries.empty()) {
+        cout << endl
+             << "IPv6 route table entries: " << endl
+             << "========================= " << endl;
+        for (size_t i = 0; i < v6_entries.size(); ++i) {
+            cout << "Entry " << setw(2) << i << ": " << endl
+                 << "Interface:   " << v6_entries[i].interface << endl
+                 << "Destination: " << v6_entries[i].destination << endl
+                 << "Gateway:     " << v6_entries[i].gateway << endl
+                 << "Genmask:     " << v6_entries[i].mask << endl
+                 << "Metric:      " << v6_entries[i].metric << endl << endl;
+        }
     }
 }

examples/stream_dump.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -94,6 +94,7 @@ string stream_identifier(const Stream& stream) {
 void on_client_data(Stream& stream) {
     // Construct a string out of the contents of the client's payload
     string data(stream.client_payload().begin(), stream.client_payload().end());
+
     // Now print it, prepending some information about the stream
     cout << client_endpoint(stream) << " >> " 
          << server_endpoint(stream) << ": " << endl << data << endl;
@@ -114,13 +115,34 @@ void on_connection_closed(Stream& stream) {
 
 // When a new connection is captured, this callback will be executed.
 void on_new_connection(Stream& stream) {
-    // Print some information about the new connection
-    cout << "[+] New connection " << stream_identifier(stream) << endl;
+    if (stream.is_partial_stream()) {
+        // We found a partial stream. This means this connection/stream had
+        // been established before we started capturing traffic.
+        //
+        // In this case, we need to allow for the stream to catch up, as we
+        // may have just captured an out of order packet and if we keep waiting
+        // for the holes to be filled, we may end up waiting forever.
+        //
+        // Calling enable_recovery_mode will skip out of order packets that
+        // fall withing the range of the given window size.
+        // See Stream::enable_recover_mode for more information
+        cout << "[+] New connection " << stream_identifier(stream) << endl;
+
+        // Enable recovery mode using a window of 10kb
+        stream.enable_recovery_mode(10 * 1024);
+    }
+    else {
+        // Print some information about the new connection
+        cout << "[+] New connection " << stream_identifier(stream) << endl;
+    }
+
     // Now configure the callbacks on it.
     // First, we want on_client_data to be called every time there's new client data
     stream.client_data_callback(&on_client_data);
+
     // Same thing for server data, but calling on_server_data
     stream.server_data_callback(&on_server_data);
+
     // When the connection is closed, call on_connection_closed
     stream.stream_closed_callback(&on_connection_closed);
 }
@@ -134,8 +156,10 @@ int main(int argc, char* argv[]) {
     try {
         // Construct the sniffer configuration object
         SnifferConfiguration config;
+
         // Only capture TCP traffic sent from/to the given port
         config.set_filter("tcp port " + to_string(stoi(string(argv[2]))));
+
         // Construct the sniffer we'll use
         Sniffer sniffer(argv[1], config);
 
@@ -143,11 +167,17 @@ int main(int argc, char* argv[]) {
 
         // Now construct the stream follower
         StreamFollower follower;
+
         // We just need to specify the callback to be executed when a new 
         // stream is captured. In this stream, you should define which callbacks
         // will be executed whenever new data is sent on that stream 
         // (see on_new_connection)
         follower.new_stream_callback(&on_new_connection);
+
+        // Allow following partial TCP streams (e.g. streams that were
+        // open before the sniffer started running)
+        follower.follow_partial_streams(true);
+
         // Now start capturing. Every time there's a new packet, call 
         // follower.process_packet
         sniffer.sniff_loop([&](PDU& packet) {

examples/tcp_connection_close.cpp

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

examples/traceroute.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -35,6 +35,7 @@
 #define _GLIBCXX_USE_NANOSLEEP
 
 #include <iostream>
+#include <iomanip>
 #include <chrono>
 #include <thread>
 #include <cstdint>

examples/wps_detect.cpp

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

include/CMakeLists.txt

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

include/tins/CMakeLists.txt

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

include/tins/address_range.h

@@ -1,18 +1,18 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, 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,10 +30,10 @@
 #ifndef TINS_ADDRESS_RANGE
 #define TINS_ADDRESS_RANGE
 
-#include <stdexcept>
 #include <iterator>
-#include "endianness.h"
-#include "internals.h"
+#include <tins/endianness.h>
+#include <tins/exceptions.h>
+#include <tins/detail/address_helpers.h>
 
 namespace Tins {
 /**
@@ -125,10 +125,10 @@ private:
  * \brief Represents a range of addresses.
  *
  * This class provides a begin()/end() interface which allows
- * iterating through every address stored in it. 
+ * iterating through every address stored in it.
  *
  * Note that when iterating a range that was created using
- * operator/(IPv4Address, int) and the analog for IPv6, the 
+ * operator/(IPv4Address, int) and the analog for IPv6, the
  * network and broadcast addresses are discarded:
  *
  * \code
@@ -139,12 +139,12 @@ private:
  * }
  *
  * // That's only valid for iteration, not for AddressRange<>::contains
- * 
+ *
  * assert(range.contains("192.168.5.0")); // works
  * assert(range.contains("192.168.5.255")); // works
  * \endcode
  *
- * Ranges created using AddressRange(address_type, address_type) 
+ * Ranges created using AddressRange(address_type, address_type)
  * will allow the iteration over the entire range:
  *
  * \code
@@ -153,11 +153,11 @@ private:
  *     // process 192.168.5.0-255, no addresses are discarded
  *     process(addr);
  * }
- * 
+ *
  * assert(range.contains("192.168.5.0")); // still valid
  * assert(range.contains("192.168.5.255")); // still valid
  * \endcode
- * 
+ *
  */
 template<typename Address>
 class AddressRange {
@@ -186,10 +186,10 @@ public:
      * The range will consist of the addresses [first, last].
      *
      * If only_hosts is true, then the network and broadcast addresses
-     * will not be available when iterating the range. 
+     * will not be available when iterating the range.
      *
      * If last < first, an std::runtime_error exception is thrown.
-     * 
+     *
      * \param first The first address in the range.
      * \param last The last address(inclusive) in the range.
      * \param only_hosts Indicates whether only host addresses
@@ -198,7 +198,7 @@ public:
     AddressRange(const address_type& first, const address_type& last, bool only_hosts = false)
     : first_(first), last_(last), only_hosts_(only_hosts){
         if (last_ < first_) {
-            throw std::runtime_error("Invalid address range");
+            throw exception_base("Invalid address range");
         }
     }
 
@@ -211,8 +211,8 @@ public:
      */
     static AddressRange from_mask(const address_type& first, const address_type& mask) {
         return AddressRange<address_type>(
-            first, 
-            Internals::last_address_from_mask(first, mask), 
+            first & mask,
+            Internals::last_address_from_mask(first, mask),
             true
         );
     }
@@ -253,15 +253,15 @@ public:
     /**
      * \brief Indicates whether this range is iterable.
      *
-     * Iterable ranges are those for which there is at least one 
+     * Iterable ranges are those for which there is at least one
      * address that could represent a host. For IPv4 ranges, a /31 or
      * /32 ranges does not contain any, therefore it's not iterable.
      * The same is true for /127 and /128 IPv6 ranges.
      *
      * If is_iterable returns false for a range, then iterating it
-     * through the iterators returned by begin() and end() is 
-     * undefined. 
-     * 
+     * through the iterators returned by begin() and end() is
+     * undefined.
+     *
      * \return bool indicating whether this range is iterable.
      */
     bool is_iterable() const {

include/tins/arp.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,11 +31,11 @@
 #ifndef TINS_ARP_H
 #define TINS_ARP_H
 
-#include "macros.h"
-#include "pdu.h"
-#include "endianness.h"
-#include "hw_address.h"
-#include "ip_address.h"
+#include <tins/macros.h>
+#include <tins/pdu.h>
+#include <tins/endianness.h>
+#include <tins/hw_address.h>
+#include <tins/ip_address.h>
 
 namespace Tins {
 
@@ -298,7 +298,7 @@ public:
      * \param sender The sender's IP address.
      * \param hw_tgt The target's hardware address.
      * \param hw_snd The sender's hardware address.
-     * \return EthetnetII containing the ARP Replay.
+     * \return EthernetII object containing the ARP Reply.
      */
     static EthernetII make_arp_reply(ipaddress_type target, 
                                      ipaddress_type sender, 
@@ -334,7 +334,7 @@ private:
         uint32_t target_ip_address;
     } TINS_END_PACK;
 
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
 
     arp_header header_;
 };

include/tins/bootp.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,13 +31,12 @@
 #define TINS_BOOTP_H
 
 #include <stdint.h>
-#include <algorithm>
 #include <vector>
-#include "pdu.h"
-#include "macros.h"
-#include "endianness.h"
-#include "ip_address.h"
-#include "hw_address.h"
+#include <tins/pdu.h>
+#include <tins/macros.h>
+#include <tins/endianness.h>
+#include <tins/ip_address.h>
+#include <tins/hw_address.h>
 
 namespace Tins {
 
@@ -268,15 +267,14 @@ public:
      */
     template<size_t n>
     void chaddr(const HWAddress<n>& new_chaddr) {
-        // Copy the new addr
-        uint8_t* end = std::copy(
-            new_chaddr.begin(), 
-            new_chaddr.begin() + std::min(n, sizeof(bootp_.chaddr)), 
-            bootp_.chaddr
-        );
-        // Fill what's left with zeros
-        if (end < bootp_.chaddr + chaddr_type::address_size) {
-            std::fill(end, bootp_.chaddr + chaddr_type::address_size, 0);
+        size_t copy_threshold = std::min(n, sizeof(bootp_.chaddr));
+        for (size_t i = 0; i < copy_threshold; ++i) {
+            if (i < copy_threshold) {
+                bootp_.chaddr[i] = new_chaddr[i];
+            }
+            else {
+                bootp_.chaddr[i] = 0;
+            }
         }
     }
 
@@ -332,7 +330,7 @@ protected:
      */
     vend_type& vend() { return vend_; }
 
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
     
     /**
      * Struct that represents the Bootp datagram.

include/tins/config.h.in

@@ -13,13 +13,27 @@
 /* Use pcap_sendpacket to send l2 packets */
 #cmakedefine TINS_HAVE_PACKET_SENDER_PCAP_SENDPACKET
 
+/* Have TCPIP classes */
+#cmakedefine TINS_HAVE_TCPIP
+
 /* Have TCP ACK tracking */
 #cmakedefine TINS_HAVE_ACK_TRACKER
 
+/* Have TCP stream custom data */
+#cmakedefine TINS_HAVE_TCP_STREAM_CUSTOM_DATA
+
 /* Have GCC builtin swap */
 #cmakedefine TINS_HAVE_GCC_BUILTIN_SWAP
 
 /* Have WPA2Decrypter callbacks */
 #cmakedefine TINS_HAVE_WPA2_CALLBACKS
 
+/* Have libpcap */
+#cmakedefine TINS_HAVE_PCAP
+
+/* Version macros */
+#define TINS_VERSION_MAJOR ${TINS_VERSION_MAJOR}
+#define TINS_VERSION_MINOR ${TINS_VERSION_MINOR}
+#define TINS_VERSION_PATCH ${TINS_VERSION_PATCH}
+
 #endif // TINS_CONFIG_H

include/tins/constants.h

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

include/tins/crypto.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,34 +27,30 @@
  *
  */
 
-#include "config.h"
+#include <tins/config.h>
 
 #if !defined(TINS_CRYPTO_H) && defined(TINS_HAVE_DOT11)
 #define TINS_CRYPTO_H
 
 #include <map>
 #include <string>
-#include <algorithm>
 #include <vector>
 #ifdef TINS_HAVE_WPA2_CALLBACKS
     #include <functional>
 #endif // TINS_HAVE_WPA2_CALLBACKS
-#include "utils.h"
-#include "snap.h"
-#include "rawpdu.h"
-#include "macros.h"
-#include "handshake_capturer.h"
+#include <tins/macros.h>
+#include <tins/handshake_capturer.h>
 
 namespace Tins {
 
 class PDU;
 class Dot11;
 class Dot11Data;
+class SNAP;
+class RawPDU;
 
 namespace Crypto {
 
-struct RC4Key;
-
 #ifdef TINS_HAVE_WPA2_DECRYPTION
 namespace WPA2 {
 
@@ -131,7 +127,6 @@ public:
 private:
     SNAP* ccmp_decrypt_unicast(const Dot11Data& dot11, RawPDU& raw) const;
     SNAP* tkip_decrypt_unicast(const Dot11Data& dot11, RawPDU& raw) const;
-    RC4Key generate_rc4_key(const Dot11Data& dot11, const RawPDU& raw) const;
 
     ptk_type ptk_;
     bool is_ccmp_;
@@ -177,27 +172,6 @@ private:
 } // WPA2
 #endif // TINS_HAVE_WPA2_DECRYPTION
 
-/**
- * \brief RC4 Key abstraction.
- */
-struct RC4Key {
-    static const size_t data_size = 256;
-
-    /**
-     * \brief Initializes the key using the provided iterator range.
-     * 
-     * \param start The start of the range.
-     * \param end The end of the range.
-     */
-    template<typename ForwardIterator>
-    RC4Key(ForwardIterator start, ForwardIterator end);
-
-    /**
-     * The actual key data.
-     */
-    uint8_t data[data_size];
-};
-
 /**
  * \brief Decrypts WEP-encrypted traffic.
  */
@@ -499,20 +473,6 @@ private:
     decrypter_type decrypter_;
 };
 
-/**
- * \brief Performs RC4 encription/decryption of the given byte range,
- * using the provided key.
- * 
- * The decrypted range will be copied to the OutputIterator provided.
- * 
- * \param start The beginning of the range.
- * \param start The end of the range.
- * \param key The key to be used.
- * \param output The iterator in which to write the output.
- */
-template<typename ForwardIterator, typename OutputIterator>
-void rc4(ForwardIterator start, ForwardIterator end, RC4Key& key, OutputIterator output);
-
 /**
  * \brief Wrapper function to create a DecrypterProxy using a 
  * WEPDecrypter as the Decrypter template parameter.
@@ -570,35 +530,6 @@ DecrypterProxy<Functor, WEPDecrypter> make_wep_decrypter_proxy(const Functor& fu
     return DecrypterProxy<Functor, WEPDecrypter>(functor);
 }
 
-// RC4 stuff
-
-template<typename ForwardIterator>
-RC4Key::RC4Key(ForwardIterator start, ForwardIterator end) {
-    for (size_t i = 0; i < data_size; ++i) {
-        data[i] = static_cast<uint8_t>(i);
-    }
-    size_t j = 0;
-    ForwardIterator iter = start;
-    for (size_t i = 0; i < data_size; ++i) {
-        j = (j + data[i] + *iter++) % 256;
-        if(iter == end) {
-            iter = start;
-        }
-        std::swap(data[i], data[j]);
-    }
-}
-
-template<typename ForwardIterator, typename OutputIterator>
-void rc4(ForwardIterator start, ForwardIterator end, RC4Key& key, OutputIterator output) {
-    size_t i = 0, j = 0;
-    while (start != end) {
-        i = (i + 1) % RC4Key::data_size;
-        j = (j + key.data[i]) % RC4Key::data_size;
-        std::swap(key.data[i], key.data[j]);
-        *output++ = *start++ ^ key.data[(key.data[i] + key.data[j]) % RC4Key::data_size];
-    }
-}
-
 } // Crypto
 } // Tins
 

include/tins/cxxstd.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,9 +30,7 @@
 #ifndef TINS_CXXSTD_H
 #define TINS_CXXSTD_H
 
-#include "config.h"
-
-#include <memory>
+#include <tins/config.h>
 
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
     #define TINS_CXXSTD_GCC_FIX 1
@@ -48,14 +46,7 @@
 
 namespace Tins{
 namespace Internals {
-template<typename T>
-struct smart_ptr {
-#if TINS_IS_CXX11
-    typedef std::unique_ptr<T> type;
-#else
-    typedef std::auto_ptr<T> type;
-#endif
-};
+template<class T> void unused(const T&) { }
 }
 }
 

include/tins/data_link_type.h

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

include/tins/detail/address_helpers.h

@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2017, 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_ADDRESS_HELPERS_H
+#define TINS_ADDRESS_HELPERS_H
+
+#include <tins/hw_address.h>
+
+/**
+ * \cond
+ */
+namespace Tins {
+
+class IPv4Address;
+class IPv6Address;
+
+namespace Internals {
+
+template<typename T>
+bool increment_buffer(T& addr) {
+    typename T::iterator it = addr.end() - 1;
+    while (it >= addr.begin() && *it == 0xff) {
+        *it = 0;
+        --it;
+    }
+    // reached end
+    if (it < addr.begin()) {
+        return true;
+    }
+    (*it)++;
+    return false;
+}
+
+template<typename T>
+bool decrement_buffer(T& addr) {
+    typename T::iterator it = addr.end() - 1;
+    while (it >= addr.begin() && *it == 0) {
+        *it = 0xff;
+        --it;
+    }
+    // reached end
+    if (it < addr.begin()) {
+        return true;
+    }
+    (*it)--;
+    return false;
+}
+
+bool increment(IPv4Address& addr);
+bool increment(IPv6Address& addr);
+bool decrement(IPv4Address& addr);
+bool decrement(IPv6Address& addr);
+template<size_t n>
+bool increment(HWAddress<n>& addr) {
+    return increment_buffer(addr);
+}
+template<size_t n>
+bool decrement(HWAddress<n>& addr) {
+    return decrement_buffer(addr);
+}
+
+IPv4Address last_address_from_mask(IPv4Address addr, IPv4Address mask);
+IPv6Address last_address_from_mask(IPv6Address addr, const IPv6Address& mask);
+template<size_t n>
+HWAddress<n> last_address_from_mask(HWAddress<n> addr, const HWAddress<n>& mask) {
+    typename HWAddress<n>::iterator addr_iter = addr.begin();
+    for (typename HWAddress<n>::const_iterator it = mask.begin(); it != mask.end(); ++it, ++addr_iter) {
+        *addr_iter = *addr_iter | ~*it;
+    }
+    return addr;
+}
+
+} // Internals
+} // Tins
+
+/**
+ * \endcond
+ */
+
+#endif // TINS_ADDRESS_HELPERS_H

include/tins/detail/icmp_extension_helpers.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2017, 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_ICMP_EXTENSION_HELPERS_H
+#define TINS_ICMP_EXTENSION_HELPERS_H
+
+#include <stdint.h>
+
+/**
+ * \cond
+ */
+namespace Tins {
+
+class PDU;
+class ICMPExtensionsStructure;
+
+namespace Memory {
+class InputMemoryStream;
+} // Memory
+
+namespace Internals {
+
+uint32_t get_padded_icmp_inner_pdu_size(const PDU* inner_pdu, uint32_t pad_alignment);
+void try_parse_icmp_extensions(Memory::InputMemoryStream& stream, uint32_t payload_length,
+                               ICMPExtensionsStructure& extensions);
+
+
+} // Internals
+} // Tins
+
+/**
+ * \endcond
+ */
+
+#endif // TINS_ICMP_EXTENSION_HELPERS_H

include/tins/detail/pdu_helpers.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2017, 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_HELPERS_H
+#define TINS_PDU_HELPERS_H
+
+#include <tins/constants.h>
+#include <tins/config.h>
+#include <tins/pdu.h>
+
+/**
+ * \cond
+ */
+
+namespace Tins {
+namespace Internals {
+
+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);
+#ifdef TINS_HAVE_PCAP
+PDU* pdu_from_dlt_flag(int flag, const uint8_t* buffer,
+                       uint32_t size, bool rawpdu_on_no_match = true);
+#endif // TINS_HAVE_PCAP
+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);
+PDU::PDUType ether_type_to_pdu_flag(Constants::Ethernet::e flag);
+Constants::IP::e pdu_flag_to_ip_type(PDU::PDUType flag);
+PDU::PDUType ip_type_to_pdu_flag(Constants::IP::e flag);
+
+inline bool is_dot3(const uint8_t* ptr, size_t sz) {
+    return (sz >= 13 && ptr[12] < 8);
+}
+
+} // Internals
+} // Tins
+
+/**
+ * \endcond
+ */
+
+#endif // TINS_PDU_HELPERS_H

include/tins/detail/sequence_number_helpers.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2017, 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_SEQUENCE_NUMBER_HELPERS_H
+#define TINS_SEQUENCE_NUMBER_HELPERS_H
+
+#include <stdint.h>
+/**
+ * \cond
+ */
+namespace Tins {
+namespace Internals {
+
+// Compares sequence numbers as defined by RFC 1982.
+int seq_compare(uint32_t seq1, uint32_t seq2);
+
+} // namespace Internals
+} // namespace Tins
+/**
+ * \endcond
+ */
+
+#endif // TINS_SEQUENCE_NUMBER_HELPERS_H

include/tins/detail/smart_ptr.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2017, 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_SMART_PTR_H
+#define TINS_SMART_PTR_H
+
+#include <memory>
+#include <tins/cxxstd.h>
+
+namespace Tins {
+namespace Internals {
+
+template<typename T>
+struct smart_ptr {
+#if TINS_IS_CXX11
+    typedef std::unique_ptr<T> type;
+#else
+    typedef std::auto_ptr<T> type;
+#endif
+};
+
+} // Internals
+} // Tins
+
+#endif // TINS_SMART_PTR_H

include/tins/detail/type_traits.h

@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2017, 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_TYPE_TRAITS_H
+#define TINS_TYPE_TRAITS_H
+
+#include <stdint.h>
+#include <tins/cxxstd.h>
+#if TINS_IS_CXX11
+    #include <type_traits>
+    #include <utility>
+#endif
+
+namespace Tins {
+namespace Internals {
+/**
+ * \cond
+ */
+
+template<bool, typename T = void>
+struct enable_if {
+    typedef T type;
+};
+
+template<typename T>
+struct enable_if<false, T> {
+
+};
+
+template <typename T>
+struct type_to_type {
+    typedef T type;
+};
+
+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 && !defined(_MSC_VER)
+
+// Template metaprogramming trait to determine if a functor can accept another parameter as an argument
+template <typename T, typename P, typename=void>
+struct accepts_type : std::false_type { };
+
+template <typename T, typename P>
+struct accepts_type<T, P,
+    typename std::enable_if<
+        std::is_same< decltype(  std::declval<T>()(std::declval<P>())  ), bool>::value
+    >::type
+> : std::true_type { };
+
+// use enable_if to invoke the Packet&& version of the sniff_loop handler if possible - otherwise fail to old behavior
+template <typename Functor, typename 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 <typename Functor, typename 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 <typename Functor, typename 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
+
+/**
+ * \endcond
+ */
+
+} // Internals
+} // Tins
+
+#endif // TINS_TYPE_TRAITS_H

include/tins/dhcp.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,13 +30,12 @@
 #ifndef TINS_DHCP_H
 #define TINS_DHCP_H
 
-#include <list>
 #include <vector>
 #include <string>
-#include "bootp.h"
-#include "macros.h"
-#include "pdu_option.h"
-#include "cxxstd.h"
+#include <tins/bootp.h>
+#include <tins/macros.h>
+#include <tins/pdu_option.h>
+#include <tins/cxxstd.h>
 
 namespace Tins {
 
@@ -170,7 +169,7 @@ public:
     /**
      * The type used to store the DHCP options.
      */
-    typedef std::list<option> options_type;
+    typedef std::vector<option> options_type;
     
     /**
      * \brief Extracts metadata for this protocol based on the buffer provided
@@ -436,8 +435,7 @@ public:
      * If the option is not found, an option_not_found exception
      * is thrown.
      * 
-     * \return std::list<ipaddress_type> Contanining the DNS servers
-     * provided.
+     * \return The list of DNS servers provided.
      */
     std::vector<ipaddress_type> domain_name_servers() const; 
     
@@ -509,7 +507,7 @@ public:
 private:
     static const uint32_t MAX_DHCP_SIZE;
   
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
 
     template <typename T> 
     T search_and_convert(OptionTypes opt) const {

include/tins/dhcpv6.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,13 +31,12 @@
 #define TINS_DHCPV6_H
 
 #include <cstring>
-#include <list>
-#include "pdu.h"
-#include "macros.h"
-#include "endianness.h"
-#include "small_uint.h"
-#include "ipv6_address.h"
-#include "pdu_option.h"
+#include <tins/pdu.h>
+#include <tins/macros.h>
+#include <tins/endianness.h>
+#include <tins/small_uint.h>
+#include <tins/ipv6_address.h>
+#include <tins/pdu_option.h>
 
 namespace Tins {
 namespace Memory  {
@@ -163,7 +162,7 @@ public:
     /**
      * The type used to store the DHCPv6 options.
      */
-    typedef std::list<option> options_type;
+    typedef std::vector<option> options_type;
 
     /**
      * The type used to store IP addresses.
@@ -392,7 +391,7 @@ public:
         : id(duid_en::duid_id), data(identifier.serialize()) {}
         
         duid_type(const duid_ll& identifier)
-        : id(duid_en::duid_id), data(identifier.serialize()) {}
+        : id(duid_ll::duid_id), data(identifier.serialize()) {}
 
         static duid_type from_option(const option& opt);
     };
@@ -890,7 +889,7 @@ public:
         return new DHCPv6(*this);
     }
 private:
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
     void write_option(const option& option, Memory::OutputMemoryStream& stream) const;
     options_type::const_iterator search_option_iterator(OptionTypes type) const;
     options_type::iterator search_option_iterator(OptionTypes type);
@@ -917,54 +916,8 @@ private:
     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(static_cast<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;
-}
-
-} // Internals 
 } // Tins
 
 #endif // TINS_DHCPV6_H

include/tins/dns.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,14 +31,21 @@
 #define TINS_DNS_H
 
 #include <stdint.h>
-#include <list>
 #include <vector>
 #include <cstring>
 #include <string>
 #include <map>
-#include "macros.h"
-#include "pdu.h"
-#include "endianness.h"
+#include <tins/macros.h>
+#include <tins/pdu.h>
+#include <tins/endianness.h>
+
+// Undefining some macros that conflict with some symbols here. 
+// Eventually, the conflicting names will be removed, but until then
+// this is the best we can do.
+// - IN is defined by winsock2.h
+// - CERT is defined by openssl
+#undef IN
+#undef CERT
 
 namespace Tins {
 namespace Memory {
@@ -130,7 +137,7 @@ public:
         ATMA,
         NAPTR,
         KX,
-        CERT,
+        CERTIFICATE,
         A6,
         DNAM,
         SINK,
@@ -144,13 +151,23 @@ public:
         DNSKEY,
         DHCID,
         NSEC3,
-        NSEC3PARAM
+        NSEC3PARAM,
+        CERT = CERTIFICATE
     };
     
     enum QueryClass {
-        IN = 1,
-        CH = 3,
-        HS = 4,
+        INTERNET = 1,
+        CHAOS    = 3,
+        HESIOD   = 4,
+        /**
+         * \cond
+         */
+        IN = INTERNET,
+        CH = CHAOS,
+        HS = HESIOD,
+        /**
+         * \endcond
+         */
         ANY = 255
     };
     
@@ -166,8 +183,13 @@ public:
          * \param tp The query type.
          * \param cl The query class.
          */
+        #if TINS_IS_CXX11
+        query(std::string nm, QueryType tp, QueryClass cl) 
+        : name_(std::move(nm)), type_(tp), qclass_(cl) {}
+        #else
         query(const std::string& nm, QueryType tp, QueryClass cl) 
         : name_(nm), type_(tp), qclass_(cl) {}
+        #endif
         
         /**
          * \brief Default constructs this Query.
@@ -431,6 +453,16 @@ public:
          * \param rclass The class of this record.
          * \param ttl The time-to-live of this record.
          */
+        #if TINS_IS_CXX11
+        resource(std::string dname, 
+                 std::string data, 
+                 uint16_t type,
+                 uint16_t rclass,
+                 uint32_t ttl,
+                 uint16_t preference = 0) 
+        : dname_(std::move(dname)), data_(std::move(data)), type_(type),
+          qclass_(rclass), ttl_(ttl), preference_(preference) {}
+        #else
         resource(const std::string& dname, 
                  const std::string& data, 
                  uint16_t type,
@@ -439,6 +471,7 @@ public:
                  uint16_t preference = 0) 
         : dname_(dname), data_(data), type_(type), qclass_(rclass), 
           ttl_(ttl), preference_(preference) {}
+        #endif 
         
         resource() : type_(), qclass_(), ttl_(), preference_() {}
         
@@ -584,8 +617,8 @@ public:
     TINS_DEPRECATED(typedef query Query);
     TINS_DEPRECATED(typedef resource Resource);
     
-    typedef std::list<query> queries_type;
-    typedef std::list<resource> resources_type;
+    typedef std::vector<query> queries_type;
+    typedef std::vector<resource> resources_type;
     typedef IPv4Address address_type;
     typedef IPv6Address address_v6_type;
     
@@ -1012,7 +1045,7 @@ private:
     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 write_serialization(uint8_t* buffer, uint32_t total_sz);
     void add_record(const resource& resource, const sections_type& sections);
     
     dns_header header_;

include/tins/dot11.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,18 +27,18 @@
  *
  */
 
-#include "config.h"
+#include <tins/config.h>
 
 #if !defined(TINS_DOT_11) && defined(TINS_HAVE_DOT11)
 #define TINS_DOT_11
 
-#include "dot11/dot11_base.h"
-#include "dot11/dot11_data.h"
-#include "dot11/dot11_mgmt.h"
-#include "dot11/dot11_beacon.h"
-#include "dot11/dot11_assoc.h"
-#include "dot11/dot11_auth.h"
-#include "dot11/dot11_probe.h"
-#include "dot11/dot11_control.h"
+#include <tins/dot11/dot11_base.h>
+#include <tins/dot11/dot11_data.h>
+#include <tins/dot11/dot11_mgmt.h>
+#include <tins/dot11/dot11_beacon.h>
+#include <tins/dot11/dot11_assoc.h>
+#include <tins/dot11/dot11_auth.h>
+#include <tins/dot11/dot11_probe.h>
+#include <tins/dot11/dot11_control.h>
 
 #endif // TINS_DOT_11

include/tins/dot11/CMakeLists.txt

@@ -1,6 +0,0 @@
-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) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,13 +27,13 @@
  *
  */
 
-#include "../config.h"
+#include <tins/config.h>
 
 #if !defined(TINS_DOT11_DOT11_ASSOC_H) && defined(TINS_HAVE_DOT11)
 #define TINS_DOT11_DOT11_ASSOC_H
 
-#include "../dot11/dot11_mgmt.h"
-#include "../macros.h"
+#include <tins/dot11/dot11_mgmt.h>
+#include <tins/macros.h>
 
 namespace Tins {
 /**

include/tins/dot11/dot11_auth.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,13 +27,13 @@
  *
  */
 
-#include "../config.h"
+#include <tins/config.h>
 
 #if !defined(TINS_DOT11_DOT11_AUTH_H) && defined(TINS_HAVE_DOT11)
 #define TINS_DOT11_DOT11_AUTH_H
 
-#include "../dot11/dot11_mgmt.h"
-#include "../macros.h"
+#include <tins/dot11/dot11_mgmt.h>
+#include <tins/macros.h>
 
 namespace Tins {
 /**

include/tins/dot11/dot11_base.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,19 +27,18 @@
  *
  */ 
 
-#include "../config.h"
+#include <tins/config.h>
 
 #if !defined(TINS_DOT11_DOT11_H) && defined(TINS_HAVE_DOT11)
 #define TINS_DOT11_DOT11_H
 
-#include <list>
-#include "../pdu.h"
-#include "../pdu_option.h"
-#include "../small_uint.h"
-#include "../hw_address.h"
-#include "../endianness.h"
-#include "../cxxstd.h"
-#include "../macros.h"
+#include <tins/pdu.h>
+#include <tins/pdu_option.h>
+#include <tins/small_uint.h>
+#include <tins/hw_address.h>
+#include <tins/endianness.h>
+#include <tins/cxxstd.h>
+#include <tins/macros.h>
 
 namespace Tins {
 namespace Memory {
@@ -67,7 +66,7 @@ public:
     /**
      * The type used to store tagged options.
      */
-    typedef std::list<option> options_type;
+    typedef std::vector<option> options_type;
 
     /**
      * \brief This PDU's flag.
@@ -280,6 +279,15 @@ public:
         return header_.control.power_mgmt;
     }
 
+    /**
+     * \brief Getter for the More Data field.
+     *
+     * \return The stored More Data field.
+     */
+    small_uint<1> more_data() const {
+        return header_.control.more_data;
+    }
+
     /**
      * \brief Getter for the WEP field.
      *
@@ -374,6 +382,13 @@ public:
      */
     void power_mgmt(small_uint<1> new_value);
 
+    /**
+     * \brief Setter for the More Data field.
+     *
+     * \param new_value The new More Data field value.
+     */
+    void more_data(small_uint<1> new_value);
+
     /**
      * \brief Setter for the WEP field.
      *
@@ -508,8 +523,8 @@ public:
      */
     static Dot11* from_bytes(const uint8_t* buffer, uint32_t total_sz);
 protected:
-    virtual void write_ext_header(Memory::OutputMemoryStream& stream) { }
-    virtual void write_fixed_parameters(Memory::OutputMemoryStream& stream) { }
+    virtual void write_ext_header(Memory::OutputMemoryStream& stream);
+    virtual void write_fixed_parameters(Memory::OutputMemoryStream& stream);
     void parse_tagged_parameters(Memory::InputMemoryStream& stream);
     void add_tagged_option(OptionTypes opt, uint8_t len, const uint8_t* val);
 protected:
@@ -554,7 +569,7 @@ private:
     Dot11(const dot11_header* header_ptr);
     
     void internal_add_option(const option& opt);
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
     options_type::const_iterator search_option_iterator(OptionTypes type) const;
     options_type::iterator search_option_iterator(OptionTypes type);
 

include/tins/dot11/dot11_beacon.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,13 +27,13 @@
  *
  */    
 
-#include "../config.h"
+#include <tins/config.h>
 
 #if !defined(TINS_DOT11_DOT11_BEACON_H) && defined(TINS_HAVE_DOT11)
 #define TINS_DOT11_DOT11_BEACON_H
 
-#include "../dot11/dot11_mgmt.h"
-#include "../macros.h"
+#include <tins/dot11/dot11_mgmt.h>
+#include <tins/macros.h>
 
 namespace Tins {
 

include/tins/dot11/dot11_control.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,14 +27,14 @@
  *
  */
 
-#include "../config.h"
+#include <tins/config.h>
 
 #if !defined(TINS_DOT11_DOT11_CONTROL_H) && defined(TINS_HAVE_DOT11)
 
 #define TINS_DOT11_DOT11_CONTROL_H
 
-#include "../dot11/dot11_base.h"
-#include "../macros.h"
+#include <tins/dot11/dot11_base.h>
+#include <tins/macros.h>
 
 namespace Tins {
 /**

include/tins/dot11/dot11_data.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,13 +27,13 @@
  *
  */
 
-#include "../config.h"
+#include <tins/config.h>
 
 #if !defined(TINS_DOT11_DOT11_DATA_H) && defined(TINS_HAVE_DOT11)
 #define TINS_DOT11_DOT11_DATA_H
 
-#include "../dot11/dot11_base.h"
-#include "../macros.h"
+#include <tins/dot11/dot11_base.h>
+#include <tins/macros.h>
 
 namespace Tins {
 

include/tins/dot11/dot11_mgmt.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,7 +27,7 @@
  *
  */
 
-#include "../config.h"
+#include <tins/config.h>
 
 #if !defined(TINS_DOT11_DOT11_MGMT_H) && defined(TINS_HAVE_DOT11)
 
@@ -35,8 +35,8 @@
 
 #include <vector>
 #include <utility>
-#include "../dot11/dot11_base.h"
-#include "../macros.h"
+#include <tins/dot11/dot11_base.h>
+#include <tins/macros.h>
 
 namespace Tins {
 /**
@@ -463,7 +463,8 @@ public:
         uint16_t dwell_time;
         uint8_t hop_set, hop_pattern, hop_index;
         
-        fh_params_set() {}
+        fh_params_set()
+        : dwell_time(0), hop_set(0), hop_pattern(0), hop_index(0) {}
         
         fh_params_set(uint16_t dwell_time, 
                       uint8_t hop_set, 
@@ -482,7 +483,8 @@ public:
         uint8_t cfp_count, cfp_period;
         uint16_t cfp_max_duration, cfp_dur_remaining;
         
-        cf_params_set() {}
+        cf_params_set()
+        : cfp_count(0), cfp_period(0), cfp_max_duration(0), cfp_dur_remaining(0) {}
         
         cf_params_set(uint8_t cfp_count, 
                       uint8_t cfp_period,
@@ -505,7 +507,7 @@ public:
         uint8_t recovery_interval; 
         channel_map_type channel_map;
        
-        ibss_dfs_params() {}
+        ibss_dfs_params() : recovery_interval(0) {}
        
         ibss_dfs_params(const address_type& addr, 
                         uint8_t recovery_interval,
@@ -547,7 +549,8 @@ public:
         uint8_t flag, number_of_sets, modulus, offset;
         byte_array random_table;
         
-        fh_pattern_type() {}
+        fh_pattern_type()
+        : flag(0), number_of_sets(0), modulus(0), offset(0) {}
         
         fh_pattern_type(uint8_t flag, 
                         uint8_t sets,
@@ -566,7 +569,8 @@ public:
     struct channel_switch_type {
         uint8_t switch_mode, new_channel, switch_count;
         
-        channel_switch_type() {}
+        channel_switch_type()
+        : switch_mode(0), new_channel(0), switch_count(0) {}
         
         channel_switch_type(uint8_t mode, 
                             uint8_t channel,
@@ -583,7 +587,8 @@ public:
         uint8_t quiet_count, quiet_period;
         uint16_t quiet_duration, quiet_offset;
         
-        quiet_type() {}
+        quiet_type() 
+        : quiet_count(0), quiet_period(0), quiet_duration(0), quiet_offset(0) {}
         
         quiet_type(uint8_t count, 
                    uint8_t period,
@@ -603,7 +608,8 @@ public:
         uint16_t available_capacity;
         uint8_t channel_utilization;
         
-        bss_load_type() {}
+        bss_load_type() 
+        : station_count(0), available_capacity(0), channel_utilization(0) {}
         
         bss_load_type(uint16_t count, uint8_t utilization, uint16_t capacity) 
         : station_count(count), available_capacity(capacity),
@@ -619,7 +625,8 @@ public:
         uint8_t dtim_count, dtim_period, bitmap_control;
         byte_array partial_virtual_bitmap;
         
-        tim_type() {}
+        tim_type()
+        : dtim_count(0), dtim_period(0), bitmap_control(0) {}
         
         tim_type(uint8_t count, 
                  uint8_t period,

include/tins/dot11/dot11_probe.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,14 +27,14 @@
  *
  */
 
-#include "../config.h"
+#include <tins/config.h>
 
 #if !defined(TINS_DOT11_DOT11_PROBE_H) && defined(TINS_HAVE_DOT11)
 
 #define TINS_DOT11_DOT11_PROBE_H
 
-#include "../dot11/dot11_mgmt.h"
-#include "../macros.h"
+#include <tins/dot11/dot11_mgmt.h>
+#include <tins/macros.h>
 
 namespace Tins {
 /**

include/tins/dot1q.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,10 +30,10 @@
 #ifndef TINS_DOT1Q_H
 #define TINS_DOT1Q_H
 
-#include "pdu.h"
-#include "macros.h"
-#include "endianness.h"
-#include "small_uint.h"
+#include <tins/pdu.h>
+#include <tins/macros.h>
+#include <tins/endianness.h>
+#include <tins/small_uint.h>
 
 namespace Tins {
 
@@ -197,7 +197,7 @@ public:
      */
     bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;
 private:
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
 
     TINS_BEGIN_PACK
     struct dot1q_header {

include/tins/dot3.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,11 +31,11 @@
 #define TINS_DOT3_H
 
 #include <stdint.h>
-#include "macros.h"
-#include "pdu.h"
-#include "config.h"
-#include "endianness.h"
-#include "hw_address.h"
+#include <tins/macros.h>
+#include <tins/pdu.h>
+#include <tins/config.h>
+#include <tins/endianness.h>
+#include <tins/hw_address.h>
 
 namespace Tins {
 
@@ -199,7 +199,7 @@ private:
         uint16_t length;
     } TINS_END_PACK;
 
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
 
     dot3_header header_;
 };

include/tins/eapol.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,10 +31,10 @@
 #define TINS_EAPOL_H
 
 #include <stdint.h>
-#include "pdu.h"
-#include "macros.h"
-#include "small_uint.h"
-#include "endianness.h"
+#include <tins/pdu.h>
+#include <tins/macros.h>
+#include <tins/small_uint.h>
+#include <tins/endianness.h>
 
 namespace Tins {
 namespace Memory {
@@ -185,13 +185,7 @@ protected:
      */
     virtual void write_body(Memory::OutputMemoryStream& stream) = 0;
 private:
-    /** 
-     * \brief Serialices this EAPOL PDU.
-     * \param buffer The buffer in which the PDU will be serialized.
-     * \param total_sz The size available in the buffer.
-     * \param parent The PDU that's one level below this one on the stack.
-     */
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
 
     eapol_header header_;
 };

include/tins/endianness.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,7 +31,7 @@
 #define TINS_ENDIANNESS_H
 
 #include <stdint.h>
-#include "macros.h"
+#include <tins/macros.h>
 
 #if defined(__APPLE__)
     #include <sys/types.h>

include/tins/ethernetII.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,11 +31,11 @@
 #define TINS_ETHERNET_II_H
 
 #include <stdint.h>
-#include "macros.h"
-#include "pdu.h"
-#include "config.h"
-#include "endianness.h"
-#include "hw_address.h"
+#include <tins/macros.h>
+#include <tins/pdu.h>
+#include <tins/config.h>
+#include <tins/endianness.h>
+#include <tins/hw_address.h>
 
 namespace Tins {
 
@@ -208,7 +208,7 @@ private:
         uint16_t payload_type;
     } TINS_END_PACK;
     
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
 
     ethernet_header header_;
 };

include/tins/exceptions.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -45,6 +45,9 @@ public:
 
     exception_base(const std::string& message) 
     : std::runtime_error(message) { }
+
+    exception_base(const char* message) 
+    : std::runtime_error(message) { }
 };
 
 /**
@@ -52,10 +55,7 @@ public:
  */
 class option_not_found : public exception_base {
 public:
-    // try to avoid allocations by doing this.
-    const char* what() const throw() {
-        return "Option not found";
-    }
+    option_not_found() : exception_base("Option not found") { }
 };
 
 /**
@@ -63,9 +63,7 @@ public:
  */
 class malformed_packet : public exception_base {
 public:
-    const char* what() const throw() {
-        return "Malformed packet";
-    }
+    malformed_packet() : exception_base("Malformed packet") { }
 };
 
 /**
@@ -73,9 +71,7 @@ public:
  */
 class serialization_error : public exception_base {
 public:
-    const char* what() const throw() {
-        return "Serialization error";
-    }
+    serialization_error() : exception_base("Serialization error") { }
 };
 
 /**
@@ -83,9 +79,7 @@ public:
  */
 class pdu_not_found : public exception_base {
 public:
-    const char* what() const throw() {
-        return "PDU not found";
-    }
+    pdu_not_found() : exception_base("PDU not found") { }
 };
 
 /**
@@ -94,9 +88,7 @@ public:
  */
 class invalid_interface : public exception_base {
 public:
-    const char* what() const throw() {
-        return "Invalid interface";
-    }
+    invalid_interface() : exception_base("Invalid interface") { }
 };
 
 /**
@@ -105,9 +97,15 @@ public:
  */
 class invalid_address : public exception_base {
 public:
-    const char* what() const throw() {
-        return "Invalid address";
-    }
+    invalid_address() : exception_base("Invalid address") { }
+};
+
+/**
+ * \brief Exception thrown when a PDU option is set using an incorrect value
+ */
+class invalid_option_value : public exception_base {
+public:
+    invalid_option_value() : exception_base("Invalid option value") { }
 };
 
 /**
@@ -115,9 +113,7 @@ public:
  */
 class field_not_present : public exception_base {
 public:
-    const char* what() const throw() {
-        return "Field not present";
-    }
+    field_not_present() : exception_base("Field not present") { }
 };
 
 /**
@@ -132,7 +128,7 @@ public:
 /**
  * \brief Exception thrown when PacketSender fails to close a socket.
  */
-class socket_close_error : exception_base {
+class socket_close_error : public exception_base {
 public:
     socket_close_error(const std::string& msg)
     : exception_base(msg) { }
@@ -153,9 +149,7 @@ public:
  */
 class invalid_socket_type : public exception_base {
 public:
-    const char* what() const throw() {
-        return "The provided socket type is invalid";
-    }
+    invalid_socket_type() : exception_base("The provided socket type is invalid") { }
 };
 
 /**
@@ -164,9 +158,7 @@ public:
  */
 class unknown_link_type : public exception_base {
 public:
-    const char* what() const throw() {
-        return "The sniffed link layer PDU type is unknown";
-    }
+    unknown_link_type() : exception_base("The sniffed link layer PDU type is unknown") { }
 };
 
 /**
@@ -174,9 +166,7 @@ public:
  */
 class malformed_option : public exception_base {
 public:
-    const char* what() const throw() {
-        return "Malformed option";
-    }
+    malformed_option() : exception_base("Malformed option") { }
 };
 
 /**
@@ -184,9 +174,7 @@ public:
  */
 class bad_tins_cast : public exception_base {
 public:
-    const char* what() const throw() {
-        return "Bad Tins cast";
-    }
+    bad_tins_cast() : exception_base("Bad Tins cast") { }
 };
 
 /**
@@ -195,9 +183,7 @@ public:
  */
 class protocol_disabled : public exception_base {
 public:
-    const char* what() const throw() {
-        return "Protocol disabled";
-    }
+    protocol_disabled() : exception_base("Protocol disabled") { }
 };
 
 /**
@@ -206,9 +192,7 @@ public:
  */
 class feature_disabled : public exception_base {
 public:
-    const char* what() const throw() {
-        return "Feature disabled";
-    }
+    feature_disabled() : exception_base("Feature disabled") { }
 };
 
 /**
@@ -217,9 +201,16 @@ public:
  */
 class option_payload_too_large : public exception_base {
 public:
-    const char* what() const throw() {
-        return "Option payload too large";
-    }
+    option_payload_too_large() : exception_base("Option payload too large") { }
+};
+
+/**
+ * \brief Exception thrown when an IPv6 extension header is being
+ * created from invalid data
+ */
+class invalid_ipv6_extension_header : public exception_base {
+public:
+    invalid_ipv6_extension_header() : exception_base("Invalid IPv6 extension header") { }
 };
 
 /**
@@ -230,6 +221,10 @@ public:
     pcap_error(const char* message) : exception_base(message) {
 
     }
+
+    pcap_error(const std::string& message) : exception_base(message) {
+
+    }
 };
 
 /**
@@ -248,9 +243,7 @@ public:
  */
 class pdu_not_serializable : public exception_base {
 public:
-    const char* what() const throw() {
-        return "PDU not serializable";
-    }
+    pdu_not_serializable() : exception_base("PDU not serializable") { }
 };
 
 /**
@@ -258,9 +251,7 @@ public:
  */
 class pcap_open_failed : public exception_base {
 public:
-    const char* what() const throw() {
-        return "Failed to create pcap handle";
-    }
+    pcap_open_failed() : exception_base("Failed to create pcap handle") { }
 };
 
 /**
@@ -269,9 +260,7 @@ public:
  */
 class unsupported_function : public exception_base {
 public:
-    const char* what() const throw() {
-        return "Function is not supported on this OS";
-    }
+    unsupported_function() : exception_base("Function is not supported on this OS") { }
 };
 
 /**
@@ -279,9 +268,7 @@ public:
  */
 class invalid_domain_name : public exception_base {
 public:
-    const char* what() const throw() {
-        return "Invalid domain name";
-    }
+    invalid_domain_name() : exception_base("Invalid domain name") { }
 };
 
 /**
@@ -289,9 +276,7 @@ public:
  */
 class stream_not_found : public exception_base {
 public:
-    const char* what() const throw() {
-        return "Stream not found";
-    }
+    stream_not_found() : exception_base("Stream not found") { }
 };
 
 /**
@@ -299,9 +284,7 @@ public:
  */
 class callback_not_set : public exception_base {
 public:
-    const char* what() const throw() {
-        return "Callback not set";
-    }
+    callback_not_set() : exception_base("Callback not set") { }
 };
 
 /**
@@ -309,9 +292,7 @@ public:
  */
 class invalid_packet : public exception_base {
 public:
-    const char* what() const throw() {
-        return "Invalid packet";
-    }
+    invalid_packet() : exception_base("Invalid packet") { }
 };
 
 namespace Crypto {
@@ -321,9 +302,7 @@ namespace WPA2 {
      */
     class invalid_handshake : public exception_base {
     public:
-        const char* what() const throw() {
-            return "Invalid WPA2 handshake";
-        }
+        invalid_handshake() : exception_base("Invalid WPA2 handshake") { }
     };
 } // WPA2
 } // Crypto

include/tins/handshake_capturer.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,7 +27,7 @@
  *
  */
 
-#include "config.h"
+#include <tins/config.h>
 
 #if !defined(TINS_HANDSHAKE_CAPTURER_H) && defined(TINS_HAVE_DOT11)
 #define TINS_HANDSHAKE_CAPTURER_H
@@ -35,9 +35,9 @@
 #include <vector>
 #include <map>
 #include <utility>
-#include "hw_address.h"
-#include "macros.h"
-#include "eapol.h"
+#include <tins/hw_address.h>
+#include <tins/macros.h>
+#include <tins/eapol.h>
 
 namespace Tins {
 

include/tins/hw_address.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,15 +31,41 @@
 #define TINS_HWADDRESS_H
 
 #include <stdint.h>
-#include <stdexcept>
-#include <iterator>
-#include <algorithm>
-#include <iomanip>
-#include <iostream>
-#include <sstream>
-#include "cxxstd.h"
+#include <iosfwd>
+#include <string>
+#include <cstring>
+#include <tins/cxxstd.h>
+#include <tins/macros.h>
+#if TINS_IS_CXX11
+    // std::hash
+    #include <memory>
+#endif // TINS_IS_CXX11
 
 namespace Tins {
+namespace Internals {
+
+// Defined in hw_address.cpp
+/**
+ * \cond
+ */
+TINS_API std::string hw_address_to_string(const uint8_t* ptr, size_t count);
+
+TINS_API void string_to_hw_address(const std::string& hw_addr, uint8_t* output,
+                                   size_t output_size);
+
+TINS_API bool hw_address_equal_compare(const uint8_t* start1, const uint8_t* end1,
+                                      const uint8_t* start2);
+
+TINS_API bool hw_address_lt_compare(const uint8_t* start1, const uint8_t* end1,
+                                    const uint8_t* start2, const uint8_t* end2);
+
+TINS_API bool hw_address_gt_compare(const uint8_t* start1, const uint8_t* end1,
+                                    const uint8_t* start2, const uint8_t* end2);
+
+/**
+ * \endcond
+ */
+} // Internals
 
 /**
  * \class HWAddress
@@ -61,15 +87,13 @@ namespace Tins {
  * }
  * \endcode
  */
-template<size_t n, typename Storage = uint8_t>
+template<size_t n>
 class HWAddress {
 public:
     /**
      * \brief The type of the elements stored in the hardware address.
-     * 
-     * This is the same as the template parameter Storage.
      */
-    typedef Storage storage_type;
+    typedef uint8_t storage_type;
     
     /**
      * \brief The random access iterator type.
@@ -90,7 +114,7 @@ public:
     /**
      * \brief The broadcast address.
      */
-    static const HWAddress<n, Storage> broadcast;
+    static const HWAddress<n> broadcast;
     
     /**
      * \brief Constructor from a const storage_type*.
@@ -109,10 +133,10 @@ public:
      */
     HWAddress(const storage_type* ptr = 0) {
         if (ptr) {
-            std::copy(ptr, ptr + address_size, buffer_);
+            std::memcpy(buffer_, ptr, address_size);
         }
         else {
-            std::fill(begin(), end(), storage_type());
+            std::memset(buffer_, 0, address_size);
         }
     }
     
@@ -128,7 +152,7 @@ public:
      * \param address The hex-notation address to be parsed.
      */
     HWAddress(const std::string& address) {
-        convert(address, buffer_);
+        Internals::string_to_hw_address(address, buffer_, n);
     }
     
     /**
@@ -146,7 +170,7 @@ public:
      */
     template<size_t i>
     HWAddress(const char (&address)[i]) {
-        convert(address, buffer_);
+        Internals::string_to_hw_address(address, buffer_, n);
     }
     
     /**
@@ -163,18 +187,15 @@ public:
      */
     template<size_t i>
     HWAddress(const HWAddress<i>& rhs) {
-        // Fill extra bytes
-        std::fill(
-            // Copy as most as we can
-            std::copy(
-                rhs.begin(),
-                rhs.begin() + std::min(i, n),
-                begin()
-            ),
-            end(),
-            0
-        );
-        
+        size_t copy_threshold = i < n ? i : n;
+        for (size_t index = 0; index < n; ++index) {
+            if (index < copy_threshold) {
+                buffer_[index] = rhs[index];
+            }
+            else {
+                buffer_[index] = storage_type();
+            }
+        }
     }
     
     /**
@@ -225,7 +246,7 @@ public:
      * \return bool indicating whether addresses are equal.
      */
     bool operator==(const HWAddress& rhs) const {
-        return std::equal(begin(), end(), rhs.begin());
+        return Internals::hw_address_equal_compare(begin(), end(), rhs.begin());
     }
     
     /**
@@ -247,15 +268,88 @@ public:
      * \return bool indicating whether this address is less-than rhs.
      */
     bool operator<(const HWAddress& rhs) const {
-        return std::lexicographical_compare(begin(), end(), rhs.begin(), rhs.end());
+        return Internals::hw_address_lt_compare(begin(), end(), rhs.begin(), rhs.end());
     }
-    
+
+    /**
+     * \brief Compares this HWAddress for less-than equality.
+     *
+     * \param rhs The HWAddress to be compared to.
+     *
+     * \return bool indicating whether this address is equal or less-than rhs.
+     */
+    bool operator<=(const HWAddress& rhs) const {
+        return !operator>(rhs);
+    }
+
+    /**
+     * \brief Compares this HWAddress for greater-than inequality.
+     *
+     * \param rhs The HWAddress to be compared to.
+     *
+     * \return bool indicating whether this address is greater-than rhs.
+     */
+    bool operator>(const HWAddress& rhs) const {
+        return Internals::hw_address_gt_compare(begin(), end(), rhs.begin(), rhs.end());
+    }
+
+    /**
+     * \brief Compares this HWAddress for greater-than equality.
+     *
+     * \param rhs The HWAddress to be compared to.
+     *
+     * \return bool indicating whether this address is equal or greater-than rhs.
+     */
+    bool operator>=(const HWAddress& rhs) const {
+        return !operator<(rhs);
+    }
+
+    /**
+     * \brief Apply a mask to this address
+     * 
+     * \param mask The mask to be applied
+     * \return The result of applying the mask to this address
+     */
+    HWAddress operator&(const HWAddress& mask) const {
+        HWAddress<n> output = *this;
+        for (size_t i = 0; i < n; ++i) {
+            output[i] = output[i] & mask[i];
+        }
+        return output;
+    }
+
+    /**
+    * \brief Apply a mask to this address
+    *
+    * \param mask The mask to be applied
+    * \return The result of applying the mask to this address
+    */
+   HWAddress operator|(const HWAddress& mask) const {
+       HWAddress<n> output = *this;
+       for (size_t i = 0; i < n; ++i) {
+           output[i] = output[i] | mask[i];
+       }
+       return output;
+   }
+
+   /**
+    * \brief not operator
+    * \return The result of applying the mask to this address
+    */
+   HWAddress operator~() const {
+       HWAddress<n> output = *this;
+       for (size_t i = 0; i < n; ++i) {
+           output[i] = ~output[i];
+       }
+       return output;
+   }
+
     /**
      * \brief Retrieves the size of this address.
      * 
      * This effectively returns the address_size constant.
      */
-    const size_t size() const {
+    size_t size() const {
         return address_size;
     }
     
@@ -286,9 +380,7 @@ public:
      * \return std::string containing the hex-notation address.
      */
     std::string to_string() const {
-        std::ostringstream oss;
-        oss <<* this;
-        return oss.str();
+        return Internals::hw_address_to_string(buffer_, size());
     }
 
     /**
@@ -299,6 +391,15 @@ public:
     storage_type operator[](size_t i) const {
         return begin()[i];
     }
+
+    /**
+     * \brief Retrieves the i-th storage_type in this address.
+     *
+     * \param i The element to retrieve.
+     */
+    storage_type& operator[](size_t i) {
+        return begin()[i];
+    }
     
     /**
      * \brief Writes this HWAddress in hex-notation to a std::ostream.
@@ -308,13 +409,7 @@ public:
      * \return std::ostream& pointing to the os parameter.
      */
     friend std::ostream& operator<<(std::ostream& os, const HWAddress& addr) {
-        std::transform(
-            addr.begin(), 
-            addr.end() - 1,
-            std::ostream_iterator<std::string>(os, ":"),
-            &HWAddress::storage_to_string
-        );
-        return os << storage_to_string(addr.begin()[HWAddress::address_size - 1]);
+        return os << addr.to_string();
     }
     
     /**
@@ -340,9 +435,6 @@ public:
         return output;
     }
 private:
-    template<typename OutputIterator>
-    static void convert(const std::string& hw_addr, OutputIterator output);
-    
     static HWAddress<n> make_broadcast_address() {
         // Build a buffer made of n 0xff bytes
         uint8_t buffer[n];
@@ -352,65 +444,11 @@ private:
         return HWAddress<n>(buffer);
     }
 
-    static std::string storage_to_string(storage_type element) {
-        std::ostringstream oss;
-        oss << std::hex;
-        if (element < 0x10) {
-            oss << '0';
-        }
-        oss << (unsigned)element;
-        return oss.str();
-    }
-
     storage_type buffer_[n];
 };
 
-template<size_t n, typename Storage>
-template<typename OutputIterator>
-void HWAddress<n, Storage>::convert(const std::string& hw_addr, 
-                                    OutputIterator output)  {
-    unsigned i(0);
-    size_t count(0);
-    storage_type tmp;
-    while (i < hw_addr.size() && count < n) {
-        const unsigned end = i+2;
-        tmp = storage_type();
-        while (i < end) {
-            if (hw_addr[i] >= 'a' && hw_addr[i] <= 'f') {
-                tmp = (tmp << 4) | (hw_addr[i] - 'a' + 10);
-            }
-            else if (hw_addr[i] >= 'A' && hw_addr[i] <= 'F') {
-                tmp = (tmp << 4) | (hw_addr[i] - 'A' + 10);
-            }
-            else if (hw_addr[i] >= '0' && hw_addr[i] <= '9') {
-                tmp = (tmp << 4) | (hw_addr[i] - '0');
-            }
-            else if (hw_addr[i] == ':') {
-                break;
-            }
-            else {
-                throw std::runtime_error("Invalid byte found");
-            }
-            i++;
-        }
-        *(output++) = tmp;
-        count++;
-        if (i < hw_addr.size()) {
-            if (hw_addr[i] == ':') {
-                i++;
-            }
-            else {
-                throw std::runtime_error("Invalid separator");
-            }
-        }
-    }
-    while (count++ < n) {
-        *(output++) = storage_type();
-    }
-}
-
-template<size_t n, typename Storage>
-const HWAddress<n, Storage> HWAddress<n, Storage>::broadcast = make_broadcast_address();
+template<size_t n>
+const HWAddress<n> HWAddress<n>::broadcast = make_broadcast_address();
 
 } // namespace Tins
 

include/tins/icmp.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -42,11 +42,11 @@
     #endif // TIMESTAMP_REPLY
 #endif // _WIN32
 
-#include "macros.h"
-#include "pdu.h"
-#include "endianness.h"
-#include "ip_address.h"
-#include "icmp_extension.h"
+#include <tins/macros.h>
+#include <tins/pdu.h>
+#include <tins/endianness.h>
+#include <tins/ip_address.h>
+#include <tins/icmp_extension.h>
 
 namespace Tins {
 namespace Memory {
@@ -493,21 +493,16 @@ private:
         } un;
     } TINS_END_PACK;
 
-    void checksum(uint16_t new_check);
-    
-    /** \brief Serialices this ICMP PDU.
-     * \param buffer The buffer in which the PDU will be serialized.
-     * \param total_sz The size available in the buffer.
-     * \param parent The PDU that's one level below this one on the stack.
-     */
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
-    
+    void checksum(uint16_t new_check);    
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
     uint32_t get_adjusted_inner_pdu_size() const;
     void try_parse_extensions(Memory::InputMemoryStream& stream);
     bool are_extensions_allowed() const;
 
     icmp_header header_;
-    uint32_t orig_timestamp_or_address_mask_, recv_timestamp_, trans_timestamp_;
+    uint32_t orig_timestamp_or_address_mask_;
+    uint32_t recv_timestamp_;
+    uint32_t trans_timestamp_;
     ICMPExtensionsStructure extensions_;
 };
 

include/tins/icmp_extension.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,11 +31,10 @@
 #define TINS_ICMP_EXTENSION_H
 
 #include <vector>
-#include <list>
 #include <stdint.h>
-#include "macros.h"
-#include "small_uint.h"
-#include "endianness.h"
+#include <tins/macros.h>
+#include <tins/small_uint.h>
+#include <tins/endianness.h>
 
 namespace Tins {
 
@@ -176,7 +175,7 @@ public:
     /**
      * The type used to store the list of ICMP extensions in this structure
      */
-    typedef std::list<ICMPExtension> extensions_type;
+    typedef std::vector<ICMPExtension> extensions_type;
 
     /**
      * \brief Default constructor

include/tins/icmpv6.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,18 +30,17 @@
 #ifndef TINS_ICMPV6_H
 #define TINS_ICMPV6_H
 
-#include <list>
 #include <vector>
-#include "macros.h"
-#include "pdu.h"
-#include "ipv6_address.h"
-#include "pdu_option.h"
-#include "endianness.h"
-#include "small_uint.h"
-#include "hw_address.h"
-#include "small_uint.h"
-#include "icmp_extension.h"
-#include "cxxstd.h"
+#include <tins/macros.h>
+#include <tins/pdu.h>
+#include <tins/ipv6_address.h>
+#include <tins/pdu_option.h>
+#include <tins/endianness.h>
+#include <tins/small_uint.h>
+#include <tins/hw_address.h>
+#include <tins/small_uint.h>
+#include <tins/icmp_extension.h>
+#include <tins/cxxstd.h>
 
 namespace Tins {
 namespace Memory {
@@ -155,7 +154,7 @@ public:
     /**
      * The type used to store options.
      */
-    typedef std::list<option> options_type;
+    typedef std::vector<option> options_type;
     
     /**
      * \brief The type used to store the new home agent information 
@@ -251,8 +250,8 @@ public:
         uint8_t prefix_len;
         small_uint<1> A, L;
         uint32_t valid_lifetime,
-                preferred_lifetime,
-                reserved2;
+                 preferred_lifetime,
+                 reserved2;
         ipaddress_type prefix;
         
         prefix_info_type(uint8_t prefix_len = 0, 
@@ -262,7 +261,7 @@ public:
                          uint32_t preferred_lifetime = 0,
                          const ipaddress_type& prefix = ipaddress_type())
         : prefix_len(prefix_len), A(A), L(L), valid_lifetime(valid_lifetime),
-          preferred_lifetime(preferred_lifetime), prefix(prefix) { }
+          preferred_lifetime(preferred_lifetime), reserved2(0), prefix(prefix) { }
           
         static prefix_info_type from_option(const option& opt);
     };
@@ -548,13 +547,13 @@ public:
     /*
      * The type used to store all multicast address records in a packet
      */
-    typedef std::list<multicast_address_record> multicast_address_records_list;
+    typedef std::vector<multicast_address_record> multicast_address_records_list;
 
     /*
      * The type used to store all source address (from Multicast 
      * Listener Query messages) in a packet 
      */
-    typedef std::list<ipaddress_type> sources_list;
+    typedef std::vector<ipaddress_type> sources_list;
 
     /**
      * \brief Constructs an ICMPv6 object.
@@ -1115,6 +1114,17 @@ public:
     ICMPv6* clone() const {
         return new ICMPv6(*this);
     }
+
+    /** 
+     * \brief Indicates whether to use MLDv2
+     *
+     * If this is set to true, then MLDv2 will be used rather than MLDv1 when
+     * serializing Multicast Listener Discovery messages. By default,
+     * MLDv2 will be used.
+     *
+     * \param value The value to set
+     */
+    void use_mldv2(bool value);
     
     // ****************************************************************
     //                          Option setters
@@ -1548,7 +1558,7 @@ private:
     } TINS_END_PACK;
     
     void internal_add_option(const option& option);
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
     bool has_options() const;
     void write_option(const option& opt, Memory::OutputMemoryStream& stream);
     void parse_options(Memory::InputMemoryStream& stream);
@@ -1590,6 +1600,7 @@ private:
     multicast_listener_query_message_fields mlqm_;
     sources_list sources_;
     ICMPExtensionsStructure extensions_;
+    bool use_mldv2_;
 };
 
 } // Tins

include/tins/ieee802_3.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,7 +30,7 @@
 #ifndef TINS_IEEE802_3_H
 #define TINS_IEEE802_3_H
 
-#include "dot3.h"
+#include <tins/dot3.h>
 
 namespace Tins {
     typedef Dot3 IEEE802_3;

include/tins/internals.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,232 +30,11 @@
 #ifndef TINS_INTERNALS_H
 #define TINS_INTERNALS_H
 
-#if TINS_IS_CXX11
-#include <type_traits>
-#endif
-
-#include <sstream>
-#include <string>
-#include <stdint.h>
-#include "constants.h"
-#include "pdu.h"
-#include "hw_address.h"
-
-/**
- * \cond
- */
-namespace Tins {
-namespace Memory {
-
-class InputMemoryStream;
-} // Memory
-class IPv4Address;
-class IPv6Address;
-class ICMPExtensionsStructure;
-
-namespace Internals {
-
-template<size_t n>
-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, last, data);
-    }
-
-    template<typename InputIterator>
-    byte_array(InputIterator start) {
-        std::copy(start, n, data);
-    }
-
-    uint8_t& operator[](size_t i) {
-        return data[i];
-    }
-
-    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;
-    }
-private:
-    uint8_t data[n];
-};
-
-void skip_line(std::istream& input);
-bool from_hex(const std::string& str, uint32_t& result);
-
-template<bool, typename T = void>
-struct enable_if {
-    typedef T type;
-};
-
-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);
-PDU::PDUType ether_type_to_pdu_flag(Constants::Ethernet::e flag);
-Constants::IP::e pdu_flag_to_ip_type(PDU::PDUType flag);
-PDU::PDUType ip_type_to_pdu_flag(Constants::IP::e flag);
-
-uint32_t get_padded_icmp_inner_pdu_size(const PDU* inner_pdu, uint32_t pad_alignment);
-void try_parse_icmp_extensions(Memory::InputMemoryStream& stream, 
-    uint32_t payload_length, ICMPExtensionsStructure& extensions);
-
-template<typename T>
-bool increment_buffer(T& addr) {
-    typename T::iterator it = addr.end() - 1;
-    while (it >= addr.begin() && *it == 0xff) {
-        *it = 0;
-        --it;
-    }
-    // reached end
-    if (it < addr.begin()) {
-        return true;
-    }
-    (*it)++;
-    return false;
-}
-
-template<typename T>
-bool decrement_buffer(T& addr) {
-    typename T::iterator it = addr.end() - 1;
-    while (it >= addr.begin() && *it == 0) {
-        *it = 0xff;
-        --it;
-    }
-    // reached end
-    if (it < addr.begin()) {
-        return true;
-    }
-    (*it)--;
-    return false;
-}
-
-bool increment(IPv4Address& addr);
-bool increment(IPv6Address& addr);
-bool decrement(IPv4Address& addr);
-bool decrement(IPv6Address& addr);
-template<size_t n>
-bool increment(HWAddress<n>& addr) {
-    return increment_buffer(addr);
-}
-template<size_t n>
-bool decrement(HWAddress<n>& addr) {
-    return decrement_buffer(addr);
-}
-
-// Compares sequence numbers as defined by RFC 1982.
-int seq_compare(uint32_t seq1, uint32_t seq2);
-
-IPv4Address last_address_from_mask(IPv4Address addr, IPv4Address mask);
-IPv6Address last_address_from_mask(IPv6Address addr, const IPv6Address& mask);
-template<size_t n>
-HWAddress<n> last_address_from_mask(HWAddress<n> addr, const HWAddress<n>& mask) {
-    typename HWAddress<n>::iterator addr_iter = addr.begin();
-    for (typename HWAddress<n>::const_iterator it = mask.begin(); it != mask.end(); ++it, ++addr_iter) {
-        *addr_iter = *addr_iter | ~*it;
-    }
-    return addr;
-}
-
-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 && !defined(_MSC_VER)
-
-// Template metaprogramming trait to determine if a functor can accept another parameter as an argument
-template <typename T, typename P, typename=void>
-struct accepts_type : std::false_type { };
-
-template <typename T, typename P>
-struct accepts_type<T, P, 
-    typename std::enable_if<
-        std::is_same< decltype(  std::declval<T>()(std::declval<P>())  ), bool>::value
-    >::type 
-> : std::true_type { };
-
-// use enable_if to invoke the Packet&& version of the sniff_loop handler if possible - otherwise fail to old behavior
-template <typename Functor, typename 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 <typename Functor, typename 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 <typename Functor, typename 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
-/**
- * \endcond
- */
+#include <tins/detail/type_traits.h>
+#include <tins/detail/address_helpers.h>
+#include <tins/detail/icmp_extension_helpers.h>
+#include <tins/detail/smart_ptr.h>
+#include <tins/detail/pdu_helpers.h>
+#include <tins/detail/sequence_number_helpers.h>
 
 #endif

include/tins/ip.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,14 +30,13 @@
 #ifndef TINS_IP_H
 #define TINS_IP_H
 
-#include <list>
-#include "pdu.h"
-#include "small_uint.h"
-#include "endianness.h"
-#include "ip_address.h"
-#include "pdu_option.h"
-#include "macros.h"
-#include "cxxstd.h"
+#include <tins/pdu.h>
+#include <tins/small_uint.h>
+#include <tins/endianness.h>
+#include <tins/ip_address.h>
+#include <tins/pdu_option.h>
+#include <tins/macros.h>
+#include <tins/cxxstd.h>
 
 namespace Tins {
 namespace Memory {
@@ -244,7 +243,7 @@ public:
     /**
      * The type used to store IP options.
      */
-    typedef std::list<option> options_type;
+    typedef std::vector<option> options_type;
 
     /**
      * \brief Extracts metadata for this protocol based on the buffer provided
@@ -410,7 +409,7 @@ public:
      * \return The stored options.
      */
     const options_type& options() const {
-        return ip_options_;
+        return options_;
     }
 
     /* Setters */
@@ -524,8 +523,7 @@ public:
          * \param opt The option to be added.
          */
         void add_option(option &&opt) {
-            internal_add_option(opt);
-            ip_options_.push_back(std::move(opt));
+            options_.push_back(std::move(opt));
         }
 
         /**
@@ -538,8 +536,7 @@ public:
          */
         template<typename... Args>
         void add_option(Args&&... args) {
-            ip_options_.emplace_back(std::forward<Args>(args)...);
-            internal_add_option(ip_options_.back());
+            options_.emplace_back(std::forward<Args>(args)...);
         }
     #endif
 
@@ -756,21 +753,20 @@ private:
     void head_len(small_uint<4> new_head_len);
     void tot_len(uint16_t new_tot_len);
 
-    void prepare_for_serialize(const PDU* parent);
-    void internal_add_option(const option& option);
+    void prepare_for_serialize();
+    uint32_t calculate_options_size() const;
+    uint32_t pad_options_size(uint32_t size) const;
     void init_ip_fields();
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
     void write_option(const option& opt, Memory::OutputMemoryStream& stream);
     void add_route_option(option_identifier id, const generic_route_option_type& data);
     generic_route_option_type search_route_option(option_identifier id) const;
     void checksum(uint16_t new_check);
     options_type::const_iterator search_option_iterator(option_identifier id) const;
     options_type::iterator search_option_iterator(option_identifier id);
-    void update_padded_options_size();
 
+    options_type options_;
     ip_header header_;
-    uint16_t options_size_, padded_options_size_;
-    options_type ip_options_;
 };
 
 } // Tins

include/tins/ip_address.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,10 +31,11 @@
 #define TINS_IPADDRESS_H
 
 #include <string>
-#include <iostream>
+#include <iosfwd>
+#include <functional>
 #include <stdint.h>
-#include "cxxstd.h"
-#include "macros.h"
+#include <tins/cxxstd.h>
+#include <tins/macros.h>
 
 namespace Tins {
 /**
@@ -53,6 +54,13 @@ public:
      */
     static const IPv4Address broadcast;
 
+    /**
+     * \brief Constructs an IPv4 address from a prefix length
+     *
+     * \param prefix_length The length of the prefix
+     */
+    static IPv4Address from_prefix_length(uint32_t prefix_length);
+
     /**
      * \brief Constructor taking a const char*.
      * 
@@ -123,9 +131,62 @@ public:
      * \param rhs The address to be compared.
      * \return bool indicating whether this address is less-than rhs.
      */
-    bool operator< (const IPv4Address& rhs) const {
+    bool operator<(const IPv4Address& rhs) const {
         return ip_addr_ < rhs.ip_addr_;
     }
+
+    /**
+     * \brief Compares this address for less-than equality.
+     *
+     * \param rhs The address to be compared to.
+     *
+     * \return bool indicating whether this address is equal or less-than rhs.
+     */
+    bool operator<=(const IPv4Address& rhs) const {
+        return !operator>(rhs);
+    }
+
+    /**
+     * \brief Compare this IPv4Address for greater-than inequality.
+     *
+     * \param rhs The address to be compared.
+     * \return bool indicating whether this address is greater-than rhs.
+     */
+    bool operator>(const IPv4Address& rhs) const {
+        return ip_addr_ > rhs.ip_addr_;
+    }
+
+    /**
+     * \brief Compares this address for greater-than equality.
+     *
+     * \param rhs The address to be compared to.
+     *
+     * \return bool indicating whether this address is equal or greater-than rhs.
+     */
+    bool operator>=(const IPv4Address& rhs) const {
+        return !operator<(rhs);
+    }
+
+    /**
+     * \brief Apply a mask to this address
+     * 
+     * \param mask The mask to be applied
+     * \return The result of applying the mask to this address
+     */
+    IPv4Address operator&(const IPv4Address& mask) const;
+
+    /**
+     * \brief Apply a mask to this address
+     *
+     * \param mask The mask to be applied
+     * \return The result of applying the mask to this address
+     */
+    IPv4Address operator|(const IPv4Address& mask) const;
+
+    /**
+     * not operator (invert)
+     */
+    IPv4Address operator~() const;
     
     /**
      * \brief Returns true if this is a private IPv4 address.
@@ -165,6 +226,15 @@ public:
      * \brief Returns true if this is a broadcast IPv4 address.
      */
     bool is_broadcast() const;
+
+    /**
+     * \brief Returns the size of an IPv4 Address.
+     *
+     * This returns the value of IPv4Address::address_size
+     */
+    size_t size() const {
+        return address_size;
+    }
     
     /**
      * \brief Writes this address to a std::ostream.
@@ -176,7 +246,7 @@ public:
      * \param addr The IPv4Address to be written.
      * \return std::stream& pointing to output.
      */
-    friend std::ostream& operator<<(std::ostream& output, const IPv4Address& addr);
+    TINS_API friend std::ostream& operator<<(std::ostream& output, const IPv4Address& addr);
 private:
     uint32_t ip_to_int(const char* ip);
 
@@ -190,8 +260,9 @@ namespace std {
 
 template<>
 struct hash<Tins::IPv4Address> {
-    size_t operator()(const Tins::IPv4Address& addr) const {
-        return std::hash<uint32_t>()(addr);
+    size_t operator()(const Tins::IPv4Address& addr) const
+    {
+        return std::hash<std::uint32_t>()(addr);
     }
 };
 

include/tins/ip_reassembler.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -32,16 +32,16 @@
 
 #include <vector>
 #include <map>
-#include "pdu.h"
-#include "macros.h"
-#include "ip_address.h"
+#include <tins/pdu.h>
+#include <tins/macros.h>
+#include <tins/ip_address.h>
+#include <tins/ip.h>
 
 namespace Tins {
 
 /** 
  * \cond
  */
-class IP;
 namespace Internals {
 class IPv4Fragment {
 public:
@@ -74,6 +74,7 @@ public:
     void add_fragment(IP* ip);
     bool is_complete() const;
     PDU* allocate_pdu() const;
+    const IP& first_fragment() const;
 private:
     typedef std::vector<IPv4Fragment> fragments_type;
     
@@ -81,9 +82,10 @@ private:
     bool extract_more_frag(const IP* ip);
 
     fragments_type fragments_;
+    size_t received_size_;
+    size_t total_size_;
+    IP first_fragment_;
     bool received_end_;
-    uint8_t transport_proto_;
-    size_t received_size_, total_size_;
 };
 } // namespace Internals
 

include/tins/ipsec.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,10 +30,10 @@
 #ifndef TINS_IPSEC_H
 #define TINS_IPSEC_H
 
-#include "pdu.h"
-#include "macros.h"
-#include "endianness.h"
-#include "small_uint.h"
+#include <tins/pdu.h>
+#include <tins/macros.h>
+#include <tins/endianness.h>
+#include <tins/small_uint.h>
 
 namespace Tins {
 
@@ -168,7 +168,7 @@ private:
         uint32_t spi, seq_number;
     };
 
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
     
     ipsec_header header_;
     byte_array icv_;
@@ -258,7 +258,7 @@ private:
         uint32_t spi, seq_number;
     };
 
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
     
     ipsec_header header_;
 };

include/tins/ipv6.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,14 +30,13 @@
 #ifndef TINS_IPV6_h
 #define TINS_IPV6_h
 
-#include <list>
-#include <stdexcept>
-#include "macros.h"
-#include "pdu.h"
-#include "endianness.h"
-#include "small_uint.h"
-#include "pdu_option.h"
-#include "ipv6_address.h"
+#include <tins/macros.h>
+#include <tins/cxxstd.h>
+#include <tins/pdu.h>
+#include <tins/endianness.h>
+#include <tins/small_uint.h>
+#include <tins/pdu_option.h>
+#include <tins/ipv6_address.h>
 
 namespace Tins {
 namespace Memory {
@@ -72,7 +71,12 @@ public:
     /**
      * The type used to store the extension headers.
      */
-    typedef std::list<ext_header> headers_type;
+    typedef std::vector<ext_header> headers_type;
+
+    /**
+     * The type used to store an extension header option.
+     */
+    typedef std::pair<uint8_t, std::vector<uint8_t> > header_option_type;
 
     /**
      * The values used to identify extension headers.
@@ -89,6 +93,15 @@ public:
         NO_NEXT_HEADER = 59
     };
 
+    /**
+     * The values used to identify Hop-By-Hop Options and Destination Options.
+     */
+    enum OptionType {
+        PAD_1 = 0,
+        PAD_N = 1,
+        JUMBO_PAYLOAD = 0xC2,
+    };
+
     /**
      * \brief Extracts metadata for this protocol based on the buffer provided
      *
@@ -97,6 +110,46 @@ public:
      */
     static metadata extract_metadata(const uint8_t *buffer, uint32_t total_sz);
 
+    /*
+     * \brief The type used to store Hop-By-Hop Extension Headers
+     */
+    struct hop_by_hop_header {
+        std::vector<header_option_type> options;
+
+        static hop_by_hop_header from_extension_header(const ext_header& hdr);
+    };
+
+    /*
+     * \brief The type used to store Destination Routing Extension Headers
+     */
+    struct destination_routing_header {
+        std::vector<header_option_type> options;
+
+        static destination_routing_header from_extension_header(const ext_header& hdr);
+    };
+
+    /**
+     * \brief The type used to store Routing Extension headers
+     */
+    struct routing_header {
+        uint8_t routing_type;
+        uint8_t segments_left;
+        std::vector<uint8_t> data;
+
+        static routing_header from_extension_header(const ext_header& hdr);
+    };
+
+    /**
+     * \brief The type used to store Fragment Extension headers
+     */
+    struct fragment_header {
+        uint16_t fragment_offset;
+        bool more_fragments;
+        uint32_t identification;
+
+        static fragment_header from_extension_header(const ext_header& hdr);
+    };
+
     /**
      * \brief Constructs an IPv6 object.
      * 
@@ -290,15 +343,55 @@ public:
      * \sa PDU::send()
      */
     void send(PacketSender& sender, const NetworkInterface &);
+
+    /**
+     * \brief Receives a matching response for this packet.
+     *
+     * \sa PDU::recv_response
+     * \param sender The packet sender which will receive the packet.
+     */
+    PDU* recv_response(PacketSender& sender, const NetworkInterface &);
     #endif
     
     /**
      * Adds an extension header.
      * 
+     * \deprecated Use IPv6::add_header
      * \param header The extension header to be added.
      */
-    void add_ext_header(const ext_header& header);
+    TINS_DEPRECATED(void add_ext_header(const ext_header& header));
     
+    /**
+     * Adds an extension header
+     * 
+     * \deprecated Use IPv6::add_header
+     * \param header The extension header to be added.
+     */
+    void add_header(const ext_header& header);
+
+    #if TINS_IS_CXX11
+
+    /**
+     * Adds an extension header by moving it
+     * 
+     * \param header The extension header to be added.
+     */
+    void add_header(ext_header&& header) {
+        ext_headers_.emplace_back(std::move(header));
+    }
+
+    /**
+     * Adds an extension header by using the provided parameters
+     * 
+     * \param header The extension header to be added.
+     */
+    template <typename... Args>
+    void add_header(Args&&... args) {
+        ext_headers_.emplace_back(std::forward<Args>(args)...);
+    }
+
+    #endif // TINS_IS_CXX11
+
     /**
      * \brief Searchs for an extension header that matchs the given 
      * flag.
@@ -311,10 +404,13 @@ public:
      */
     const ext_header* search_header(ExtensionHeader id) const;
 private:
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
     void set_last_next_header(uint8_t value);
+    uint32_t calculate_headers_size() const;
     static void write_header(const ext_header& header, Memory::OutputMemoryStream& stream);
     static bool is_extension_header(uint8_t header_id);
+    static uint32_t get_padding_size(const ext_header& header);
+    static std::vector<header_option_type> parse_header_options(const uint8_t* data, size_t size);
 
     TINS_BEGIN_PACK
     struct ipv6_header {
@@ -338,7 +434,7 @@ private:
 
     ipv6_header header_;
     headers_type ext_headers_;
-    uint32_t headers_size_;
+    uint8_t next_header_;
 };
 }
 

include/tins/ipv6_address.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,10 +31,11 @@
 #define TINS_IPV6_ADDRESS
 
 #include <string>
-#include <stdexcept>
+#include <iosfwd>
+#include <functional>
 #include <stdint.h>
-#include "cxxstd.h"
-#include "macros.h"
+#include <tins/cxxstd.h>
+#include <tins/macros.h>
 
 namespace Tins {
 
@@ -55,6 +56,13 @@ public:
      */
     typedef const uint8_t* const_iterator;
 
+    /**
+     * \brief Constructs an IPv6 address from a prefix length
+     *
+     * \param prefix_length The length of the prefix
+     */
+    static IPv6Address from_prefix_length(uint32_t prefix_length);
+
     /**
      * \brief Default constructor.
      * Initializes this IPv6 address to "::"
@@ -152,7 +160,40 @@ public:
     bool operator<(const IPv6Address& rhs) const {
         return std::lexicographical_compare(begin(), end(), rhs.begin(), rhs.end());
     }
-    
+
+    /**
+     * \brief Compares this address for less-than equality.
+     *
+     * \param rhs The address to be compared to.
+     *
+     * \return bool indicating whether this address is equal or less-than rhs.
+     */
+    bool operator<=(const IPv6Address& rhs) const {
+        return !operator>(rhs);
+    }
+
+    /**
+     * \brief Compares this address for greater-than inequality.
+     *
+     * \param rhs The address to be compared to.
+     *
+     * \return bool indicating whether this address is greater-than rhs.
+     */
+    bool operator>(const IPv6Address& rhs) const {
+        return std::lexicographical_compare(rhs.begin(), rhs.end(), begin(), end());
+    }
+
+    /**
+     * \brief Compares this address for greater-than equality.
+     *
+     * \param rhs The address to be compared to.
+     *
+     * \return bool indicating whether this address is equal or greater-than rhs.
+     */
+    bool operator>=(const IPv6Address& rhs) const {
+        return !operator<(rhs);
+    }
+
     /**
      * \brief Helper function which copies the address into an output
      * iterator.
@@ -188,6 +229,15 @@ public:
      * ff00::/8, false otherwise.
      */
     bool is_multicast() const;
+
+    /**
+     * \brief Returns the size of an IPv6 Address.
+     *
+     * This returns the value of IPv6Address::address_size
+     */
+    size_t size() const {
+        return address_size;
+    }
     
     /**
      * \brief Writes this address in hex-notation to a std::ostream.
@@ -196,9 +246,23 @@ public:
      * \param addr The parameter to be written.
      * \return std::ostream& pointing to the os parameter.
      */
-    friend std::ostream& operator<<(std::ostream& os, const IPv6Address& addr) {
-        return os << addr.to_string();
-    }
+    TINS_API friend std::ostream& operator<<(std::ostream& os, const IPv6Address& addr);
+
+    /**
+     * Applies a mask to an address
+     */
+    IPv6Address operator&(const IPv6Address& rhs) const;
+
+    /**
+     * or a mask to an address
+     */
+    IPv6Address operator|(const IPv6Address& rhs) const;
+
+    /**
+     * not operator (invert)
+     */
+    IPv6Address operator~() const ;
+
 private:
     void init(const char* addr);
 
@@ -212,8 +276,14 @@ namespace std {
 
 template<>
 struct hash<Tins::IPv6Address> {
+    // Implementation taken from boost.functional
     size_t operator()(const Tins::IPv6Address& addr) const {
-        return std::hash<std::string>()(addr.to_string());
+        std::size_t output = Tins::IPv6Address::address_size;
+        Tins::IPv6Address::const_iterator iter = addr.begin();
+        for (; iter != addr.end(); ++iter) {
+            output ^= *iter + 0x9e3779b9 + (output << 6) + (output >> 2);
+        }
+        return output;
     }
 };
 

include/tins/llc.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,13 +30,11 @@
 #ifndef TINS_IEEE8022_H
 #define TINS_IEEE8022_H
 
-#include <list>
 #include <vector>
 #include <stdint.h>
-#include "macros.h"
-#include "pdu.h"
-#include "macros.h"
-#include "endianness.h"
+#include <tins/macros.h>
+#include <tins/pdu.h>
+#include <tins/endianness.h>
 
 namespace Tins {
 
@@ -400,9 +398,9 @@ private:
     #endif
     
     typedef std::vector<uint8_t> field_type;
-    typedef std::list<field_type> field_list;
+    typedef std::vector<field_type> field_list;
 
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
 
     llchdr header_;
     uint8_t control_field_length_;

include/tins/loopback.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,8 +30,8 @@
 #ifndef TINS_LOOPBACK_H
 #define TINS_LOOPBACK_H
 
-#include "pdu.h"
-#include "macros.h"
+#include <tins/pdu.h>
+#include <tins/macros.h>
 
 namespace Tins {
 
@@ -117,7 +117,7 @@ public:
     void send(PacketSender& sender, const NetworkInterface& iface);
     #endif // BSD
 private:
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
 
     uint32_t family_;
 };

include/tins/macros.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -34,7 +34,7 @@
     #include <sys/param.h>
 #endif
 
-#include "config.h"
+#include <tins/config.h>
 
 // Check if this is Visual Studio
 #ifdef _MSC_VER
@@ -47,7 +47,7 @@
     #define TINS_LIKELY(x) (x)
     #define TINS_UNLIKELY(x) (x)
 #else
-    // Not Vistual Studio. Assume this is gcc compatible
+    // Not Visual Studio. Assume this is gcc compatible
     #define TINS_BEGIN_PACK 
     #define TINS_END_PACK __attribute__((packed))
     #define TINS_PACKED(DECLARATION) DECLARATION __attribute__((packed))

include/tins/memory_helpers.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -32,16 +32,17 @@
 
 #include <stdint.h>
 #include <cstring>
-#include <algorithm>
 #include <vector>
-#include "exceptions.h"
-#include "ip_address.h"
-#include "ipv6_address.h"
-#include "hw_address.h"
-#include "endianness.h"
+#include <tins/exceptions.h>
+#include <tins/endianness.h>
 
 namespace Tins {
 
+class IPv4Address;
+class IPv6Address;
+template <size_t n>
+class HWAddress;
+
 /** 
  * \cond
  */
@@ -71,20 +72,7 @@ public:
     : buffer_(buffer), size_(total_sz) {
     }
 
-    InputMemoryStream(const std::vector<uint8_t>& data)
-    : buffer_(&data[0]), size_(data.size()) {
-    }
-
-    void skip(size_t size) {
-        if (TINS_UNLIKELY(size > size_)) {
-            throw malformed_packet();
-        }
-        buffer_ += size;
-        size_ -= size;
-    }
-
-    bool can_read(size_t byte_count) const {
-        return TINS_LIKELY(size_ >= byte_count);
+    InputMemoryStream(const std::vector<uint8_t>& data) : buffer_(&data[0]), size_(data.size()) {
     }
  
     template <typename T>
@@ -113,33 +101,16 @@ public:
         skip(sizeof(value));
     }
 
-    void read(std::vector<uint8_t>& value, size_t count) {
-        if (!can_read(count)) {
+    void skip(size_t size) {
+        if (TINS_UNLIKELY(size > size_)) {
             throw malformed_packet();
         }
-        value.assign(pointer(), pointer() + count);
-        skip(count);
+        buffer_ += size;
+        size_ -= size;
     }
 
-    void read(IPv4Address& address) {
-        address = IPv4Address(read<uint32_t>());
-    }
-
-    void read(IPv6Address& address) {
-        if (!can_read(IPv6Address::address_size)) {
-            throw malformed_packet();
-        }
-        address = pointer();
-        skip(IPv6Address::address_size);
-    }
-
-    template <size_t n>
-    void read(HWAddress<n>& address) {
-        if (!can_read(HWAddress<n>::address_size)) {
-            throw malformed_packet();
-        }
-        address = pointer();
-        skip(HWAddress<n>::address_size);
+    bool can_read(size_t byte_count) const {
+        return TINS_LIKELY(size_ >= byte_count);
     }
 
     void read(void* output_buffer, size_t output_buffer_size) {
@@ -165,6 +136,11 @@ public:
     operator bool() const {
         return size_ > 0;
     }
+
+    void read(std::vector<uint8_t>& value, size_t count);
+    void read(HWAddress<6>& address);
+    void read(IPv4Address& address);
+    void read(IPv6Address& address);
 private:
     const uint8_t* buffer_;
     size_t size_;
@@ -180,14 +156,6 @@ public:
     : buffer_(&buffer[0]), size_(buffer.size()) {
     }
 
-    void skip(size_t size) {
-        if (TINS_UNLIKELY(size > size_)) {
-            throw malformed_packet();
-        }
-        buffer_ += size;
-        size_ -= size;
-    }
-
     template <typename T>
     void write(const T& value) {
         if (TINS_UNLIKELY(size_ < sizeof(value))) {
@@ -213,32 +181,31 @@ public:
         if (TINS_UNLIKELY(size_ < length)) {
             throw serialization_error();
         }
-        std::copy(start, end, buffer_);
+        // VC doesn't like dereferencing empty vector's iterators so check this here
+        if (TINS_UNLIKELY(length == 0)) {
+            return;
+        }
+        std::memcpy(buffer_, &*start, length);
         skip(length);
     }
 
+    void skip(size_t size) {
+        if (TINS_UNLIKELY(size > size_)) {
+            throw malformed_packet();
+        }
+        buffer_ += size;
+        size_ -= size;
+    }
+
     void write(const uint8_t* ptr, size_t length) {
         write(ptr, ptr + length);
     }
 
-    void write(const IPv4Address& address) {
-        write(static_cast<uint32_t>(address));
-    }
-
-    void write(const IPv6Address& address) {
-        write(address.begin(), address.end());
-    }
-
-    template <size_t n>
-    void write(const HWAddress<n>& address) {
-        write(address.begin(), address.end());
-    }
-
     void fill(size_t size, uint8_t value) {
         if (TINS_UNLIKELY(size_ < size)) {
             throw serialization_error();
         }
-        std::fill(buffer_, buffer_ + size, value);
+        std::memset(buffer_, value, size);
         skip(size);
     }
 
@@ -249,6 +216,10 @@ public:
     size_t size() const {
         return size_;
     }
+
+    void write(const HWAddress<6>& address);
+    void write(const IPv4Address& address);
+    void write(const IPv6Address& address);
 private:
     uint8_t* buffer_;
     size_t size_;

include/tins/mpls.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,10 +30,10 @@
 #ifndef TINS_MPLS_H
 #define TINS_MPLS_H
 
-#include "pdu.h"
-#include "endianness.h"
-#include "macros.h"
-#include "small_uint.h"
+#include <tins/pdu.h>
+#include <tins/endianness.h>
+#include <tins/macros.h>
+#include <tins/small_uint.h>
 
 namespace Tins {
 
@@ -73,15 +73,22 @@ public:
      * \brief Getter for the label field.
      */
     small_uint<20> label() const {
-        return (Endian::be_to_host(header_.label_high) << 4) | 
-               ((header_.label_low_and_bottom >> 4) & 0xf);
+        return (Endian::be_to_host(header_.label_high) << 4) |
+               ((header_.label_low_exp_and_bottom >> 4) & 0xf);
+    }
+
+    /**
+     * \brief Getter for the experimental field.
+     */
+    small_uint<3> experimental() const {
+        return (header_.label_low_exp_and_bottom >> 1) & 0x7;
     }
 
     /**
      * \brief Getter for the bottom of the stack field.
      */
     small_uint<1> bottom_of_stack() const {
-        return header_.label_low_and_bottom & 0x1;
+        return header_.label_low_exp_and_bottom & 0x1;
     }
 
     /**
@@ -98,11 +105,18 @@ public:
      */
     void label(small_uint<20> value);
 
+    /**
+     * \brief Setter for the experimental field
+     *
+     * \param value The new experimental field value
+     */
+    void experimental(small_uint<3> value);
+
     /**
      * \brief Setter for the bottom of the stack field
      *
      * Note that if this MPLS layer is somewhere between an Ethernet and IP
-     * layers, the bottom of the stack field will be overriden and set 
+     * layers, the bottom of the stack field will be overriden and set
      * automatically. You should only set this field when constructing ICMP
      * extensions.
      *
@@ -143,11 +157,11 @@ private:
     TINS_BEGIN_PACK
     struct mpls_header {
         uint16_t label_high;
-        uint8_t label_low_and_bottom;
+        uint8_t label_low_exp_and_bottom;
         uint8_t ttl;
     } TINS_END_PACK;
 
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
 
     mpls_header header_;
 };

include/tins/network_interface.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -33,10 +33,10 @@
 #include <string>
 #include <vector>
 #include <stdint.h>
-#include "macros.h"
-#include "hw_address.h"
-#include "ip_address.h"
-#include "ipv6_address.h"
+#include <tins/macros.h>
+#include <tins/hw_address.h>
+#include <tins/ip_address.h>
+#include <tins/ipv6_address.h>
 
 namespace Tins {
 
@@ -118,6 +118,17 @@ public:
      * \param ip The ip address being looked up.
      */
     NetworkInterface(IPv4Address ip);
+
+
+    /**
+     * \brief Constructs a NetworkInterface from an ipv6 address.
+     *
+     * This abstracted interface will be the one that would be the gateway
+     * when sending a packet to the given ip.
+     *
+     * \param ip The ipv6 address being looked up.
+     */
+    NetworkInterface(IPv6Address ipv6);
     
     /**
      * \brief Getter for this interface's identifier.

include/tins/offline_packet_filter.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -32,8 +32,11 @@
 
 #include <string>
 #include <stdint.h>
-#include "data_link_type.h"
-#include "macros.h"
+#include <tins/macros.h>
+
+#ifdef TINS_HAVE_PCAP
+
+#include <tins/data_link_type.h>
 
 namespace Tins {
 
@@ -154,6 +157,9 @@ private:
     mutable bpf_program filter_;
     std::string string_filter_;
 };
+
 } // Tins
 
+#endif // TINS_HAVE_PCAP
+
 #endif // TINS_OFFLINE_PACKET_FILTER_H

include/tins/packet.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,10 +30,9 @@
 #ifndef TINS_PACKET_H
 #define TINS_PACKET_H
 
-#include <algorithm>
-#include "cxxstd.h"
-#include "pdu.h"
-#include "timestamp.h"
+#include <tins/cxxstd.h>
+#include <tins/pdu.h>
+#include <tins/timestamp.h>
 
 /**
  * \namespace Tins
@@ -234,7 +233,9 @@ public:
      */
     Packet& operator=(Packet &&rhs) TINS_NOEXCEPT { 
         if (this != &rhs) {
-            std::swap(pdu_, rhs.pdu_);
+            PDU* tmp = std::move(pdu_);
+            pdu_ = std::move(rhs.pdu_);
+            rhs.pdu_ = std::move(tmp);
             ts_ = rhs.timestamp();
         }
         return* this;

include/tins/packet_sender.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -32,17 +32,16 @@
 
 
 #include <string>
-#include <stdexcept>
 #include <vector>
 #include <stdint.h>
 #include <map>
-#include "config.h"
+#include <tins/config.h>
 #ifdef TINS_HAVE_PACKET_SENDER_PCAP_SENDPACKET
     #include <pcap.h>
 #endif // TINS_HAVE_PACKET_SENDER_PCAP_SENDPACKET
-#include "network_interface.h"
-#include "macros.h"
-#include "cxxstd.h"
+#include <tins/network_interface.h>
+#include <tins/macros.h>
+#include <tins/cxxstd.h>
 
 struct timeval;
 struct sockaddr;
@@ -132,6 +131,7 @@ public:
         ARP_SOCKET,
         ICMP_SOCKET,
         IPV6_SOCKET,
+        ICMPV6_SOCKET,
         SOCKETS_END
     };
 
@@ -399,7 +399,8 @@ private:
     PDU* recv_match_loop(const std::vector<int>& sockets, 
                          PDU& pdu,
                          struct sockaddr* link_addr, 
-                         uint32_t addrlen);
+                         uint32_t addrlen,
+                         bool is_layer_3);
 
     std::vector<int> sockets_;
     #ifndef _WIN32

include/tins/packet_writer.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,13 +30,14 @@
 #ifndef TINS_PACKET_WRITER_H
 #define TINS_PACKET_WRITER_H
 
-#include "utils.h"
 #include <string>
-#include <iterator>
+#include <tins/macros.h>
+#include <tins/cxxstd.h>
+#include <tins/utils/pdu_utils.h>
+
+#ifdef TINS_HAVE_PCAP
 #include <pcap.h>
-#include "data_link_type.h"
-#include "macros.h"
-#include "cxxstd.h"
+#include <tins/data_link_type.h>
 
 struct timeval;
 
@@ -220,6 +221,9 @@ private:
     pcap_t* handle_;
     pcap_dumper_t* dumper_; 
 };
-}
+
+} // Tins
+
+#endif // TINS_HAVE_PCAP
 
 #endif // TINS_PACKET_WRITER_H

include/tins/pdu.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -33,10 +33,9 @@
 
 #include <stdint.h>
 #include <vector>
-#include "macros.h"
-#include "cxxstd.h"
-#include "exceptions.h"
-#include "macros.h"
+#include <tins/macros.h>
+#include <tins/cxxstd.h>
+#include <tins/exceptions.h>
 
 /** \brief The Tins namespace.
  */
@@ -171,6 +170,7 @@ public:
         ICMPv6,
         SLL,
         DHCPv6,
+        DOT1AD,
         DOT1Q,
         PPPOE,
         STP,
@@ -232,8 +232,11 @@ public:
          * \param rhs The PDU to be moved.
          */
         PDU(PDU &&rhs) TINS_NOEXCEPT 
-        : inner_pdu_(0) {
+        : inner_pdu_(0), parent_pdu_(0) {
             std::swap(inner_pdu_, rhs.inner_pdu_);
+            if (inner_pdu_) {
+                inner_pdu_->parent_pdu(this);
+            }
         }
         
         /**
@@ -242,7 +245,12 @@ public:
          * \param rhs The PDU to be moved.
          */
         PDU& operator=(PDU &&rhs) TINS_NOEXCEPT {
+            delete inner_pdu_;
+            inner_pdu_ = 0;
             std::swap(inner_pdu_, rhs.inner_pdu_);
+            if (inner_pdu_) {
+                inner_pdu_->parent_pdu(this);
+            }
             return* this;
         }
     #endif
@@ -275,11 +283,19 @@ public:
 
     /**
      * \brief Getter for the inner PDU.
-     * \return The current inner PDU. Might be 0.
+     * \return The current inner PDU. Might be a null pointer.
      */
     PDU* inner_pdu() const {
         return inner_pdu_;
     }
+
+    /**
+     * Getter for the parent PDU
+     * \return The current parent PDU. Might be a null pointer.
+     */
+    PDU* parent_pdu() const {
+        return parent_pdu_;
+    }
     
     /**
      * \brief Releases the inner PDU.
@@ -315,7 +331,6 @@ public:
      */
     void inner_pdu(const PDU& next_pdu);
 
-
     /** 
      * \brief Serializes the whole chain of PDU's, including this one.
      *
@@ -354,7 +369,7 @@ public:
      */
     template<typename T> 
     const T* find_pdu(PDUType type = T::pdu_flag) const {
-        return const_cast<PDU*>(this)->find_pdu<T>();
+        return const_cast<PDU*>(this)->find_pdu<T>(type);
     }
 
     /**
@@ -382,7 +397,7 @@ public:
      */
     template<typename T> 
     const T& rfind_pdu(PDUType type = T::pdu_flag) const {
-        return const_cast<PDU*>(this)->rfind_pdu<T>();
+        return const_cast<PDU*>(this)->rfind_pdu<T>(type);
     }
 
     /**
@@ -434,9 +449,7 @@ public:
      * \param ptr The pointer to the buffer.
      * \param total_sz The size of the buffer.
      */
-    virtual bool matches_response(const uint8_t* ptr, uint32_t total_sz) const { 
-        return false; 
-    }
+    virtual bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;
 
     /**
      * \brief Check whether this PDU matches the specified flag.
@@ -483,19 +496,16 @@ protected:
      * is calculated.
      * 
      * By default, this method does nothing
-     * 
-     * \param parent The parent PDU.
      */
-    virtual void prepare_for_serialize(const PDU* parent) { }
+    virtual void prepare_for_serialize();
 
     /** 
      * \brief Serializes this PDU and propagates this action to child PDUs.
      *
      * \param buffer The buffer in which to store this PDU's serialization.
      * \param total_sz The total size of the buffer.
-     * \param parent The parent PDU. Will be 0 if there's the parent does not exist.
      */
-    void serialize(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    void serialize(uint8_t* buffer, uint32_t total_sz);
 
     /** 
      * \brief Serializes this TCP PDU.
@@ -504,11 +514,13 @@ protected:
      * serialization.
      * \param buffer The buffer in which the PDU will be serialized.
      * \param total_sz The size available in the buffer.
-     * \param parent The PDU that's one level below this one on the stack. Might be 0.
      */
-    virtual void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent) = 0;
+    virtual void write_serialization(uint8_t* buffer, uint32_t total_sz) = 0;
 private:
+    void parent_pdu(PDU* parent);
+
     PDU* inner_pdu_;
+    PDU* parent_pdu_;
 };
 
 /**

include/tins/pdu_allocator.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,7 +31,7 @@
 #define TINS_PDU_ALLOCATOR_H
 
 #include <map>
-#include "pdu.h"
+#include <tins/pdu.h>
 
 namespace Tins {
 /**

include/tins/pdu_cacher.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,9 +30,9 @@
 #ifndef TINS_PDU_CACHER_H
 #define TINS_PDU_CACHER_H
 
-#include <algorithm>
-#include "pdu.h"
-#include "macros.h"
+#include <cstring>
+#include <tins/pdu.h>
+#include <tins/macros.h>
 
 namespace Tins {
 /**
@@ -144,11 +144,11 @@ public:
         return cached_.pdu_type();
     }
 private:
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent) {
+    void write_serialization(uint8_t* buffer, uint32_t total_sz) {
         if (cached_serialization_.size() != total_sz) {
             cached_serialization_ = cached_.serialize();
         }
-        std::copy(cached_serialization_.begin(), cached_serialization_.end(), buffer);
+        std::memcpy(buffer, &*cached_serialization_.begin(), cached_serialization_.size());
     }
 
     cached_type cached_;

include/tins/pdu_iterator.h

@@ -0,0 +1,312 @@
+/*
+ * Copyright (c) 2017, 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_ITERATOR_H
+#define TINS_PDU_ITERATOR_H
+
+#include <iterator>
+
+namespace Tins {
+
+class PDU;
+class Packet;
+
+/**
+ * Base class for PDU iterators
+ */
+template <typename Concrete>
+class PDUIteratorBase {
+public:
+    /**
+     * Iterator's category
+     */
+    typedef std::bidirectional_iterator_tag iterator_category;
+
+    /**
+     * Iterator difference type
+     */
+    typedef std::ptrdiff_t difference_type;
+
+    /**
+     * Advances this iterator
+     */
+    Concrete& operator++() {
+        advance();
+        return static_cast<Concrete&>(*this);
+    }
+
+    /**
+     * Advances this iterator
+     */
+    Concrete operator++(int) {
+        Concrete output = static_cast<Concrete&>(*this);
+        advance();
+        return output;
+    }
+
+    /**
+     * Moves this iterator back
+     */
+    Concrete& operator--() {
+        retreat();
+        return static_cast<Concrete&>(*this);
+    }
+
+    /**
+     * Moves this iterator back
+     */
+    Concrete operator--(int) {
+        Concrete output = static_cast<Concrete&>(*this);
+        retreat();
+        return output;
+    }
+private:
+    void advance() {
+        Concrete& self = static_cast<Concrete&>(*this);
+        self = Concrete(self->inner_pdu());
+    }
+
+    void retreat() {
+        Concrete& self = static_cast<Concrete&>(*this);
+        self = Concrete(self->parent_pdu());
+    }
+};
+
+/**
+ * Compares iterators for equality
+ *
+ * \param lhs The left hand side iterator to be compared
+ * \param rhs The right hand side iterator to be compared
+ */
+template <typename Concrete>
+bool operator==(const PDUIteratorBase<Concrete>& lhs, const PDUIteratorBase<Concrete>& rhs) {
+    const PDU* lhs_pdu = static_cast<const Concrete&>(lhs).operator->();
+    const PDU* rhs_pdu = static_cast<const Concrete&>(rhs).operator->();
+    return lhs_pdu == rhs_pdu;
+}
+
+/**
+ * Compares iterators for equality
+ *
+ * \param lhs The left hand side iterator to be compared
+ * \param rhs The right hand side iterator to be compared
+ */
+template <typename Concrete>
+bool operator!=(const PDUIteratorBase<Concrete>& lhs, const PDUIteratorBase<Concrete>& rhs) {
+    return !(lhs == rhs);
+}
+
+/**
+ * Iterator class for PDUs
+ */
+class PDUIterator : public PDUIteratorBase<PDUIterator> {
+public:
+    /**
+     * The used pointer type
+     */
+    typedef PDU* pointer;
+
+    /**
+     * The used reference type
+     */
+    typedef PDU& reference;
+
+    /**
+     * The used value type
+     */
+    typedef PDU& value_type;
+
+    /**
+     * Constructs an iterator using a PDU
+     *
+     * \param pdu The PDU to be used for iteration
+     */
+    PDUIterator(pointer pdu);
+
+    /**
+     * Get the stored PDU pointer
+     */
+    pointer operator->();
+
+    /**
+     * Get the stored PDU pointer
+     */
+    pointer operator->() const;
+
+    /**
+     * Dereference and get the stored PDU
+     */
+    PDU& operator*();
+
+    /**
+     * Dereference and get the stored PDU
+     */
+    const PDU& operator*() const;
+private:
+    pointer pdu_;
+};
+
+/**
+ * Const iterator class for PDUs
+ */
+class ConstPDUIterator : public PDUIteratorBase<PDUIterator> {
+public:
+    /**
+     * The used pointer type
+     */
+    typedef const PDU* pointer;
+
+    /**
+     * The used reference type
+     */
+    typedef const PDU& reference;
+
+    /**
+     * The used value type
+     */
+    typedef const PDU& value_type;
+
+    /**
+     * Constructs an iterator using a PDU
+     *
+     * \param pdu The PDU to be used for iteration
+     */
+    ConstPDUIterator(pointer pdu);
+
+    /**
+     * Construct from a PDU iterator
+     */
+    ConstPDUIterator(PDUIterator iterator);
+
+    /**
+     * Get the stored PDU pointer
+     */
+    pointer operator->() const;
+
+    /**
+     * Dereference and get the stored PDU
+     */
+    value_type operator*() const;
+private:
+    pointer pdu_;
+};
+
+/*
+ * \brief PDU iterator class
+ *
+ * This class allows iterating all PDUs in a packet.
+ *
+ * Note that this keeps pointers to the original PDUs so you need to guarantee that they're
+ * still in scope while you iterate them.
+ */
+template <typename Iterator>
+class PDUIteratorRange {
+public:
+    /**
+     * Constructs a PDU iterator range
+     *
+     * \param start The beginning of the range
+     * \param end The end of the range
+     */
+    PDUIteratorRange(Iterator start, Iterator end)
+    : start_(start), end_(end) {
+
+    }
+
+    template <typename OtherIterator>
+    PDUIteratorRange(const PDUIteratorRange<OtherIterator>& other)
+    : start_(other.begin().operator->()), end_(other.end().operator->()) {
+
+    } 
+
+    /*
+     * Gets the beginning of the range
+     */ 
+    Iterator begin() {
+        return start_;
+    }
+
+    /*
+     * Gets the beginning of the range
+     */ 
+    Iterator begin() const {
+        return start_;
+    }
+
+    /*
+     * Gets the end of the range
+     */ 
+    Iterator end() {
+        return end_;
+    }
+
+    /*
+     * Gets the end of the range
+     */ 
+    Iterator end() const {
+        return end_;
+    }
+private:
+    Iterator start_;
+    Iterator end_;
+};
+
+/**
+ * Creates an iterator range out of a PDU
+ */
+PDUIteratorRange<PDUIterator> iterate_pdus(PDU* pdu);
+
+/**
+ * Creates an iterator range out of a PDU
+ */
+PDUIteratorRange<PDUIterator> iterate_pdus(PDU& pdu);
+
+/**
+ * Creates an iterator range out of a PDU
+ */
+PDUIteratorRange<PDUIterator> iterate_pdus(Packet& packet);
+
+/**
+ * Creates an iterator range out of a PDU
+ */
+PDUIteratorRange<ConstPDUIterator> iterate_pdus(const PDU* pdu);
+
+/**
+ * Creates an iterator range out of a PDU
+ */
+PDUIteratorRange<ConstPDUIterator> iterate_pdus(const PDU& pdu);
+
+/**
+ * Creates an iterator range out of a packet
+ */
+PDUIteratorRange<ConstPDUIterator> iterate_pdus(const Packet& packet);
+
+} // Tins
+
+#endif // TINS_PDU_ITERATOR_H

include/tins/pdu_option.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,20 +31,19 @@
 #define TINS_PDU_OPTION_H
 
 #include <vector>
-#include <iterator>
-#include <cstring>
-#include <algorithm>
 #include <string>
-#include <limits>
+#include <cstring>
 #include <stdint.h>
-#include "exceptions.h"
-#include "endianness.h"
-#include "internals.h"
-#include "ip_address.h"
-#include "ipv6_address.h"
-#include "hw_address.h"
+#include <tins/exceptions.h>
+#include <tins/detail/type_traits.h>
 
 namespace Tins {
+
+class IPv4Address;
+class IPv6Address;
+template <size_t n>
+class HWAddress;
+
 /**
  * \cond
  */
@@ -52,251 +51,133 @@ template <typename OptionType, typename PDUType>
 class PDUOption;
 
 namespace Internals {
-    template <typename T, typename X, typename PDUType>
-    T convert_to_integral(const PDUOption<X, PDUType> & opt) {
-        if (opt.data_size() != sizeof(T)) {
-            throw malformed_option();
-        }
-        T data = *(T*)opt.data_ptr();
-        if (PDUType::endianness == PDUType::BE) {
-            data = Endian::be_to_host(data);
-        }
-        else {
-            data = Endian::le_to_host(data);
-        }
-        return data;
-    }
+    namespace Converters {
+        uint8_t convert(const uint8_t* ptr, uint32_t data_size, PDU::endian_type endian,
+                        type_to_type<uint8_t>);
+        int8_t convert(const uint8_t* ptr, uint32_t data_size, PDU::endian_type endian,
+                        type_to_type<int8_t>);
+        uint16_t convert(const uint8_t* ptr, uint32_t data_size, PDU::endian_type endian,
+                         type_to_type<uint16_t>);
+        uint32_t convert(const uint8_t* ptr, uint32_t data_size, PDU::endian_type endian,
+                         type_to_type<uint32_t>);
+        uint64_t convert(const uint8_t* ptr, uint32_t data_size, PDU::endian_type endian,
+                         type_to_type<uint64_t>);
+        HWAddress<6> convert(const uint8_t* ptr, uint32_t data_size,
+                             PDU::endian_type endian, type_to_type<HWAddress<6> >);
+        IPv4Address convert(const uint8_t* ptr, uint32_t data_size,
+                            PDU::endian_type endian, type_to_type<IPv4Address>);
+        IPv6Address convert(const uint8_t* ptr, uint32_t data_size, PDU::endian_type endian,
+                            type_to_type<IPv6Address>);
+        std::string convert(const uint8_t* ptr, uint32_t data_size,
+                            PDU::endian_type endian, type_to_type<std::string>);
+        std::vector<float> convert(const uint8_t* ptr, uint32_t data_size,
+                                   PDU::endian_type endian, type_to_type<std::vector<float> >);
+        std::vector<uint8_t> convert(const uint8_t* ptr, uint32_t data_size,
+                                     PDU::endian_type endian, type_to_type<std::vector<uint8_t> >);
+        std::vector<uint16_t> convert(const uint8_t* ptr, uint32_t data_size,
+                                      PDU::endian_type endian,
+                                      type_to_type<std::vector<uint16_t> >);
+        std::vector<uint32_t> convert(const uint8_t* ptr, uint32_t data_size,
+                                      PDU::endian_type endian,
+                                      type_to_type<std::vector<uint32_t> >);
+        std::vector<IPv4Address> convert(const uint8_t* ptr, uint32_t data_size,
+                                         PDU::endian_type endian,
+                                         type_to_type<std::vector<IPv4Address> >);
+        std::vector<IPv6Address> convert(const uint8_t* ptr, uint32_t data_size,
+                                         PDU::endian_type endian,
+                                         type_to_type<std::vector<IPv6Address> >);
+        std::vector<std::pair<uint8_t, uint8_t> > convert(const uint8_t* ptr, uint32_t data_size,
+                                                          PDU::endian_type endian,
+                                        type_to_type<std::vector<std::pair<uint8_t, uint8_t> > >);
+        std::pair<uint8_t, uint8_t> convert(const uint8_t* ptr, uint32_t data_size,
+                                            PDU::endian_type endian,
+                                            type_to_type<std::pair<uint8_t, uint8_t> >);
+        std::pair<uint16_t, uint32_t> convert(const uint8_t* ptr, uint32_t data_size,
+                                              PDU::endian_type endian,
+                                              type_to_type<std::pair<uint16_t, uint32_t> >);
+        std::pair<uint32_t, uint32_t> convert(const uint8_t* ptr, uint32_t data_size,
+                                              PDU::endian_type endian,
+                                              type_to_type<std::pair<uint32_t, uint32_t> >);
+    } // Converters
     
-    template <typename T, typename = void>
     struct converter {
-        template <typename X, typename PDUType>
-        static T convert(const PDUOption<X, PDUType>& opt) {
+        template <typename T, typename X, typename PDUType>
+        static T do_convert(const PDUOption<X, PDUType>& opt, type_to_type<T>) {
             return T::from_option(opt);
         }
-    };
-    
-    template <>
-    struct converter<uint8_t> {
-        template <typename X, typename PDUType>
-        static uint8_t convert(const PDUOption<X, PDUType>& opt) {
-            if (opt.data_size() != 1) {
-                throw malformed_option();
-            }
-            return* opt.data_ptr();
-        }
-    };
-    
-    template<>
-    struct converter<uint16_t> {
-        template<typename X, typename PDUType>
-        static uint16_t convert(const PDUOption<X, PDUType>& opt) {
-            return convert_to_integral<uint16_t>(opt);
-        }
-    };
-    
-    template<>
-    struct converter<uint32_t> {
-        template<typename X, typename PDUType>
-        static uint32_t convert(const PDUOption<X, PDUType>& opt) {
-            return convert_to_integral<uint32_t>(opt);
-        }
-    };
-    
-    template<>
-    struct converter<uint64_t> {
-        template<typename X, typename PDUType>
-        static uint64_t convert(const PDUOption<X, PDUType>& opt) {
-            return convert_to_integral<uint64_t>(opt);
-        }
-    };
 
-    template<size_t n>
-    struct converter<HWAddress<n> > {
-        template<typename X, typename PDUType>
-        static HWAddress<n> convert(const PDUOption<X, PDUType>& opt) {
-            if (opt.data_size() != n) {
-                throw malformed_option();
-            }
-            return HWAddress<n>(opt.data_ptr());
+        template <typename U, typename X, typename PDUType>
+        static U do_convert(const PDUOption<X, PDUType>& opt, type_to_type<uint8_t> type) {
+            return Converters::convert(opt.data_ptr(), opt.data_size(),
+                                       PDUType::endianness, type);
         }
-    };
 
-    template<>
-    struct converter<IPv4Address> {
-        template<typename X, typename PDUType>
-        static IPv4Address convert(const PDUOption<X, PDUType>& opt) {
-            if (opt.data_size() != sizeof(uint32_t)) {
-                throw malformed_option();
-            }
-            const uint32_t* ptr = (const uint32_t*)opt.data_ptr();
-            if (PDUType::endianness == PDUType::BE) {
-                return IPv4Address(*ptr);
-            }
-            else {
-                return IPv4Address(Endian::change_endian(*ptr));
-            }
+        template <typename U, typename X, typename PDUType>
+        static U do_convert(const PDUOption<X, PDUType>& opt, type_to_type<int8_t> type) {
+            return Converters::convert(opt.data_ptr(), opt.data_size(),
+                                       PDUType::endianness, type);
         }
-    };
 
-    template<>
-    struct converter<IPv6Address> {
-        template<typename X, typename PDUType>
-        static IPv6Address convert(const PDUOption<X, PDUType>& opt) {
-            if (opt.data_size() != IPv6Address::address_size) {
-                throw malformed_option();
-            }
-            return IPv6Address(opt.data_ptr());
+        template <typename U, typename X, typename PDUType>
+        static U do_convert(const PDUOption<X, PDUType>& opt, type_to_type<uint16_t> type) {
+            return Converters::convert(opt.data_ptr(), opt.data_size(),
+                                       PDUType::endianness, type);
         }
-    };
-    
-    template<>
-    struct converter<std::string> {
-        template<typename X, typename PDUType>
-        static std::string convert(const PDUOption<X, PDUType>& opt) {
-            return std::string(
-                opt.data_ptr(),
-                opt.data_ptr() + opt.data_size()
-            );
+
+        template <typename U, typename X, typename PDUType>
+        static U do_convert(const PDUOption<X, PDUType>& opt, type_to_type<uint32_t> type) {
+            return Converters::convert(opt.data_ptr(), opt.data_size(),
+                                       PDUType::endianness, type);
         }
-    };
-    
-    template<>
-    struct converter<std::vector<float> > {
-        template<typename X, typename PDUType>
-        static std::vector<float> convert(const PDUOption<X, PDUType>& opt) {
-            std::vector<float> output;
-            const uint8_t* ptr = opt.data_ptr(), *end = ptr + opt.data_size();
-            while (ptr != end) {
-                output.push_back(float(*(ptr++) & 0x7f) / 2);
-            }
-            return output;
+
+        template <typename U, typename X, typename PDUType>
+        static U do_convert(const PDUOption<X, PDUType>& opt, type_to_type<uint64_t> type) {
+            return Converters::convert(opt.data_ptr(), opt.data_size(),
+                                       PDUType::endianness, type);
         }
-    };
-    
-    template<typename T>
-    struct converter<std::vector<T>, typename enable_if<is_unsigned_integral<T>::value>::type> {
-        template<typename X, typename PDUType>
-        static std::vector<T> convert(const PDUOption<X, PDUType>& opt) {
-            if (opt.data_size() % sizeof(T) != 0) {
-                throw malformed_option();
-            }
-            const T* ptr = (const T*)opt.data_ptr();
-            const T* end = (const T*)(opt.data_ptr() + opt.data_size());
-            
-            std::vector<T> output(std::distance(ptr, end));
-            typename std::vector<T>::iterator it = output.begin();
-            while (ptr < end) {
-                if (PDUType::endianness == PDUType::BE) {
-                    *it++ = Endian::be_to_host(*ptr++);
-                }
-                else {
-                    *it++ = Endian::le_to_host(*ptr++);
-                }
-            }
-            return output;
+
+        template <typename U, typename X, typename PDUType>
+        static U do_convert(const PDUOption<X, PDUType>& opt, type_to_type<HWAddress<6> > type) {
+            return Converters::convert(opt.data_ptr(), opt.data_size(),
+                                       PDUType::endianness, type);
         }
-    };
-    
-    template<typename T, typename U>
-    struct converter<
-            std::vector<std::pair<T, U> >, 
-            typename enable_if<
-                is_unsigned_integral<T>::value && is_unsigned_integral<U>::value
-            >::type
-    > {
-        template<typename X, typename PDUType>
-        static std::vector<std::pair<T, U> > convert(const PDUOption<X, PDUType>& opt) {
-            if (opt.data_size() % (sizeof(T) + sizeof(U)) != 0) {
-                throw malformed_option();
-            }
-            const uint8_t* ptr = opt.data_ptr(), *end = ptr + opt.data_size();
-            
-            std::vector<std::pair<T, U> > output;
-            while (ptr < end) {
-                std::pair<T, U> data;
-                data.first = *(const T*)ptr;
-                ptr += sizeof(T);
-                data.second = *(const U*)ptr;
-                ptr += sizeof(U);
-                if (PDUType::endianness == PDUType::BE) {
-                    data.first = Endian::be_to_host(data.first);
-                    data.second = Endian::be_to_host(data.second);
-                }
-                else {
-                    data.first = Endian::le_to_host(data.first);
-                    data.second = Endian::le_to_host(data.second);
-                }
-                output.push_back(data);
-            }
-            return output;
+
+        template <typename U, typename X, typename PDUType>
+        static U do_convert(const PDUOption<X, PDUType>& opt, type_to_type<IPv4Address> type) {
+            return Converters::convert(opt.data_ptr(), opt.data_size(),
+                                       PDUType::endianness, type);
         }
-    };
-    
-    template<>
-    struct converter<std::vector<IPv4Address> > {
-        template<typename X, typename PDUType>
-        static std::vector<IPv4Address> convert(const PDUOption<X, PDUType>& opt) {
-            if (opt.data_size() % 4 != 0) {
-                throw malformed_option();
-            }
-            const uint32_t* ptr = (const uint32_t*)opt.data_ptr();
-            const uint32_t* end = (const uint32_t*)(opt.data_ptr() + opt.data_size());
-            
-            std::vector<IPv4Address> output(std::distance(ptr, end));
-            std::vector<IPv4Address>::iterator it = output.begin();
-            while (ptr < end) {
-                if (PDUType::endianness == PDUType::BE) {
-                    *it++ = IPv4Address(*ptr++);
-                }
-                else {
-                    *it++ = IPv4Address(Endian::change_endian(*ptr++));
-                }
-            }
-            return output;
+
+        template <typename U, typename X, typename PDUType>
+        static U do_convert(const PDUOption<X, PDUType>& opt, type_to_type<IPv6Address> type) {
+            return Converters::convert(opt.data_ptr(), opt.data_size(),
+                                       PDUType::endianness, type);
         }
-    };
-    
-    template<>
-    struct converter<std::vector<IPv6Address> > {
-        template<typename X, typename PDUType>
-        static std::vector<IPv6Address> convert(const PDUOption<X, PDUType>& opt) {
-            if (opt.data_size() % IPv6Address::address_size != 0) {
-                throw malformed_option();
-            }
-            const uint8_t* ptr = opt.data_ptr(), *end = opt.data_ptr() + opt.data_size();
-            std::vector<IPv6Address> output;
-            while (ptr < end) {
-                output.push_back(IPv6Address(ptr));
-                ptr += IPv6Address::address_size;
-            }
-            return output;
+
+        template <typename U, typename X, typename PDUType>
+        static U do_convert(const PDUOption<X, PDUType>& opt,
+                            type_to_type<std::string> type) {
+            return Converters::convert(opt.data_ptr(), opt.data_size(),
+                                       PDUType::endianness, type);
         }
-    };
-    
-    template<typename T, typename U>
-    struct converter<
-            std::pair<T, U>, 
-            typename enable_if<
-                is_unsigned_integral<T>::value && is_unsigned_integral<U>::value
-            >::type
-    > {
-        template<typename X, typename PDUType>
-        static std::pair<T, U> convert(const PDUOption<X, PDUType>& opt) {
-            if (opt.data_size() != sizeof(T) + sizeof(U)) {
-                throw malformed_option();
-            }
-            std::pair<T, U> output;
-            std::memcpy(&output.first, opt.data_ptr(), sizeof(T));
-            std::memcpy(&output.second, opt.data_ptr() + sizeof(T), sizeof(U));
-            if (PDUType::endianness == PDUType::BE) {
-                output.first = Endian::be_to_host(output.first);
-                output.second = Endian::be_to_host(output.second);
-            }
-            else {
-                output.first = Endian::le_to_host(output.first);
-                output.second = Endian::le_to_host(output.second);
-            }
-            return output;
+
+        template <typename U, typename X, typename PDUType, typename Z>
+        static U do_convert(const PDUOption<X, PDUType>& opt,
+                            type_to_type<std::vector<Z> > type) {
+            return Converters::convert(opt.data_ptr(), opt.data_size(),
+                                       PDUType::endianness, type);
+        }
+
+        template <typename U, typename X, typename PDUType, typename Z, typename W>
+        static U do_convert(const PDUOption<X, PDUType>& opt,
+                            type_to_type<std::pair<Z, W> > type) {
+            return Converters::convert(opt.data_ptr(), opt.data_size(),
+                                       PDUType::endianness, type);
+        }
+
+        template <typename T, typename X, typename PDUType>
+        static T convert(const PDUOption<X, PDUType>& opt) {
+            return do_convert<T>(opt, type_to_type<T>());
         }
     };
 }
@@ -333,8 +214,10 @@ public:
     PDUOption(option_type opt = option_type(), 
               size_t length = 0,
               const data_type* data = 0) 
-    : option_(opt), size_(static_cast<uint16_t>(length)) {
-        set_payload_contents(data, data + (data ? length : 0));
+    : option_(opt), size_(static_cast<uint16_t>(length)), real_size_(0) {
+        if (data != 0) {
+            set_payload_contents(data, data + length);
+        }
     }
     
     /**
@@ -351,7 +234,7 @@ public:
      * \brief Move constructor.
      * \param rhs The PDUOption to be moved.
      */
-    PDUOption(PDUOption&& rhs) {
+    PDUOption(PDUOption&& rhs) TINS_NOEXCEPT {
         real_size_ = 0;
         *this = std::move(rhs);
     }
@@ -360,7 +243,7 @@ public:
      * \brief Move assignment operator.
      * \param rhs The PDUOption to be moved.
      */
-    PDUOption& operator=(PDUOption&& rhs) {
+    PDUOption& operator=(PDUOption&& rhs) TINS_NOEXCEPT {
         option_ = rhs.option_;
         size_ = rhs.size_;
         if (real_size_ > small_buffer_size) {
@@ -373,13 +256,9 @@ public:
             rhs.real_size_ = 0;
         }
         else {
-            std::copy(
-                rhs.data_ptr(),
-                rhs.data_ptr() + rhs.data_size(),
-                payload_.small_buffer
-            );
+            std::memcpy(payload_.small_buffer, rhs.data_ptr(), rhs.data_size());
         }
-        return* this;
+        return *this;
     }
     
     #endif // TINS_IS_CXX11
@@ -508,22 +387,20 @@ public:
      */
     template<typename T>
     T to() const {
-        return Internals::converter<T>::convert(*this);
+        return Internals::converter::convert<T>(*this);
     }
 private:
     template<typename ForwardIterator>
     void set_payload_contents(ForwardIterator start, ForwardIterator end) {
         size_t total_size = std::distance(start, end);
-        if (total_size > std::numeric_limits<uint16_t>::max()) {
+        if (total_size > 65535) {
             throw option_payload_too_large();
         }
         real_size_ = static_cast<uint16_t>(total_size);
         if (real_size_ <= small_buffer_size) {
-            std::copy(
-                start,
-                end,
-                payload_.small_buffer
-            );
+            if (total_size > 0) {
+                std::memcpy(payload_.small_buffer, &*start, total_size);
+            }
         }
         else {
             payload_.big_buffer_ptr = new data_type[real_size_];
@@ -545,22 +422,36 @@ private:
 };
 
 namespace Internals {
-    /*
-     * \cond
-     */
-    template <typename Option>
-    struct option_type_equality_comparator {
-        option_type_equality_comparator(typename Option::option_type type) : type(type) { }
+/*
+ * \cond
+ */
 
-        bool operator()(const Option& opt) const {
-            return opt.option() == type;
+template <typename Option, typename Container>
+typename Container::iterator find_option(Container& cont, typename Option::option_type type) {
+    typename Container::iterator iter;
+    for (iter = cont.begin(); iter != cont.end(); ++iter) {
+        if (iter->option() == type) {
+            break;
         }
+    }
+    return iter;
+}
 
-        typename Option::option_type type; 
-    };
-    /*
-     * \endcond
-     */
+template <typename Option, typename Container>
+typename Container::const_iterator find_option_const(const Container& cont,
+                                                     typename Option::option_type type) {
+    typename Container::const_iterator iter;
+    for (iter = cont.begin(); iter != cont.end(); ++iter) {
+        if (iter->option() == type) {
+            break;
+        }
+    }
+    return iter;
+}
+
+/*
+ * \endcond
+ */
 } // Internals
 
 } // namespace Tins

include/tins/pktap.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,8 +30,11 @@
 #ifndef TINS_PKTAP_H
 #define TINS_PKTAP_H
 
-#include "pdu.h"
-#include "macros.h"
+#include <tins/pdu.h>
+#include <tins/macros.h>
+
+// This class is only available if pcap is enabled
+#ifdef TINS_HAVE_PCAP
 
 namespace Tins {
 
@@ -104,11 +107,13 @@ private:
         uint8_t ecommand[20];
     };
 
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
 
     pktap_header header_;
 };
 
 } // Tins
 
+#endif // TINS_HAVE_PCAP
+
 #endif // TINS_PKTAP_H

include/tins/ppi.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,10 +30,12 @@
 #ifndef TINS_PPI_H
 #define TINS_PPI_H
 
-#include "pdu.h"
-#include "macros.h"
-#include "endianness.h"
-#include "small_uint.h"
+#include <tins/pdu.h>
+#include <tins/macros.h>
+#include <tins/endianness.h>
+#include <tins/small_uint.h>
+
+#ifdef TINS_HAVE_PCAP
 
 namespace Tins {
 
@@ -123,7 +125,7 @@ public:
         return new PPI(*this);
     }
 private:
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
     void parse_80211(const uint8_t* buffer, uint32_t total_sz);
 
     struct ppi_header {
@@ -135,6 +137,9 @@ private:
     ppi_header header_;
     byte_array data_;
 };
-}
+
+} // Tins
+
+#endif // TINS_HAVE_PCAP
 
 #endif // TINS_PPI_H

include/tins/pppoe.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,15 +30,14 @@
 #ifndef TINS_PPPoE_H
 #define TINS_PPPoE_H
 
-#include <list>
 #include <string>
 #include <vector>
-#include "pdu.h"
-#include "macros.h"
-#include "endianness.h"
-#include "small_uint.h"
-#include "pdu_option.h"
-#include "cxxstd.h"
+#include <tins/pdu.h>
+#include <tins/macros.h>
+#include <tins/endianness.h>
+#include <tins/small_uint.h>
+#include <tins/pdu_option.h>
+#include <tins/cxxstd.h>
 
 namespace Tins {
 /**
@@ -82,7 +81,7 @@ public:
     /**
      * The type used to store the options.
      */
-    typedef std::list<tag> tags_type;
+    typedef std::vector<tag> tags_type;
     
     /**
      * The type used to store the Vendor-Specific tag's value.
@@ -390,7 +389,7 @@ public:
      */
     std::string generic_error() const;
 private:
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
     
     template<typename T>
     void add_tag_iterable(TagTypes id, const T& data) {

include/tins/radiotap.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,14 +27,15 @@
  *
  */
 
-#include "config.h"
+#include <tins/config.h>
 
 #if !defined(TINS_RADIOTAP_H) && defined(TINS_HAVE_DOT11)
 #define TINS_RADIOTAP_H
 
-#include "macros.h"
-#include "pdu.h"
-#include "endianness.h"
+#include <tins/macros.h>
+#include <tins/pdu.h>
+#include <tins/endianness.h>
+#include <tins/pdu_option.h>
 
 namespace Tins {
 class PacketSender;
@@ -54,6 +55,11 @@ public:
      */
     static const PDU::PDUType pdu_flag = PDU::RADIOTAP;
 
+    /**
+     * RadioTap is little endian
+     */
+    static const endian_type endianness = LE;
+
     /**
      * \brief Enumeration of the different channel type flags.
      * 
@@ -77,7 +83,8 @@ public:
      * \sa RadioTap::present()
      */
     enum PresentFlags {
-        TSTF                = 1 << 0,
+        TSFT                = 1 << 0,
+        TSTF                = 1 << 0, ///< Deprecated (typo), use TSFT
         FLAGS               = 1 << 1,
         RATE                = 1 << 2,
         CHANNEL             = 1 << 3,
@@ -94,6 +101,7 @@ public:
         RX_FLAGS            = 1 << 14,
         TX_FLAGS            = 1 << 15,
         DATA_RETRIES        = 1 << 17,
+        XCHANNEL            = 1 << 18,
         CHANNEL_PLUS        = 1 << 18,
         MCS                 = 1 << 19
     };
@@ -121,7 +129,28 @@ public:
         uint8_t flags;
         uint8_t mcs;
     } TINS_END_PACK;
+
+    /**
+     * \brief The type used to represent the XChannel field
+     */
+    TINS_BEGIN_PACK
+    struct xchannel_type {
+        uint32_t flags;
+        uint16_t frequency;
+        uint8_t channel;
+        uint8_t max_power;
+    } TINS_END_PACK;
     
+    /**
+     * The type used to store RadioTap options
+     */
+    typedef PDUOption<RadioTap::PresentFlags, RadioTap> option;
+
+    /**
+     * The type used to store the options payload
+     */
+    typedef std::vector<uint8_t> options_payload_type;
+
     /**
      * \brief Default constructor.
      */
@@ -233,6 +262,12 @@ public:
      */
     void tx_flags(uint16_t new_tx_flag);
 
+    /**
+     * \brief Setter for the xchannel field.
+     * \param new_xchannel The xchannel field
+     */
+    void xchannel(xchannel_type new_xchannel);
+
     /**
      * \brief Setter for the data retries field.
      * \param new_rx_flag The data retries.
@@ -326,10 +361,10 @@ public:
     uint8_t db_signal() const;
     
     /**
-     * \brief Getter for the channel+ field.
-     * \return The channel+ field.
+     * \brief Getter for the XChannel field.
+     * \return The XChannel field.
      */
-    uint32_t channel_plus() const;
+    xchannel_type xchannel() const;
     
     /**
      * \brief Getter for the data retries field
@@ -364,10 +399,7 @@ public:
      * will be undefined. It is only safe to use the getter of a field 
      * if its corresponding bit flag is set in the present field.
      */
-    PresentFlags present() const { 
-        //return (PresentFlags)*(uint32_t*)(&radio_.it_len + 1); 
-        return (PresentFlags)Endian::le_to_host(radio_.flags_32);
-    }
+    PresentFlags present() const;
     
     /** \brief Check whether ptr points to a valid response for this PDU.
      *
@@ -391,6 +423,22 @@ public:
      */
     uint32_t trailer_size() const;
     
+    /**
+     * Adds the given option
+     *
+     * \param option The option to be added.
+     */
+    void add_option(const option& opt);
+
+    /**
+     * \brief Gets the options payload
+     *
+     * Use Utils::RadioTapParser to iterate these options and extract fields manually,
+     * in case you want to have deeper access into the option types/values stored in 
+     * a RadioTap frame.
+     */
+    const options_payload_type& options_payload() const;
+
     /**
      * \sa PDU::clone
      */
@@ -407,70 +455,7 @@ public:
     }
 private:
     TINS_BEGIN_PACK
-    #if TINS_IS_LITTLE_ENDIAN
-        struct flags_type {
-            uint32_t
-                tsft:1,
-                flags:1,
-                rate:1,
-                channel:1,
-                fhss:1,
-                dbm_signal:1,
-                dbm_noise:1,
-                lock_quality:1,
-
-                tx_attenuation:1,
-                db_tx_attenuation:1,
-                dbm_tx_power:1,
-                antenna:1,
-                db_signal:1,
-                db_noise:1,
-                rx_flags:1,
-                tx_flags:1,
-
-                reserved1:1,
-                data_retries:1,
-                channel_plus:1,
-                mcs:1,
-                reserved2:4,
-
-                reserved3:7,
-                ext:1;
-        } TINS_END_PACK;
-    #else
-        struct flags_type {
-            uint32_t
-                lock_quality:1,
-                dbm_noise:1,
-                dbm_signal:1,
-                fhss:1,
-                channel:1,
-                rate:1,
-                flags:1,
-                tsft:1,
-
-                tx_flags:1,
-                rx_flags:1,
-                db_noise:1,
-                db_signal:1,
-                antenna:1,
-                dbm_tx_power:1,
-                db_tx_attenuation:1,
-                tx_attenuation:1,
-
-                reserved2:4,
-                mcs:1,
-                channel_plus:1,
-                data_retries:1,
-                reserved1:1,
-
-                ext:1,
-                reserved3:7;
-        } TINS_END_PACK;
-    #endif
-
-    TINS_BEGIN_PACK
-    struct radiotap_hdr {
+    struct radiotap_header {
     #if TINS_IS_LITTLE_ENDIAN
         uint8_t it_version;	
         uint8_t it_pad;
@@ -479,37 +464,13 @@ private:
         uint8_t it_version;
     #endif // TINS_IS_LITTLE_ENDIAN 
         uint16_t it_len;
-        union {
-            flags_type flags;
-            uint32_t flags_32;
-        };
     } TINS_END_PACK;
     
-    void init();
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
-    uint32_t find_extra_flag_fields_size(const uint8_t* buffer, uint32_t total_sz);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
+    option do_find_option(PresentFlags type) const;
 
-    template <size_t n>
-    void align_buffer(const uint8_t* buffer_start, const uint8_t*& buffer, uint32_t& size) {
-        uint32_t offset = ((buffer - buffer_start) % n);
-        if (offset) {
-            offset = n - offset;
-            if (offset > size) {
-                throw malformed_packet();
-            }
-            buffer += offset;
-            size -= offset;
-        }
-    }
-    
-    
-    radiotap_hdr radio_;
-    // present fields...
-    uint64_t tsft_;
-    uint16_t channel_type_, channel_freq_, rx_flags_, signal_quality_, tx_flags_;
-    mcs_type mcs_;
-    uint8_t antenna_, flags_, rate_, channel_, max_power_, db_signal_, data_retries_;
-    int8_t dbm_signal_, dbm_noise_;
+    radiotap_header header_;
+    options_payload_type options_payload_;
 };
 }
 

include/tins/rawpdu.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -32,9 +32,9 @@
 
 #include <vector>
 #include <string>
-#include "pdu.h"
-#include "macros.h"
-#include "cxxstd.h"
+#include <tins/pdu.h>
+#include <tins/macros.h>
+#include <tins/cxxstd.h>
 
 namespace Tins {
 
@@ -96,6 +96,16 @@ public:
     RawPDU(ForwardIterator start, ForwardIterator end) 
     : payload_(start, end) { }
 
+    /**
+     * \brief Creates an instance of RawPDU from a payload_type.
+     *
+     * The payload is copied into the RawPDU's internal buffer.
+     *
+     * \param data The payload to use.
+     */
+    RawPDU(const payload_type & data)
+            : payload_(data) { }
+
     #if TINS_IS_CXX11
         /** 
          * \brief Creates an instance of RawPDU from a payload_type.
@@ -201,7 +211,7 @@ public:
         return new RawPDU(*this);
     }
 private:
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
 
     payload_type payload_;
 };

include/tins/rsn_information.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,15 +27,15 @@
  *
  */
 
-#include "config.h"
+#include <tins/config.h>
 
 #if !defined(TINS_RSN_INFORMATION) && defined(TINS_HAVE_DOT11)
 #define TINS_RSN_INFORMATION
 
 #include <stdint.h>
 #include <vector>
-#include "macros.h"
-#include "endianness.h"
+#include <tins/macros.h>
+#include <tins/endianness.h>
 
 namespace Tins{
 class Dot11;
@@ -50,18 +50,36 @@ public:
      * \brief Enum that represents the different cypher suites.
      */
     enum CypherSuites {
-        WEP_40  = 0x01ac0f00,
-        TKIP    = 0x02ac0f00,
-        CCMP    = 0x04ac0f00,
-        WEP_104 = 0x05ac0f00
+        WEP_40          = 0x01ac0f00,
+        TKIP            = 0x02ac0f00,
+        CCMP            = 0x04ac0f00,
+        WEP_104         = 0x05ac0f00,
+        BIP_CMAC_128    = 0x06ac0f00,
+        GCMP_128        = 0x08ac0f00,
+        GCMP_256        = 0x09ac0f00,
+        CCMP_256        = 0x10ac0f00,
+        BIP_GMAC_128    = 0x11ac0f00,
+        BIP_GMAC_256    = 0x12ac0f00,
+        BIP_CMAC_256    = 0x13ac0f00
     };
 
     /**
      * \brief Enum that represents the different akm suites.
      */
     enum AKMSuites {
-        PMKSA = 0x01ac0f00,
-        PSK   = 0x02ac0f00
+        EAP                 = 0x01ac0f00,
+        PSK                 = 0x02ac0f00,
+        EAP_FT              = 0x03ac0f00,
+        PSK_FT              = 0x04ac0f00,
+        EAP_SHA256          = 0x05ac0f00,
+        PSK_SHA256          = 0x06ac0f00,
+        TDLS                = 0x07ac0f00,
+        SAE_SHA256          = 0x08ac0f00,
+        SAE_FT              = 0x09ac0f00,
+        APPEERKEY           = 0x10ac0f00,
+        EAP_SHA256_FIPSB    = 0x11ac0f00,
+        EAP_SHA384_FIPSB    = 0x12ac0f00,
+        EAP_SHA384          = 0x13ac0f00
     };
 
     /**

include/tins/sll.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,10 +31,10 @@
 #define TINS_SLL_H
 
 #include <vector>
-#include "pdu.h"
-#include "macros.h"
-#include "endianness.h"
-#include "hw_address.h"
+#include <tins/pdu.h>
+#include <tins/macros.h>
+#include <tins/endianness.h>
+#include <tins/hw_address.h>
 
 namespace Tins {
 
@@ -174,7 +174,7 @@ private:
         uint16_t protocol;
     } TINS_END_PACK;
     
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
     
     sll_header header_;
 };

include/tins/small_uint.h

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

include/tins/snap.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,12 +30,11 @@
 #ifndef TINS_SNAP_H
 #define TINS_SNAP_H
 
-
 #include <stdint.h>
-#include "pdu.h"
-#include "macros.h"
-#include "endianness.h"
-#include "small_uint.h"
+#include <tins/pdu.h>
+#include <tins/macros.h>
+#include <tins/endianness.h>
+#include <tins/small_uint.h>
 
 namespace Tins {
 
@@ -177,7 +176,7 @@ private:
         uint16_t eth_type;
     } TINS_END_PACK;
     
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
     
     snap_header snap_;
 };

include/tins/sniffer.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,18 +31,20 @@
 #ifndef TINS_SNIFFER_H
 #define TINS_SNIFFER_H
 
-
-#include <pcap.h>
 #include <string>
 #include <memory>
-#include <stdexcept>
 #include <iterator>
-#include "pdu.h"
-#include "packet.h"
-#include "cxxstd.h"
-#include "macros.h"
-#include "exceptions.h"
-#include "internals.h"
+#include <tins/pdu.h>
+#include <tins/packet.h>
+#include <tins/cxxstd.h>
+#include <tins/macros.h>
+#include <tins/exceptions.h>
+#include <tins/detail/type_traits.h>
+
+#ifdef TINS_HAVE_PCAP
+
+#include <pcap.h>
+
 
 namespace Tins {
 class SnifferIterator;
@@ -71,7 +73,8 @@ public:
          * This constructor is available only in C++11.
          */
         BaseSniffer(BaseSniffer &&rhs) TINS_NOEXCEPT
-        : handle_(0), mask_(), extract_raw_(false) {
+        : handle_(0), mask_(), extract_raw_(false),
+          pcap_sniffing_method_(pcap_loop) {
             *this = std::move(rhs);
         }
 
@@ -84,6 +87,7 @@ public:
             swap(handle_, rhs.handle_);
             swap(mask_, rhs.mask_);
             swap(extract_raw_, rhs.extract_raw_);
+            swap(pcap_sniffing_method_, rhs.pcap_sniffing_method_);
             return* this;
         }
     #endif
@@ -236,6 +240,35 @@ public:
      */
     void set_extract_raw_pdus(bool value);
 
+    /**
+     * \brief function pointer for the sniffing method
+     *
+     * By default, libtins uses `pcap_loop` to sniff packets. With
+     * `set_pcap_sniffing_method` it is possible to specify an alternative
+     * sniffing method, for example `pcap_dispatch`, or a custom function.
+     * This function pointer has the same interface as `pcap_loop` and
+     * `pcap_dispatch`.
+     *
+     * \sa set_pcap_sniffing_method
+     */
+    typedef int(*PcapSniffingMethod)(pcap_t*, int, pcap_handler, u_char*);
+
+    /**
+     * \brief set sniffing method to either pcap_loop or pcap_dispatch.
+     *
+     * By default, packets are sniffed with `pcap_loop`, which only returns if
+     * a packet is received, thus ignoring timeout expiration, if any is set.
+     * With this method it is possible to pass an alternative sniffer function,
+     * e.g. `pcap_dispatch`, that honors timeouts, or a custom function with
+     * the same signature.
+     *
+     * See the relevant manual pages for pcap_loop and pcap_dispatch for more
+     * information on their behavior
+     *
+     * \sa PcapSniffingMethod
+     */
+    void set_pcap_sniffing_method(PcapSniffingMethod method);
+
     /**
      * \brief Retrieves this sniffer's link type.
      *
@@ -281,6 +314,7 @@ private:
     pcap_t* handle_;
     bpf_u_int32 mask_;
     bool extract_raw_;
+    PcapSniffingMethod pcap_sniffing_method_;
 };
 
 /**
@@ -298,13 +332,18 @@ public:
         PROMISC
     };
 
+    /**
+     * \brief Constructs an instance of Sniffer
+     *
+     * \param device The device from which to capture packets
+     */
+    Sniffer(const std::string& device);
+
     /**
      * \brief Constructs an instance of Sniffer using the provided configuration.
      *
-     * This constructor was added as a way to improve the parameter bloat
-     * introduced by the other ones available. You should create an instance
-     * of SnifferConfiguration, set the desired parameters, and then use it
-     * when constructing a Sniffer object.
+     * Use the SnifferConfiguration object to specify how you want to configure
+     * the properties of this sniffer
      *
      * \sa SnifferConfiguration
      *
@@ -327,8 +366,8 @@ public:
      * \param filter A capture filter to be used on the sniffing session.(optional);
      * \param rfmon Indicates if the interface should be put in monitor mode.(optional);
      */
-    Sniffer(const std::string& device, unsigned max_packet_size,
-      bool promisc = false, const std::string& filter = "", bool rfmon = false);
+    TINS_DEPRECATED(Sniffer(const std::string& device, unsigned max_packet_size,
+                    bool promisc = false, const std::string& filter = "", bool rfmon = false));
 
     /**
      * \brief Constructs an instance of Sniffer.
@@ -343,21 +382,19 @@ public:
      * \param filter A capture filter to be used on the sniffing session.(optional);
      * \param rfmon Indicates if the interface should be put in monitor mode.(optional);
      */
-    Sniffer(const std::string& device, promisc_type promisc = NON_PROMISC,
-      const std::string& filter = "", bool rfmon = false);
+    TINS_DEPRECATED(Sniffer(const std::string& device, promisc_type promisc,
+                    const std::string& filter = "", bool rfmon = false));
 
 private:
     friend class SnifferConfiguration;
 
+    void init(const std::string& device, const SnifferConfiguration& configuration);
     void set_snap_len(unsigned snap_len);
-
     void set_buffer_size(unsigned buffer_size);
-
     void set_promisc_mode(bool promisc_enabled);
-
     void set_rfmon(bool rfmon_enabled);
-
     void set_immediate_mode(bool enabled);
+    void set_timestamp_precision(int value);
 };
 
 /**
@@ -563,6 +600,12 @@ public:
      */
     void set_filter(const std::string& filter);
 
+    /**
+     * Sets the pcap sniffing method to use.
+     * \param method The sniffing method to be used.
+     */
+    void set_pcap_sniffing_method(BaseSniffer::PcapSniffingMethod method);
+
     /**
      * Sets the rfmon option.
      * \param enabled The rfmon option value.
@@ -586,6 +629,12 @@ public:
      * \param enabled The immediate mode option value.
      */
     void set_immediate_mode(bool enabled);
+
+    /**
+     * Sets the timestamp precision value
+     * \param value The timestamp option value.
+     */
+    void set_timestamp_precision(int value);
 protected:
     friend class Sniffer;
     friend class FileSniffer;
@@ -596,7 +645,9 @@ protected:
         RFMON = 4,
         PACKET_FILTER = 8,
         IMMEDIATE_MODE = 16,
-        DIRECTION = 32
+        DIRECTION = 32,
+        TIMESTAMP_PRECISION = 64,
+        PCAP_SNIFFING_METHOD = 128,
     };
 
     void configure_sniffer_pre_activation(Sniffer& sniffer) const;
@@ -608,11 +659,13 @@ protected:
     unsigned snap_len_;
     unsigned buffer_size_;
     std::string filter_;
+    BaseSniffer::PcapSniffingMethod pcap_sniffing_method_;
     unsigned timeout_;
     bool promisc_;
     bool rfmon_;
     bool immediate_mode_;
     pcap_direction_t direction_;
+    int timestamp_precision_;
 };
 
 template <typename Functor>
@@ -640,4 +693,6 @@ void Tins::BaseSniffer::sniff_loop(Functor function, uint32_t max_packets) {
 
 } // Tins
 
+#endif // TINS_HAVE_PCAP
+
 #endif // TINS_SNIFFER_H

include/tins/stp.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,11 +30,11 @@
 #ifndef TINS_STP_H
 #define TINS_STP_H
 
-#include "pdu.h"
-#include "macros.h"
-#include "endianness.h"
-#include "hw_address.h"
-#include "small_uint.h"
+#include <tins/pdu.h>
+#include <tins/macros.h>
+#include <tins/endianness.h>
+#include <tins/hw_address.h>
+#include <tins/small_uint.h>
 
 namespace Tins {
 /**
@@ -305,7 +305,7 @@ private:
     static bpdu_id_type convert(const pvt_bpdu_id& id);
     static pvt_bpdu_id convert(const bpdu_id_type& id);
     
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
     
     stp_header header_;
 };

include/tins/tcp.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Matias Fontanini
+ * Copyright (c) 2017, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,18 +30,15 @@
 #ifndef TINS_TCP_H
 #define TINS_TCP_H
 
-
-#include <list>
 #include <vector>
 #include <stdint.h>
-#include <stdexcept>
 #include <utility>
-#include "pdu.h"
-#include "macros.h"
-#include "endianness.h"
-#include "small_uint.h"
-#include "pdu_option.h"
-#include "cxxstd.h"
+#include <tins/pdu.h>
+#include <tins/macros.h>
+#include <tins/endianness.h>
+#include <tins/small_uint.h>
+#include <tins/pdu_option.h>
+#include <tins/cxxstd.h>
 
 namespace Tins {
 namespace Memory {
@@ -112,7 +109,9 @@ public:
         SACK_OK = 4,
         SACK    = 5,
         TSOPT   = 8,
-        ALTCHK  = 14
+        ALTCHK  = 14,
+        RFC_EXPERIMENT_1 = 253,
+        RFC_EXPERIMENT_2 = 254
     };
     
     /**
@@ -132,7 +131,7 @@ public:
     /**
      * The type used to store the options.
      */
-    typedef std::list<option> options_type;
+    typedef std::vector<option> options_type;
     
     /**
      * The type used to store the sack option.
@@ -478,7 +477,6 @@ public:
          * \param option The option to be added.
          */
         void add_option(option &&opt) {
-            internal_add_option(opt);
             options_.push_back(std::move(opt));
         }
 
@@ -493,7 +491,6 @@ public:
         template <typename... Args>
         void add_option(Args&&... args) {
             options_.emplace_back(std::forward<Args>(args)...);
-            internal_add_option(options_.back());
         }
     #endif
 
@@ -609,18 +606,17 @@ private:
         return opt->to<T>();
     }
     
-    void internal_add_option(const option& option);
-    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz);
     void checksum(uint16_t new_check);
-    void update_options_size();
+    uint32_t calculate_options_size() const;
+    uint32_t pad_options_size(uint32_t size) const;
     options_type::const_iterator search_option_iterator(OptionTypes type) const;
     options_type::iterator search_option_iterator(OptionTypes type);
     
     void write_option(const option& opt, Memory::OutputMemoryStream& stream);
 
-    tcp_header header_;
-    uint16_t options_size_, total_options_size_;
     options_type options_;
+    tcp_header header_;
 };
 
 } // Tins