Updated files for release.

fix armv5 alignment issues

AUTHORS

@@ -1,2 +1,9 @@
-Matias Fontanini - mfontanini@nasel.com.ar
-Santiago Alessandri - salessandri@nasel.com.ar
+# 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

@@ -0,0 +1,258 @@
+v3.1 - Sun Aug 24 21:39:43 ART 2014
+
+- Fixed ICMPv6 checksum error on serialization.
+
+- Fixed empty domain name encoding on DNS.
+
+- Changed the build system to CMake.
+
+v3.0 - Thu Aug  7 21:39:09 ART 2014
+
+- Timestamps can now be constructed from std::chrono::duration.
+
+- Packets can now be constructed from a PDU pointer and take ownership
+of it.
+
+- All protocols now set the next layer protocol flag, regardless if 
+it was already set. This was not done in some protocols, 
+like EthernetII, and as a consequence if the network layer protocol
+was replaced by other, the packet would be serialized incorrectly.
+
+- Fixed invalid parsing of some unknown DNS records.
+
+- Fixed unaligned memory accesses that were not supported under
+ARMv4 and ARMv5.
+
+- Added BaseSniffer::set_extract_raw_pdus.
+
+- Reduced minimum automake version to 1.11.
+
+- Added Utils::to_string(PDU::PDUType).
+
+- Fixed error compilations on Windows.
+
+- Fixed ICMPv6 checksum calculation.
+
+- Added method in IP and TCP to emplace an option (C++11 only).
+
+- Added small option optimization to PDUOption.
+
+- Fixed error compilation on RSNInformation.
+
+- Renamed ICMP::check to ICMP::checksum.
+
+- Added Sniffer support to set interface to promiscuous mode.
+
+- TCPStreamFollower now handles overlapping fragments correctly.
+
+- Fixed bugs in TCPStreamFollower which didn't allow it to follow
+stream correctly.
+
+- TCPStreamFollower now doesn't clear its state after every call to
+TCPStreamFollower::follow_streams.
+
+- Added IPv6 flag check to pdu_flag_to_ip_type.
+
+- Added DHCP::hostname to extract the hostname options.
+
+- Removed extra qualifier on SessionKeys::decrypt_unicast which 
+produced compilation errors on some platforms.
+
+- PacketSender::send now uses PDU::matches_flag to match specific
+PDU types.
+
+- Removed 'no newline at end of file' warnings.
+
+- Fixed bug when calling BIOCIMMEDIATE on *BSD.
+
+- Fixed bug on PacketSender::send_recv which didn't work under *BSD.
+
+- Fixed bug triggered by not including the string header.
+
+v2.0 - Thu Jan 23 11:09:38 ART 2014 
+
+- DNSResourceRecord was removed. Now DNS records are added using 
+DNS::Resource.
+
+- tins.h now includes ppi.h.
+
+- Done significant improvements in the speed of DNS parsing.
+
+- Added PDUOption<>::to<> which converts a PDUOption to a specific type.
+
+- Layer 3 packets sent using PacketSender::send_recv for which the 
+answer is a different PDU type.
+
+- ICMP::gateway now uses IPv4Address.
+
+- Added support for ICMP address mask request/reply.
+
+- Fixed bug in PacketSender when using send_recv and a layer 2 PDU. The 
+interface in which the packet was sent was not the default_interface 
+set when the sender was constructed.
+
+- IP packets sent using PacketSender::send_recv now match ICMP 
+responses.
+
+- Added support for ICMP timestamp request/reply packets. 
+ICMP::matches_response now works with these types of packets as well.
+
+- Added support for reassembling of fragmented IP packets via the
+IPv4Reassembler class.
+
+- Fragmented IP packet's inner_pdu PDUs are not decoded now.
+
+- Added 1000ms as the default read timeout used when calling 
+pcap_open_live. Added BaseSniffer::set_timeout to modify this parameter.
+
+- Added the --disable-dot11 configure switch.
+
+- Added support for IPSec.
+
+- Fixed bug triggered when ifaddrs::ifa_addr was null in 
+NetworkInterface::addresses.
+
+- Added another overload of Utils::route_entries which returns the
+result either than storing it in a parameter.
+
+- Added ARP monitor, WPS detector, DNS queries sniffer and DNS spoofer 
+examples.
+
+- Added another Sniffer constructor which doesn't expect the maximum
+capture size.
+
+- Added tins_cast as a replacement for dynamic_cast on PDUs.
+
+v1.2 - Mon oct  7 23:33:49 ART 2013
+
+- Added BaseSniffer::begin and BaseSniffer::end.
+
+- BaseSniffer::next_packet uses pcap_loop instead of pcap_next, which
+doesn't work well on some linux distributions.
+
+- Added PPI PDU class.
+
+- Fixed a bug in EthernetII triggered when the size of the whole frame 
+was lower than 60 bytes.
+
+- Added AddressRange class and IPv4Address, IPv6Address and 
+HWAddress<>::operator/.
+
+- Added is_broadcast, is_multicast and is_unicast to IPv4, IPv6
+and HWAddress.
+
+- Added is_private and is_loopback methods to IPv4 and IPv6 addresses.
+
+- Done some optimizations on TCP's constructor from buffer.
+
+- Added helper functions to Dot11Data to retrieve the source, 
+destination and BSSID addresses.
+
+- Fixed bugs in DNS triggered when parsing MX and unknown records.
+
+- BaseSniffer::next_packet now iterates until a valid packet is found.
+
+- TCP::get_flag is now const.
+
+- The --disable-wpa2 now works as expected.
+
+v1.1 - Wed Jun  5 09:03:37 ART 2013
+
+- Implemented std::hash specialization for IPv4, IPv6 and HWAddress<>
+types.
+
+- Added a RSNHandshakeCapturer class.
+
+- Added WPA2Decrypter class.
+
+- IEEE 802.11 frames are not parsed if the RadioTap FAILED_FCS flag 
+is on.
+
+- RadioTap now calculates its size everytime it's serialized.
+
+- Splitted the dot11.h and dot11.cpp files into several files to
+speed up compilation times.
+
+- Added HWAddress<>::is_broadcast and HWAddress::operator[].
+
+- Fixed a bug triggered when parsing Dot11QoSData frames.
+
+v1.0 - Tue Apr 23 20:40:57 ART 2013
+
+- Link layer protocol PDUs now don't hold a NetworkInterface. This led
+to changes in their constructors.
+
+- Removed the obsolete PDU* parameter taken by several classes' 
+constructors.
+
+- IP now sets the sender's address automatically when no link layer
+PDU is used.
+
+- IP, TCP and UDP now calculate the checksum everytime they're 
+serialized.
+
+- Added PDU::rfind_pdu.
+
+- Defined several exception types.
+
+- Implemented matches_response on several protocols.
+
+- PacketSender is now movable.
+
+- Added an overload of add_option that takes an rvalue-reference in IP, 
+TCP, DHCP, ICMPv6 and Dot11.
+
+- Added support for GNU/kFreeBSD.
+
+- Removed several deprecated methods, such as PDU::clone_packet.
+
+- Added PacketSender::send(PDU&, NetworkInterface).
+
+- Normalized the TLV options naming conventions in all of the classes
+that used them.
+
+- Added support for Dot1Q, STP, PPPoE protocols.
+
+- Made some important optimizations on PDUOption<>'s constructors.
+
+- Added Utils::resolve_domain and Utils::resolve_domain6
+
+v0.3 - Thu Jan 31 16:47:27 ART 2013
+
+- Added IPv6, ICMPv6 and DHCPv6 classes.
+
+- Added support for Loopback interfaces and the Linux Crooked Capture
+pseudo protocol.
+
+- Added support for IPv6 records in DNS.
+
+- Added Packet/RefPacket class.
+
+- Added support for FreeBSD, OSX and Windows.
+
+- Added C++11 move semantics to several classes.
+
+- Done a complete rewrite of the build system; it now uses libtool.
+
+- Fixed several bugs in DNS.
+
+
+v0.2 - Sat Oct 20 11:26:40 2012
+
+- Added support for big endian architectures. 
+
+- Simplified several interfaces.
+
+- Added IPv4Address and HWAddress class to simplify handling IP and hardware addresses.
+
+- Added NetworkInterface class to abstract network interfaces.
+
+- Added TCPStreamFollower class to follow TCP streams on the fly.
+
+- Added WEPDecrypter class to decrypt WEP-encrypted 802.11 data frames on the fly.
+
+- Added several new PDUs: Loopback, IEEE802_3, LLC, DNS.
+
+- Added support for reading and writing pcap files.
+
+- Moved to BSD-2 license.

CMakeLists.txt

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

Doxyfile

@@ -31,14 +31,14 @@ PROJECT_NAME           = libtins
 # This could be handy for archiving the generated documentation or
 # if some version control system is used.
 
-PROJECT_NUMBER         = 0.1
+PROJECT_NUMBER         = 1.2
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
 # base path where the generated documentation will be put.
 # If a relative path is entered, it will be relative to the location
 # where doxygen was started. If left blank the current directory will be used.
 
-OUTPUT_DIRECTORY       = docs/
+OUTPUT_DIRECTORY       = ../docs/
 
 # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
 # 4096 sub-directories (in 2 levels) under the output directory of each output
@@ -1085,7 +1085,7 @@ SERVER_BASED_SEARCH    = NO
 # If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
 # generate Latex output.
 
-GENERATE_LATEX         = YES
+GENERATE_LATEX         = NO
 
 # The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be

LICENSE

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

Makefile.am

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

README

@@ -0,0 +1,73 @@
+------------------------------------------------------------------------
+       libtins v3.0
+------------------------------------------------------------------------
+
+
+-------------------------------- About ---------------------------------
+
+libtins is a high-level, multiplatform C++ network packet sniffing and 
+crafting library.
+
+Its main purpose is to provide the C++ developer an easy, efficient, 
+platform and endianess-independent way to create tools which need to 
+send, receive and manipulate specially crafted packets. 
+
+In order to read tutorials, examples and checkout some benchmarks of the
+library, please visit:
+
+http://libtins.github.io/
+
+------------------------------- Compiling ------------------------------
+
+libtins depends on libpcap and openssl, although the latter is not 
+necessary if some features of the library are disabled.
+
+In order to compile, execute:
+
+./configure
+make
+
+Note that by default, only the shared object is compiled. If you would
+like to generate a static library file as well, run:
+
+./configure --enable-static
+
+The generated static/shared library files will be located in the .libs
+directory.
+
+libtins is noticeable faster if you enable C++11 support. Therefore, if
+your compiler supports this standard, then you should enable it. In 
+order to do so, use the --enable-c++11 switch:
+
+./configure --enable-c++11
+
+If you want to disable WPA2 decryption support, which will remove 
+openssl as a dependency for compilation, use the --disable-wpa2 switch:
+
+./configure --disable-wpa2
+
+If you want to disable IEEE 802.11 support(this will also disable 
+RadioTap and WPA2 decryption), which will reduce the size of the 
+resulting library in around 20%, use the --disable-dot11 switch:
+
+./configure --disable-dot11
+
+------------------------------ Installing-------------------------------
+
+Once you're done, if you want to install the header files and the 
+shared object, execute as root:
+
+make install
+
+This will install the shared object typically in /usr/local/lib. Note
+that you might have to update ldconfig's cache before using it, so 
+in order to invalidate it, you should run(as root):
+
+ldconfig
+
+------------------------------ Examples --------------------------------
+
+You might want to have a look at the examples located  in the "examples"
+directory. The same samples can be found online at:
+
+http://libtins.github.io/examples/

README.md

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

THANKS

@@ -0,0 +1,4 @@
+We'd like to thank the following people, who have been of great help
+through the development of libtins:
+
+- Raúl Benencia <rbenencia@gmail.com> - For creating the Debian package.

cmake/Modules/CheckCXX11Features.cmake

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

cmake/Modules/FindPCAP.cmake

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

compile

@@ -0,0 +1 @@
+/usr/share/automake-1.14/compile

configure.ac

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

depcomp

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

depends.d

@@ -1,558 +0,0 @@
-src/arp.o: src/arp.cpp include/arp.h include/pdu.h include/endianness.h \
- include/hw_address.h include/ip_address.h include/ip.h \
- include/small_uint.h include/pdu_option.h include/ethernetII.h \
- include/network_interface.h include/rawpdu.h include/constants.h \
- include/network_interface.h
-
-include/arp.h:
-
-include/pdu.h:
-
-include/endianness.h:
-
-include/hw_address.h:
-
-include/ip_address.h:
-
-include/ip.h:
-
-include/small_uint.h:
-
-include/pdu_option.h:
-
-include/ethernetII.h:
-
-include/network_interface.h:
-
-include/rawpdu.h:
-
-include/constants.h:
-
-include/network_interface.h:
-src/bootp.o: src/bootp.cpp include/bootp.h include/pdu.h \
- include/endianness.h include/ip_address.h include/hw_address.h
-
-include/bootp.h:
-
-include/pdu.h:
-
-include/endianness.h:
-
-include/ip_address.h:
-
-include/hw_address.h:
-src/crypto.o: src/crypto.cpp include/crypto.h include/dot11.h \
- include/pdu.h include/endianness.h include/hw_address.h \
- include/small_uint.h include/pdu_option.h include/network_interface.h \
- include/ip_address.h include/utils.h include/snap.h include/rawpdu.h
-
-include/crypto.h:
-
-include/dot11.h:
-
-include/pdu.h:
-
-include/endianness.h:
-
-include/hw_address.h:
-
-include/small_uint.h:
-
-include/pdu_option.h:
-
-include/network_interface.h:
-
-include/ip_address.h:
-
-include/utils.h:
-
-include/snap.h:
-
-include/rawpdu.h:
-src/dhcp.o: src/dhcp.cpp include/endianness.h include/dhcp.h \
- include/bootp.h include/pdu.h include/endianness.h include/ip_address.h \
- include/hw_address.h include/pdu_option.h include/ethernetII.h \
- include/network_interface.h
-
-include/endianness.h:
-
-include/dhcp.h:
-
-include/bootp.h:
-
-include/pdu.h:
-
-include/endianness.h:
-
-include/ip_address.h:
-
-include/hw_address.h:
-
-include/pdu_option.h:
-
-include/ethernetII.h:
-
-include/network_interface.h:
-src/dns.o: src/dns.cpp include/dns.h include/pdu.h include/endianness.h \
- include/dns_record.h include/ip_address.h
-
-include/dns.h:
-
-include/pdu.h:
-
-include/endianness.h:
-
-include/dns_record.h:
-
-include/ip_address.h:
-src/dns_record.o: src/dns_record.cpp include/dns_record.h \
- include/endianness.h
-
-include/dns_record.h:
-
-include/endianness.h:
-src/dot11.o: src/dot11.cpp include/dot11.h include/pdu.h \
- include/endianness.h include/hw_address.h include/small_uint.h \
- include/pdu_option.h include/network_interface.h include/ip_address.h \
- include/rawpdu.h include/radiotap.h include/rsn_information.h \
- include/packet_sender.h include/snap.h
-
-include/dot11.h:
-
-include/pdu.h:
-
-include/endianness.h:
-
-include/hw_address.h:
-
-include/small_uint.h:
-
-include/pdu_option.h:
-
-include/network_interface.h:
-
-include/ip_address.h:
-
-include/rawpdu.h:
-
-include/radiotap.h:
-
-include/rsn_information.h:
-
-include/packet_sender.h:
-
-include/snap.h:
-src/eapol.o: src/eapol.cpp include/eapol.h include/pdu.h \
- include/small_uint.h include/endianness.h include/dot11.h \
- include/hw_address.h include/pdu_option.h include/network_interface.h \
- include/ip_address.h include/rsn_information.h
-
-include/eapol.h:
-
-include/pdu.h:
-
-include/small_uint.h:
-
-include/endianness.h:
-
-include/dot11.h:
-
-include/hw_address.h:
-
-include/pdu_option.h:
-
-include/network_interface.h:
-
-include/ip_address.h:
-
-include/rsn_information.h:
-src/ethernetII.o: src/ethernetII.cpp include/ethernetII.h include/pdu.h \
- include/endianness.h include/hw_address.h include/network_interface.h \
- include/ip_address.h include/packet_sender.h include/rawpdu.h \
- include/ip.h include/small_uint.h include/pdu_option.h include/arp.h \
- include/constants.h
-
-include/ethernetII.h:
-
-include/pdu.h:
-
-include/endianness.h:
-
-include/hw_address.h:
-
-include/network_interface.h:
-
-include/ip_address.h:
-
-include/packet_sender.h:
-
-include/rawpdu.h:
-
-include/ip.h:
-
-include/small_uint.h:
-
-include/pdu_option.h:
-
-include/arp.h:
-
-include/constants.h:
-src/icmp.o: src/icmp.cpp include/icmp.h include/pdu.h \
- include/endianness.h include/rawpdu.h include/utils.h \
- include/ip_address.h include/hw_address.h
-
-include/icmp.h:
-
-include/pdu.h:
-
-include/endianness.h:
-
-include/rawpdu.h:
-
-include/utils.h:
-
-include/ip_address.h:
-
-include/hw_address.h:
-src/ieee802_3.o: src/ieee802_3.cpp include/ieee802_3.h include/pdu.h \
- include/endianness.h include/hw_address.h include/network_interface.h \
- include/ip_address.h include/packet_sender.h include/llc.h
-
-include/ieee802_3.h:
-
-include/pdu.h:
-
-include/endianness.h:
-
-include/hw_address.h:
-
-include/network_interface.h:
-
-include/ip_address.h:
-
-include/packet_sender.h:
-
-include/llc.h:
-src/ip_address.o: src/ip_address.cpp include/ip_address.h \
- include/endianness.h
-
-include/ip_address.h:
-
-include/endianness.h:
-src/ip.o: src/ip.cpp include/ip.h include/pdu.h include/small_uint.h \
- include/endianness.h include/ip_address.h include/pdu_option.h \
- include/tcp.h include/udp.h include/icmp.h include/rawpdu.h \
- include/utils.h include/hw_address.h include/packet_sender.h \
- include/constants.h
-
-include/ip.h:
-
-include/pdu.h:
-
-include/small_uint.h:
-
-include/endianness.h:
-
-include/ip_address.h:
-
-include/pdu_option.h:
-
-include/tcp.h:
-
-include/udp.h:
-
-include/icmp.h:
-
-include/rawpdu.h:
-
-include/utils.h:
-
-include/hw_address.h:
-
-include/packet_sender.h:
-
-include/constants.h:
-src/llc.o: src/llc.cpp include/pdu.h include/llc.h include/pdu.h \
- include/endianness.h include/rawpdu.h
-
-include/pdu.h:
-
-include/llc.h:
-
-include/pdu.h:
-
-include/endianness.h:
-
-include/rawpdu.h:
-src/loopback.o: src/loopback.cpp include/loopback.h include/pdu.h \
- include/packet_sender.h include/ip.h include/small_uint.h \
- include/endianness.h include/ip_address.h include/pdu_option.h \
- include/llc.h include/rawpdu.h
-
-include/loopback.h:
-
-include/pdu.h:
-
-include/packet_sender.h:
-
-include/ip.h:
-
-include/small_uint.h:
-
-include/endianness.h:
-
-include/ip_address.h:
-
-include/pdu_option.h:
-
-include/llc.h:
-
-include/rawpdu.h:
-src/network_interface.o: src/network_interface.cpp \
- include/network_interface.h include/hw_address.h include/ip_address.h \
- include/utils.h include/endianness.h
-
-include/network_interface.h:
-
-include/hw_address.h:
-
-include/ip_address.h:
-
-include/utils.h:
-
-include/endianness.h:
-src/packet_sender.o: src/packet_sender.cpp include/pdu.h \
- include/packet_sender.h
-
-include/pdu.h:
-
-include/packet_sender.h:
-src/packet_writer.o: src/packet_writer.cpp include/packet_writer.h \
- include/pdu.h
-
-include/packet_writer.h:
-
-include/pdu.h:
-src/pdu.o: src/pdu.cpp include/pdu.h include/rawpdu.h include/pdu.h \
- include/packet_sender.h
-
-include/pdu.h:
-
-include/rawpdu.h:
-
-include/pdu.h:
-
-include/packet_sender.h:
-src/radiotap.o: src/radiotap.cpp include/radiotap.h include/pdu.h \
- include/endianness.h include/network_interface.h include/hw_address.h \
- include/ip_address.h include/dot11.h include/small_uint.h \
- include/pdu_option.h include/utils.h include/packet_sender.h
-
-include/radiotap.h:
-
-include/pdu.h:
-
-include/endianness.h:
-
-include/network_interface.h:
-
-include/hw_address.h:
-
-include/ip_address.h:
-
-include/dot11.h:
-
-include/small_uint.h:
-
-include/pdu_option.h:
-
-include/utils.h:
-
-include/packet_sender.h:
-src/rawpdu.o: src/rawpdu.cpp include/rawpdu.h include/pdu.h
-
-include/rawpdu.h:
-
-include/pdu.h:
-src/rsn_information.o: src/rsn_information.cpp include/rsn_information.h \
- include/endianness.h
-
-include/rsn_information.h:
-
-include/endianness.h:
-src/snap.o: src/snap.cpp include/snap.h include/pdu.h \
- include/endianness.h include/small_uint.h include/constants.h \
- include/arp.h include/hw_address.h include/ip_address.h include/ip.h \
- include/pdu_option.h include/eapol.h
-
-include/snap.h:
-
-include/pdu.h:
-
-include/endianness.h:
-
-include/small_uint.h:
-
-include/constants.h:
-
-include/arp.h:
-
-include/hw_address.h:
-
-include/ip_address.h:
-
-include/ip.h:
-
-include/pdu_option.h:
-
-include/eapol.h:
-src/sniffer.o: src/sniffer.cpp include/sniffer.h include/pdu.h \
- include/ethernetII.h include/endianness.h include/hw_address.h \
- include/network_interface.h include/ip_address.h include/radiotap.h \
- include/loopback.h include/dot11.h include/small_uint.h \
- include/pdu_option.h
-
-include/sniffer.h:
-
-include/pdu.h:
-
-include/ethernetII.h:
-
-include/endianness.h:
-
-include/hw_address.h:
-
-include/network_interface.h:
-
-include/ip_address.h:
-
-include/radiotap.h:
-
-include/loopback.h:
-
-include/dot11.h:
-
-include/small_uint.h:
-
-include/pdu_option.h:
-src/tcp.o: src/tcp.cpp include/tcp.h include/pdu.h include/endianness.h \
- include/small_uint.h include/pdu_option.h include/ip.h \
- include/ip_address.h include/constants.h include/rawpdu.h \
- include/utils.h include/hw_address.h
-
-include/tcp.h:
-
-include/pdu.h:
-
-include/endianness.h:
-
-include/small_uint.h:
-
-include/pdu_option.h:
-
-include/ip.h:
-
-include/ip_address.h:
-
-include/constants.h:
-
-include/rawpdu.h:
-
-include/utils.h:
-
-include/hw_address.h:
-src/tcp_stream.o: src/tcp_stream.cpp include/rawpdu.h include/pdu.h \
- include/tcp_stream.h include/sniffer.h include/ethernetII.h \
- include/endianness.h include/hw_address.h include/network_interface.h \
- include/ip_address.h include/radiotap.h include/loopback.h \
- include/dot11.h include/small_uint.h include/pdu_option.h include/tcp.h \
- include/ip.h
-
-include/rawpdu.h:
-
-include/pdu.h:
-
-include/tcp_stream.h:
-
-include/sniffer.h:
-
-include/ethernetII.h:
-
-include/endianness.h:
-
-include/hw_address.h:
-
-include/network_interface.h:
-
-include/ip_address.h:
-
-include/radiotap.h:
-
-include/loopback.h:
-
-include/dot11.h:
-
-include/small_uint.h:
-
-include/pdu_option.h:
-
-include/tcp.h:
-
-include/ip.h:
-src/udp.o: src/udp.cpp include/udp.h include/pdu.h include/endianness.h \
- include/constants.h include/utils.h include/ip_address.h \
- include/hw_address.h include/ip.h include/small_uint.h \
- include/pdu_option.h include/rawpdu.h
-
-include/udp.h:
-
-include/pdu.h:
-
-include/endianness.h:
-
-include/constants.h:
-
-include/utils.h:
-
-include/ip_address.h:
-
-include/hw_address.h:
-
-include/ip.h:
-
-include/small_uint.h:
-
-include/pdu_option.h:
-
-include/rawpdu.h:
-src/utils.o: src/utils.cpp include/utils.h include/ip_address.h \
- include/hw_address.h include/pdu.h include/ip.h include/pdu.h \
- include/small_uint.h include/endianness.h include/pdu_option.h \
- include/arp.h include/endianness.h include/network_interface.h \
- include/packet_sender.h
-
-include/utils.h:
-
-include/ip_address.h:
-
-include/hw_address.h:
-
-include/pdu.h:
-
-include/ip.h:
-
-include/pdu.h:
-
-include/small_uint.h:
-
-include/endianness.h:
-
-include/pdu_option.h:
-
-include/arp.h:
-
-include/endianness.h:
-
-include/network_interface.h:
-
-include/packet_sender.h:

examples/CMakeLists.txt

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

examples/Makefile.in

@@ -1,7 +1,7 @@
 CXX=@CXX@
 CXXFLAGS=-Wall @CXXFLAGS@
 LDFLAGS=-ltins
-EXECUTABLES=arpspoof portscan traceroute beacon_display
+EXECUTABLES=arpspoofing arpmonitor portscan traceroute beacon_display dns_queries dns_spoof dns_stats wps_detect
 
 all: $(EXECUTABLES)
 
@@ -9,11 +9,26 @@ compile: $(OBJECTS)
 
 recompile: clean all
 
-arpspoof: 
+arpspoofing: 
 	$(CXX) arpspoofing.cpp -o arpspoofing $(CXXFLAGS) $(LDFLAGS)
 
+arpmonitor: 
+	$(CXX) arpmonitor.cpp -o arpmonitor -std=c++0x $(CXXFLAGS) $(LDFLAGS)
+
+dns_queries: 
+	$(CXX) dns_queries.cpp -o dns_queries -std=c++0x  $(CXXFLAGS) $(LDFLAGS)
+
+dns_spoof: 
+	$(CXX) dns_spoof.cpp -o dns_spoof -std=c++0x  $(CXXFLAGS) $(LDFLAGS)
+
+dns_stats: 
+	$(CXX) dns_stats.cpp -o dns_stats -std=c++0x $(CXXFLAGS) $(LDFLAGS) -lpthread 
+
 beacon_display: 
 	$(CXX) beacon_display.cpp -o beacon_display $(CXXFLAGS) $(LDFLAGS) 	
+	
+wps_detect: 
+	$(CXX) wps_detect.cpp -o wps_detect -std=c++0x  $(CXXFLAGS) $(LDFLAGS)
 
 portscan:
 	$(CXX) portscan.cpp -o portscan $(CXXFLAGS) $(LDFLAGS) -lpthread

examples/arpmonitor.cpp

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

examples/arpspoofing.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -32,6 +32,7 @@
 #include <string>
 #include <stdexcept>
 #include <cstdlib>
+#include <unistd.h>
 #include <tins/arp.h>
 #include <tins/network_interface.h>
 #include <tins/utils.h>
@@ -42,23 +43,18 @@ using namespace std;
 using namespace Tins;
 
 
-int do_arp_spoofing(NetworkInterface iface, IPv4Address gw, IPv4Address victim, 
+void do_arp_spoofing(NetworkInterface iface, IPv4Address gw, IPv4Address victim, 
   const NetworkInterface::Info &info) 
 {
     PacketSender sender;
     EthernetII::address_type gw_hw, victim_hw;
     
     // Resolves gateway's hardware address.
-    if(!Utils::resolve_hwaddr(iface, gw, &gw_hw, sender)) {
-        cout << "Could not resolve gateway's ip address.\n";
-        return 5;
-    }
+    gw_hw = Utils::resolve_hwaddr(iface, gw, sender);
     
     // Resolves victim's hardware address.
-    if(!Utils::resolve_hwaddr(iface, victim, &victim_hw, sender)) {
-        cout << "Could not resolve victim's ip address.\n";
-        return 6;
-    }
+    victim_hw = Utils::resolve_hwaddr(iface, victim, sender);
+
     // Print out the hw addresses we're using.
     cout << " Using gateway hw address: " << gw_hw << "\n";
     cout << " Using victim hw address:  " << victim_hw << "\n";
@@ -66,22 +62,22 @@ int do_arp_spoofing(NetworkInterface iface, IPv4Address gw, IPv4Address victim,
     
     /* We tell the gateway that the victim is at out hw address,
      * and tell the victim that the gateway is at out hw address */
-    ARP *gw_arp     = new ARP(gw, victim, gw_hw, info.hw_addr), 
-        *victim_arp = new ARP(victim, gw, victim_hw, info.hw_addr);
+    ARP gw_arp(gw, victim, gw_hw, info.hw_addr), 
+        victim_arp(victim, gw, victim_hw, info.hw_addr);
     // We are "replying" ARP requests
-    gw_arp->opcode(ARP::REPLY);
-    victim_arp->opcode(ARP::REPLY);
+    gw_arp.opcode(ARP::REPLY);
+    victim_arp.opcode(ARP::REPLY);
     
     /* The packet we'll send to the gateway and victim. 
      * We include our hw address as the source address
      * in ethernet layer, to avoid possible packet dropping
      * performed by any routers. */
-    EthernetII to_gw(iface, gw_hw, info.hw_addr, gw_arp);
-    EthernetII to_victim(iface, victim_hw, info.hw_addr, victim_arp);
+    EthernetII to_gw = EthernetII(gw_hw, info.hw_addr) / gw_arp;
+    EthernetII to_victim = EthernetII(victim_hw, info.hw_addr) / victim_arp;
     while(true) {
         // Just send them once every 5 seconds.
-        sender.send(to_gw);
-        sender.send(to_victim);
+        sender.send(to_gw, iface);
+        sender.send(to_victim, iface);
         sleep(5);
     }
 }
@@ -115,7 +111,7 @@ int main(int argc, char *argv[]) {
         return 3;
     }
     try {
-        return do_arp_spoofing(iface, gw, victim, info);
+        do_arp_spoofing(iface, gw, victim, info);
     }
     catch(std::runtime_error &ex) {
         std::cout << "Runtime error: " << ex.what() << std::endl;

examples/beacon_display.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -47,17 +47,17 @@ private:
 };
  
 void BeaconSniffer::run(const std::string &iface) {
-    Sniffer sniffer(iface, 1500, true, "type mgt subtype beacon");
+    Sniffer sniffer(iface, Sniffer::PROMISC, "type mgt subtype beacon", true);
     sniffer.sniff_loop(make_sniffer_handler(this, &BeaconSniffer::callback));
 }
  
 bool BeaconSniffer::callback(PDU &pdu) {
     // Get the Dot11 layer
-    Dot11Beacon *beacon = pdu.find_pdu<Dot11Beacon>();
+    const Dot11Beacon &beacon = pdu.rfind_pdu<Dot11Beacon>();
     // All beacons must have from_ds == to_ds == 0
-    if(beacon && !beacon->from_ds() && !beacon->to_ds()) {
+    if(!beacon.from_ds() && !beacon.to_ds()) {
         // Get the AP address
-        address_type addr = beacon->addr2();
+        address_type addr = beacon.addr2();
         // Look it up in our set
         ssids_type::iterator it = ssids.find(addr);
         if(it == ssids.end()) {
@@ -66,7 +66,7 @@ bool BeaconSniffer::callback(PDU &pdu) {
                 /* If no ssid option is set, then Dot11::ssid will throw 
                  * a std::runtime_error.
                  */
-                std::string ssid = beacon->ssid();
+                std::string ssid = beacon.ssid();
                 // Save it so we don't show it again.
                 ssids.insert(addr);
                 // Display the tuple "address - ssid".

examples/configure

@@ -1,11 +1,9 @@
 #! /bin/sh
 # Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.67 for myconfig 0.1.
+# Generated by GNU Autoconf 2.69 for myconfig 0.1.
 #
 #
-# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
-# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software
-# Foundation, Inc.
+# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
 #
 #
 # This configure script is free software; the Free Software Foundation
@@ -89,6 +87,7 @@ fi
 IFS=" ""	$as_nl"
 
 # Find who we are.  Look in the path if we contain no directory separator.
+as_myself=
 case $0 in #((
   *[\\/]* ) as_myself=$0 ;;
   *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -133,6 +132,31 @@ export LANGUAGE
 # CDPATH.
 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
 
+# Use a proper internal environment variable to ensure we don't fall
+  # into an infinite loop, continuously re-executing ourselves.
+  if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
+    _as_can_reexec=no; export _as_can_reexec;
+    # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+  *v*x* | *x*v* ) as_opts=-vx ;;
+  *v* ) as_opts=-v ;;
+  *x* ) as_opts=-x ;;
+  * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
+as_fn_exit 255
+  fi
+  # We don't want this to propagate to other subprocesses.
+          { _as_can_reexec=; unset _as_can_reexec;}
 if test "x$CONFIG_SHELL" = x; then
   as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
   emulate sh
@@ -166,7 +190,8 @@ if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
 else
   exitcode=1; echo positional parameters were not saved.
 fi
-test x\$exitcode = x0 || exit 1"
+test x\$exitcode = x0 || exit 1
+test -x / || exit 1"
   as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
   as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
   eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
@@ -211,14 +236,25 @@ IFS=$as_save_IFS
 
 
       if test "x$CONFIG_SHELL" != x; then :
-  # We cannot yet assume a decent shell, so we have to provide a
-	# neutralization value for shells without unset; and this also
-	# works around shells that cannot unset nonexistent variables.
-	BASH_ENV=/dev/null
-	ENV=/dev/null
-	(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
-	export CONFIG_SHELL
-	exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}
+  export CONFIG_SHELL
+             # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+  *v*x* | *x*v* ) as_opts=-vx ;;
+  *v* ) as_opts=-v ;;
+  *x* ) as_opts=-x ;;
+  * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
+exit 255
 fi
 
     if test x$as_have_required = xno; then :
@@ -320,6 +356,14 @@ $as_echo X"$as_dir" |
 
 
 } # as_fn_mkdir_p
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+  test -f "$1" && test -x "$1"
+} # as_fn_executable_p
 # as_fn_append VAR VALUE
 # ----------------------
 # Append the text in VALUE to the end of the definition contained in VAR. Take
@@ -441,6 +485,10 @@ as_cr_alnum=$as_cr_Letters$as_cr_digits
   chmod +x "$as_me.lineno" ||
     { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
 
+  # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
+  # already done that, so ensure we don't try to do so again and fall
+  # in an infinite loop.  This has already happened in practice.
+  _as_can_reexec=no; export _as_can_reexec
   # Don't try to exec as it changes $[0], causing all sort of problems
   # (the dirname of $[0] is not the place where we might find the
   # original and so on.  Autoconf is especially sensitive to this).
@@ -475,16 +523,16 @@ if (echo >conf$$.file) 2>/dev/null; then
     # ... but there are two gotchas:
     # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
     # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
-    # In both cases, we have to default to `cp -p'.
+    # In both cases, we have to default to `cp -pR'.
     ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
-      as_ln_s='cp -p'
+      as_ln_s='cp -pR'
   elif ln conf$$.file conf$$ 2>/dev/null; then
     as_ln_s=ln
   else
-    as_ln_s='cp -p'
+    as_ln_s='cp -pR'
   fi
 else
-  as_ln_s='cp -p'
+  as_ln_s='cp -pR'
 fi
 rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
 rmdir conf$$.dir 2>/dev/null
@@ -496,28 +544,8 @@ else
   as_mkdir_p=false
 fi
 
-if test -x / >/dev/null 2>&1; then
-  as_test_x='test -x'
-else
-  if ls -dL / >/dev/null 2>&1; then
-    as_ls_L_option=L
-  else
-    as_ls_L_option=
-  fi
-  as_test_x='
-    eval sh -c '\''
-      if test -d "$1"; then
-	test -d "$1/.";
-      else
-	case $1 in #(
-	-*)set "./$1";;
-	esac;
-	case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
-	???[sx]*):;;*)false;;esac;fi
-    '\'' sh
-  '
-fi
-as_executable_p=$as_test_x
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
 
 # Sed expression to map a string onto a valid CPP name.
 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
@@ -592,7 +620,6 @@ ac_includes_default="\
 
 ac_subst_vars='LTLIBOBJS
 LIBOBJS
-CFLAGS
 EGREP
 GREP
 CXXCPP
@@ -1059,7 +1086,7 @@ Try \`$0 --help' for more information"
     $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
       $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
-    : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
+    : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
     ;;
 
   esac
@@ -1110,8 +1137,6 @@ target=$target_alias
 if test "x$host_alias" != x; then
   if test "x$build_alias" = x; then
     cross_compiling=maybe
-    $as_echo "$as_me: WARNING: if you wanted to set the --build type, don't use --host.
-    If a cross compiler is detected then cross compile mode will be used" >&2
   elif test "x$build_alias" != "x$host_alias"; then
     cross_compiling=yes
   fi
@@ -1339,9 +1364,9 @@ test -n "$ac_init_help" && exit $ac_status
 if $ac_init_version; then
   cat <<\_ACEOF
 myconfig configure 0.1
-generated by GNU Autoconf 2.67
+generated by GNU Autoconf 2.69
 
-Copyright (C) 2010 Free Software Foundation, Inc.
+Copyright (C) 2012 Free Software Foundation, Inc.
 This configure script is free software; the Free Software Foundation
 gives unlimited permission to copy, distribute and modify it.
 _ACEOF
@@ -1385,11 +1410,57 @@ sed 's/^/| /' conftest.$ac_ext >&5
 
 	ac_retval=1
 fi
-  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
   as_fn_set_status $ac_retval
 
 } # ac_fn_cxx_try_compile
 
+# ac_fn_cxx_try_link LINENO
+# -------------------------
+# Try to link conftest.$ac_ext, and return whether this succeeded.
+ac_fn_cxx_try_link ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext conftest$ac_exeext
+  if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_cxx_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest$ac_exeext && {
+	 test "$cross_compiling" = yes ||
+	 test -x conftest$ac_exeext
+       }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
+  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
+  # interfere with the next link command; also delete a directory that is
+  # left behind by Apple's compiler.  We do this before executing the actions.
+  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_cxx_try_link
+
 # ac_fn_cxx_try_cpp LINENO
 # ------------------------
 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
@@ -1422,7 +1493,7 @@ sed 's/^/| /' conftest.$ac_ext >&5
 
     ac_retval=1
 fi
-  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
   as_fn_set_status $ac_retval
 
 } # ac_fn_cxx_try_cpp
@@ -1435,10 +1506,10 @@ fi
 ac_fn_cxx_check_header_mongrel ()
 {
   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  if eval "test \"\${$3+set}\"" = set; then :
+  if eval \${$3+:} false; then :
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
 $as_echo_n "checking for $2... " >&6; }
-if eval "test \"\${$3+set}\"" = set; then :
+if eval \${$3+:} false; then :
   $as_echo_n "(cached) " >&6
 fi
 eval ac_res=\$$3
@@ -1501,7 +1572,7 @@ $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
 esac
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
 $as_echo_n "checking for $2... " >&6; }
-if eval "test \"\${$3+set}\"" = set; then :
+if eval \${$3+:} false; then :
   $as_echo_n "(cached) " >&6
 else
   eval "$3=\$ac_header_compiler"
@@ -1510,7 +1581,7 @@ eval ac_res=\$$3
 	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
 $as_echo "$ac_res" >&6; }
 fi
-  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
 
 } # ac_fn_cxx_check_header_mongrel
 
@@ -1551,7 +1622,7 @@ sed 's/^/| /' conftest.$ac_ext >&5
        ac_retval=$ac_status
 fi
   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
-  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
   as_fn_set_status $ac_retval
 
 } # ac_fn_cxx_try_run
@@ -1565,7 +1636,7 @@ ac_fn_cxx_check_header_compile ()
   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
 $as_echo_n "checking for $2... " >&6; }
-if eval "test \"\${$3+set}\"" = set; then :
+if eval \${$3+:} false; then :
   $as_echo_n "(cached) " >&6
 else
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
@@ -1583,61 +1654,15 @@ fi
 eval ac_res=\$$3
 	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
 $as_echo "$ac_res" >&6; }
-  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
 
 } # ac_fn_cxx_check_header_compile
-
-# ac_fn_cxx_try_link LINENO
-# -------------------------
-# Try to link conftest.$ac_ext, and return whether this succeeded.
-ac_fn_cxx_try_link ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  rm -f conftest.$ac_objext conftest$ac_exeext
-  if { { ac_try="$ac_link"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_link") 2>conftest.err
-  ac_status=$?
-  if test -s conftest.err; then
-    grep -v '^ *+' conftest.err >conftest.er1
-    cat conftest.er1 >&5
-    mv -f conftest.er1 conftest.err
-  fi
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } && {
-	 test -z "$ac_cxx_werror_flag" ||
-	 test ! -s conftest.err
-       } && test -s conftest$ac_exeext && {
-	 test "$cross_compiling" = yes ||
-	 $as_test_x conftest$ac_exeext
-       }; then :
-  ac_retval=0
-else
-  $as_echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-	ac_retval=1
-fi
-  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
-  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
-  # interfere with the next link command; also delete a directory that is
-  # left behind by Apple's compiler.  We do this before executing the actions.
-  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
-  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
-  as_fn_set_status $ac_retval
-
-} # ac_fn_cxx_try_link
 cat >config.log <<_ACEOF
 This file contains any messages produced by compilers while
 running configure, to aid debugging if configure makes a mistake.
 
 It was created by myconfig $as_me 0.1, which was
-generated by GNU Autoconf 2.67.  Invocation command line was
+generated by GNU Autoconf 2.69.  Invocation command line was
 
   $ $0 $@
 
@@ -1895,7 +1920,7 @@ $as_echo "$as_me: loading site script $ac_site_file" >&6;}
       || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
 as_fn_error $? "failed to load site script $ac_site_file
-See \`config.log' for more details" "$LINENO" 5 ; }
+See \`config.log' for more details" "$LINENO" 5; }
   fi
 done
 
@@ -2001,7 +2026,7 @@ if test -z "$CXX"; then
 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_CXX+set}" = set; then :
+if ${ac_cv_prog_CXX+:} false; then :
   $as_echo_n "(cached) " >&6
 else
   if test -n "$CXX"; then
@@ -2013,7 +2038,7 @@ do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
-  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
@@ -2045,7 +2070,7 @@ do
 set dummy $ac_prog; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then :
+if ${ac_cv_prog_ac_ct_CXX+:} false; then :
   $as_echo_n "(cached) " >&6
 else
   if test -n "$ac_ct_CXX"; then
@@ -2057,7 +2082,7 @@ do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
-  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     ac_cv_prog_ac_ct_CXX="$ac_prog"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
@@ -2209,7 +2234,7 @@ sed 's/^/| /' conftest.$ac_ext >&5
 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
 as_fn_error 77 "C++ compiler cannot create executables
-See \`config.log' for more details" "$LINENO" 5 ; }
+See \`config.log' for more details" "$LINENO" 5; }
 else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 $as_echo "yes" >&6; }
@@ -2252,7 +2277,7 @@ else
   { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
 as_fn_error $? "cannot compute suffix of executables: cannot compile and link
-See \`config.log' for more details" "$LINENO" 5 ; }
+See \`config.log' for more details" "$LINENO" 5; }
 fi
 rm -f conftest conftest$ac_cv_exeext
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
@@ -2311,7 +2336,7 @@ $as_echo "$ac_try_echo"; } >&5
 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
 as_fn_error $? "cannot run C++ compiled programs.
 If you meant to cross compile, use \`--host'.
-See \`config.log' for more details" "$LINENO" 5 ; }
+See \`config.log' for more details" "$LINENO" 5; }
     fi
   fi
 fi
@@ -2322,7 +2347,7 @@ rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
 ac_clean_files=$ac_clean_files_save
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
 $as_echo_n "checking for suffix of object files... " >&6; }
-if test "${ac_cv_objext+set}" = set; then :
+if ${ac_cv_objext+:} false; then :
   $as_echo_n "(cached) " >&6
 else
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
@@ -2363,7 +2388,7 @@ sed 's/^/| /' conftest.$ac_ext >&5
 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
 as_fn_error $? "cannot compute suffix of object files: cannot compile
-See \`config.log' for more details" "$LINENO" 5 ; }
+See \`config.log' for more details" "$LINENO" 5; }
 fi
 rm -f conftest.$ac_cv_objext conftest.$ac_ext
 fi
@@ -2373,7 +2398,7 @@ OBJEXT=$ac_cv_objext
 ac_objext=$OBJEXT
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
 $as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
-if test "${ac_cv_cxx_compiler_gnu+set}" = set; then :
+if ${ac_cv_cxx_compiler_gnu+:} false; then :
   $as_echo_n "(cached) " >&6
 else
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
@@ -2410,7 +2435,7 @@ ac_test_CXXFLAGS=${CXXFLAGS+set}
 ac_save_CXXFLAGS=$CXXFLAGS
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
 $as_echo_n "checking whether $CXX accepts -g... " >&6; }
-if test "${ac_cv_prog_cxx_g+set}" = set; then :
+if ${ac_cv_prog_cxx_g+:} false; then :
   $as_echo_n "(cached) " >&6
 else
   ac_save_cxx_werror_flag=$ac_cxx_werror_flag
@@ -2499,13 +2524,30 @@ ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ex
 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 
 
-if test -n "$debug"
-then
-    CFLAGS="-DDEBUG -g"
-else
-    CFLAGS="-O3"
-fi
+saved_libs="${LIBS}"
+LIBS="${LIBS} -ltins"
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking libtins" >&5
+$as_echo_n "checking libtins... " >&6; }
 
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <tins/dns.h>
+int
+main ()
+{
+Tins::DNS dummy
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_link "$LINENO"; then :
+  echo done
+else
+  echo error; echo *** libtins is not installed. Aborting... ***; exit 1
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS="${saved_libs}"
 
 ac_ext=cpp
 ac_cpp='$CXXCPP $CPPFLAGS'
@@ -2515,7 +2557,7 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
 $as_echo_n "checking how to run the C++ preprocessor... " >&6; }
 if test -z "$CXXCPP"; then
-  if test "${ac_cv_prog_CXXCPP+set}" = set; then :
+  if ${ac_cv_prog_CXXCPP+:} false; then :
   $as_echo_n "(cached) " >&6
 else
       # Double quotes because CXXCPP needs to be expanded
@@ -2631,7 +2673,7 @@ else
   { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
 as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check
-See \`config.log' for more details" "$LINENO" 5 ; }
+See \`config.log' for more details" "$LINENO" 5; }
 fi
 
 ac_ext=cpp
@@ -2643,7 +2685,7 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
-if test "${ac_cv_path_GREP+set}" = set; then :
+if ${ac_cv_path_GREP+:} false; then :
   $as_echo_n "(cached) " >&6
 else
   if test -z "$GREP"; then
@@ -2657,7 +2699,7 @@ do
     for ac_prog in grep ggrep; do
     for ac_exec_ext in '' $ac_executable_extensions; do
       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
-      { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
+      as_fn_executable_p "$ac_path_GREP" || continue
 # Check for GNU ac_path_GREP and select it if it is found.
   # Check for GNU $ac_path_GREP
 case `"$ac_path_GREP" --version 2>&1` in
@@ -2706,7 +2748,7 @@ $as_echo "$ac_cv_path_GREP" >&6; }
 
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
 $as_echo_n "checking for egrep... " >&6; }
-if test "${ac_cv_path_EGREP+set}" = set; then :
+if ${ac_cv_path_EGREP+:} false; then :
   $as_echo_n "(cached) " >&6
 else
   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
@@ -2723,7 +2765,7 @@ do
     for ac_prog in egrep; do
     for ac_exec_ext in '' $ac_executable_extensions; do
       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
-      { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
+      as_fn_executable_p "$ac_path_EGREP" || continue
 # Check for GNU ac_path_EGREP and select it if it is found.
   # Check for GNU $ac_path_EGREP
 case `"$ac_path_EGREP" --version 2>&1` in
@@ -2773,7 +2815,7 @@ $as_echo "$ac_cv_path_EGREP" >&6; }
 
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
 $as_echo_n "checking for ANSI C header files... " >&6; }
-if test "${ac_cv_header_stdc+set}" = set; then :
+if ${ac_cv_header_stdc+:} false; then :
   $as_echo_n "(cached) " >&6
 else
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
@@ -2900,65 +2942,20 @@ fi
 done
 
 
-for ac_header in pcap.h
+for ac_header in tins/tins.h
 do :
-  ac_fn_cxx_check_header_mongrel "$LINENO" "pcap.h" "ac_cv_header_pcap_h" "$ac_includes_default"
-if test "x$ac_cv_header_pcap_h" = x""yes; then :
+  ac_fn_cxx_check_header_mongrel "$LINENO" "tins/tins.h" "ac_cv_header_tins_tins_h" "$ac_includes_default"
+if test "x$ac_cv_header_tins_tins_h" = xyes; then :
   cat >>confdefs.h <<_ACEOF
-#define HAVE_PCAP_H 1
+#define HAVE_TINS_TINS_H 1
 _ACEOF
 
+else
+  echo "*** Error: libtins' headers are absent ***"; exit 1;
 fi
 
 done
 
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for pcap_loop in -lpcap" >&5
-$as_echo_n "checking for pcap_loop in -lpcap... " >&6; }
-if test "${ac_cv_lib_pcap_pcap_loop+set}" = set; then :
-  $as_echo_n "(cached) " >&6
-else
-  ac_check_lib_save_LIBS=$LIBS
-LIBS="-lpcap  $LIBS"
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-/* Override any GCC internal prototype to avoid an error.
-   Use char because int might match the return type of a GCC
-   builtin and then its argument prototype would still apply.  */
-#ifdef __cplusplus
-extern "C"
-#endif
-char pcap_loop ();
-int
-main ()
-{
-return pcap_loop ();
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_cxx_try_link "$LINENO"; then :
-  ac_cv_lib_pcap_pcap_loop=yes
-else
-  ac_cv_lib_pcap_pcap_loop=no
-fi
-rm -f core conftest.err conftest.$ac_objext \
-    conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pcap_pcap_loop" >&5
-$as_echo "$ac_cv_lib_pcap_pcap_loop" >&6; }
-if test "x$ac_cv_lib_pcap_pcap_loop" = x""yes; then :
-  cat >>confdefs.h <<_ACEOF
-#define HAVE_LIBPCAP 1
-_ACEOF
-
-  LIBS="-lpcap $LIBS"
-
-else
-  as_fn_error $? "pcap library is needed!" "$LINENO" 5
-fi
-
 
 ac_config_files="$ac_config_files Makefile"
 
@@ -3026,10 +3023,21 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
      :end' >>confcache
 if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
   if test -w "$cache_file"; then
-    test "x$cache_file" != "x/dev/null" &&
+    if test "x$cache_file" != "x/dev/null"; then
       { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
 $as_echo "$as_me: updating cache $cache_file" >&6;}
-    cat confcache >$cache_file
+      if test ! -f "$cache_file" || test -h "$cache_file"; then
+	cat confcache >"$cache_file"
+      else
+        case $cache_file in #(
+        */* | ?:*)
+	  mv -f confcache "$cache_file"$$ &&
+	  mv -f "$cache_file"$$ "$cache_file" ;; #(
+        *)
+	  mv -f confcache "$cache_file" ;;
+	esac
+      fi
+    fi
   else
     { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
 $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
@@ -3097,7 +3105,7 @@ LTLIBOBJS=$ac_ltlibobjs
 
 
 
-: ${CONFIG_STATUS=./config.status}
+: "${CONFIG_STATUS=./config.status}"
 ac_write_fail=0
 ac_clean_files_save=$ac_clean_files
 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
@@ -3198,6 +3206,7 @@ fi
 IFS=" ""	$as_nl"
 
 # Find who we are.  Look in the path if we contain no directory separator.
+as_myself=
 case $0 in #((
   *[\\/]* ) as_myself=$0 ;;
   *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -3393,16 +3402,16 @@ if (echo >conf$$.file) 2>/dev/null; then
     # ... but there are two gotchas:
     # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
     # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
-    # In both cases, we have to default to `cp -p'.
+    # In both cases, we have to default to `cp -pR'.
     ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
-      as_ln_s='cp -p'
+      as_ln_s='cp -pR'
   elif ln conf$$.file conf$$ 2>/dev/null; then
     as_ln_s=ln
   else
-    as_ln_s='cp -p'
+    as_ln_s='cp -pR'
   fi
 else
-  as_ln_s='cp -p'
+  as_ln_s='cp -pR'
 fi
 rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
 rmdir conf$$.dir 2>/dev/null
@@ -3462,28 +3471,16 @@ else
   as_mkdir_p=false
 fi
 
-if test -x / >/dev/null 2>&1; then
-  as_test_x='test -x'
-else
-  if ls -dL / >/dev/null 2>&1; then
-    as_ls_L_option=L
-  else
-    as_ls_L_option=
-  fi
-  as_test_x='
-    eval sh -c '\''
-      if test -d "$1"; then
-	test -d "$1/.";
-      else
-	case $1 in #(
-	-*)set "./$1";;
-	esac;
-	case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
-	???[sx]*):;;*)false;;esac;fi
-    '\'' sh
-  '
-fi
-as_executable_p=$as_test_x
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+  test -f "$1" && test -x "$1"
+} # as_fn_executable_p
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
 
 # Sed expression to map a string onto a valid CPP name.
 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
@@ -3505,7 +3502,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
 # values after options handling.
 ac_log="
 This file was extended by myconfig $as_me 0.1, which was
-generated by GNU Autoconf 2.67.  Invocation command line was
+generated by GNU Autoconf 2.69.  Invocation command line was
 
   CONFIG_FILES    = $CONFIG_FILES
   CONFIG_HEADERS  = $CONFIG_HEADERS
@@ -3558,10 +3555,10 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
 ac_cs_version="\\
 myconfig config.status 0.1
-configured by $0, generated by GNU Autoconf 2.67,
+configured by $0, generated by GNU Autoconf 2.69,
   with options \\"\$ac_cs_config\\"
 
-Copyright (C) 2010 Free Software Foundation, Inc.
+Copyright (C) 2012 Free Software Foundation, Inc.
 This config.status script is free software; the Free Software Foundation
 gives unlimited permission to copy, distribute and modify it."
 
@@ -3638,7 +3635,7 @@ fi
 _ACEOF
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 if \$ac_cs_recheck; then
-  set X '$SHELL' '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+  set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
   shift
   \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
   CONFIG_SHELL='$SHELL'
@@ -3669,7 +3666,7 @@ do
   case $ac_config_target in
     "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
 
-  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5 ;;
+  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
   esac
 done
 
@@ -3690,9 +3687,10 @@ fi
 # after its creation but before its name has been assigned to `$tmp'.
 $debug ||
 {
-  tmp=
+  tmp= ac_tmp=
   trap 'exit_status=$?
-  { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status
+  : "${ac_tmp:=$tmp}"
+  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
 ' 0
   trap 'as_fn_exit 1' 1 2 13 15
 }
@@ -3700,12 +3698,13 @@ $debug ||
 
 {
   tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
-  test -n "$tmp" && test -d "$tmp"
+  test -d "$tmp"
 }  ||
 {
   tmp=./conf$$-$RANDOM
   (umask 077 && mkdir "$tmp")
 } || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
+ac_tmp=$tmp
 
 # Set up the scripts for CONFIG_FILES section.
 # No need to generate them if there are no CONFIG_FILES.
@@ -3727,7 +3726,7 @@ else
   ac_cs_awk_cr=$ac_cr
 fi
 
-echo 'BEGIN {' >"$tmp/subs1.awk" &&
+echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
 _ACEOF
 
 
@@ -3755,7 +3754,7 @@ done
 rm -f conf$$subs.sh
 
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-cat >>"\$tmp/subs1.awk" <<\\_ACAWK &&
+cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
 _ACEOF
 sed -n '
 h
@@ -3803,7 +3802,7 @@ t delim
 rm -f conf$$subs.awk
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 _ACAWK
-cat >>"\$tmp/subs1.awk" <<_ACAWK &&
+cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
   for (key in S) S_is_set[key] = 1
   FS = ""
 
@@ -3835,7 +3834,7 @@ if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
   sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
 else
   cat
-fi < "$tmp/subs1.awk" > "$tmp/subs.awk" \
+fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
   || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
 _ACEOF
 
@@ -3875,7 +3874,7 @@ do
   esac
   case $ac_mode$ac_tag in
   :[FHL]*:*);;
-  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5 ;;
+  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
   :[FH]-) ac_tag=-:-;;
   :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
   esac
@@ -3894,7 +3893,7 @@ do
     for ac_f
     do
       case $ac_f in
-      -) ac_f="$tmp/stdin";;
+      -) ac_f="$ac_tmp/stdin";;
       *) # Look for the file first in the build tree, then in the source tree
 	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
 	 # because $ac_f cannot contain `:'.
@@ -3903,7 +3902,7 @@ do
 	   [\\/$]*) false;;
 	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
 	   esac ||
-	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5 ;;
+	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
       esac
       case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
       as_fn_append ac_file_inputs " '$ac_f'"
@@ -3929,8 +3928,8 @@ $as_echo "$as_me: creating $ac_file" >&6;}
     esac
 
     case $ac_tag in
-    *:-:* | *:-) cat >"$tmp/stdin" \
-      || as_fn_error $? "could not create $ac_file" "$LINENO" 5  ;;
+    *:-:* | *:-) cat >"$ac_tmp/stdin" \
+      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
     esac
     ;;
   esac
@@ -4055,21 +4054,22 @@ s&@abs_builddir@&$ac_abs_builddir&;t t
 s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
 $ac_datarootdir_hack
 "
-eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$tmp/subs.awk" >$tmp/out \
-  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
+  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
 
 test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
-  { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } &&
-  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } &&
+  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
+  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' \
+      "$ac_tmp/out"`; test -z "$ac_out"; } &&
   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
 which seems to be undefined.  Please make sure it is defined" >&5
 $as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
 which seems to be undefined.  Please make sure it is defined" >&2;}
 
-  rm -f "$tmp/stdin"
+  rm -f "$ac_tmp/stdin"
   case $ac_file in
-  -) cat "$tmp/out" && rm -f "$tmp/out";;
-  *) rm -f "$ac_file" && mv "$tmp/out" "$ac_file";;
+  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
+  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
   esac \
   || as_fn_error $? "could not create $ac_file" "$LINENO" 5
  ;;

examples/configure.ac

@@ -3,14 +3,15 @@ AC_INIT(myconfig, 0.1)
 AC_PROG_CXX()
 AC_LANG(C++)
 
-if test -n "$debug"
-then
-    CFLAGS="-DDEBUG -g"
-else
-    CFLAGS="-O3"
-fi
+saved_libs="${LIBS}"
+LIBS="${LIBS} -ltins"
+AC_MSG_CHECKING(libtins)
+AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <tins/dns.h>], 
+    [Tins::DNS dummy])],
+    [echo done],
+    [echo error; echo *** libtins is not installed. Aborting... ***; exit 1])
+LIBS="${saved_libs}"
+
+AC_CHECK_HEADERS([tins/tins.h], , [echo "*** Error: libtins' headers are absent ***"; exit 1;])
 
-AC_CHECK_HEADERS([pcap.h])
-AC_CHECK_LIB(pcap, pcap_loop, [], [AC_MSG_ERROR([pcap library is needed!])])
-AC_SUBST(CFLAGS)
 AC_OUTPUT(Makefile)

examples/dns_queries.cpp

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

examples/dns_spoof.cpp

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

examples/dns_stats.cpp

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

examples/portscan.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -33,6 +33,7 @@
 #include <string>
 #include <cstdlib>
 #include <pthread.h>
+#include <unistd.h>
 #include <tins/ip.h>
 #include <tins/tcp.h>
 #include <tins/ip_address.h>
@@ -53,19 +54,17 @@ typedef std::pair<Sniffer*, std::string> sniffer_data;
  * the scanned port's status.
  */
 bool handler(PDU &pdu) {
-    TCP *tcp = pdu.find_pdu<TCP>();
-    if(tcp) {
-        // Ok, it's a TCP PDU. Is RST flag on? Then port is closed.
-        if(tcp->get_flag(TCP::RST)) {
-            // This indicates we should stop sniffing.
-            if(tcp->get_flag(TCP::SYN))
-                return false;
-            cout << "Port: " << setw(5) << tcp->sport() << " closed\n";
-        }
-        // Is SYN flag on? Then port is open!
-        else if(tcp->get_flag(TCP::SYN) && tcp->get_flag(TCP::ACK))
-            cout << "Port: " << setw(5) << tcp->sport() << " open\n";
+    const TCP &tcp = pdu.rfind_pdu<TCP>();
+    // Ok, it's a TCP PDU. Is RST flag on? Then port is closed.
+    if(tcp.get_flag(TCP::RST)) {
+        // This indicates we should stop sniffing.
+        if(tcp.get_flag(TCP::SYN))
+            return false;
+        cout << "Port: " << setw(5) << tcp.sport() << " closed\n";
     }
+    // Is SYN flag on? Then port is open!
+    else if(tcp.flags() == (TCP::SYN | TCP::ACK))
+        cout << "Port: " << setw(5) << tcp.sport() << " open\n";
     return true;
 }
 
@@ -74,17 +73,18 @@ void send_syns(const NetworkInterface &iface, IPv4Address dest_ip, const vector<
     // Retrieve the addresses.
     NetworkInterface::Info info = iface.addresses();
     PacketSender sender;
-    TCP *tcp = new TCP();
     // Allocate the IP PDU
-    IP ip(dest_ip, info.ip_addr, tcp);
+    IP ip = IP(dest_ip, info.ip_addr) / TCP();
+    // Get the reference to the TCP PDU
+    TCP &tcp = ip.rfind_pdu<TCP>();
     // Set the SYN flag on.
-    tcp->set_flag(TCP::SYN, 1);
-    // Just some arbitrary port. 
-    tcp->sport(1337);
+    tcp.set_flag(TCP::SYN, 1);
+    // Just some random port. 
+    tcp.sport(1337);
     cout << "Sending SYNs..." << endl;
     for(vector<string>::const_iterator it = ips.begin(); it != ips.end(); ++it) {
         // Set the new port and send the packet!
-        tcp->dport(atoi(it->c_str()));
+        tcp.dport(atoi(it->c_str()));
         sender.send(ip);
     }
     // Wait 1 second.
@@ -92,12 +92,12 @@ void send_syns(const NetworkInterface &iface, IPv4Address dest_ip, const vector<
     /* Special packet to indicate that we're done. This will be sniffed
      * by our function, which will in turn return false.  
      */
-    tcp->set_flag(TCP::RST, 1);
+    tcp.set_flag(TCP::RST, 1);
     // Pretend we're the scanned host...
     ip.src_addr(dest_ip);
     // We use an ethernet pdu, otherwise the kernel will drop it.
-    EthernetII eth(iface, info.hw_addr, info.hw_addr, ip.clone());
-    sender.send(eth);
+    EthernetII eth = EthernetII(info.hw_addr, info.hw_addr) / ip;
+    sender.send(eth, iface);
 }
 
 void *thread_proc(void *param) {

examples/traceroute.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -54,7 +54,11 @@ public:
         
         PacketSender sender;
         // Create our handler
-        auto handler = make_sniffer_handler(this, &Traceroute::sniff_callback);
+        auto handler = std::bind(
+            &Traceroute::sniff_callback, 
+            this, 
+            std::placeholders::_1
+        );
         // We're running
         running = true;
         // Start the sniff thread
@@ -74,7 +78,7 @@ private:
 
     void send_packets(PacketSender &sender) {
         // ICMPs are icmp-requests by default
-        IP ip(addr, iface.addresses().ip_addr, new ICMP());
+        IP ip = IP(addr, iface.addresses().ip_addr) / ICMP();
         // We'll find at most 10 hops.
         
         for(auto i = 1; i <= 10; ++i) {
@@ -98,30 +102,20 @@ private:
     }
 
     bool sniff_callback(PDU &pdu) {
-        IP *ip = pdu.find_pdu<IP>();
-        RawPDU *raw = pdu.find_pdu<RawPDU>();
-        if(ip && raw) {
-            ttl_map::const_iterator iter;
-            IP inner_ip;
-            // This will fail if its a corrupted packet
-            try {
-                // Fetch the IP PDU attached to the ICMP response
-                inner_ip = IP(&raw->payload()[0], raw->payload_size());
-            }
-            catch(std::runtime_error &ex) {
-                return running;
-            }
-            // Critical section
-            {
-                std::lock_guard<std::mutex> _(lock);
-                iter = ttls.find(inner_ip.id());
-            } 
+        const IP &ip = pdu.rfind_pdu<IP>();
+        ttl_map::const_iterator iter;
+        // Fetch the IP PDU attached to the ICMP response
+        const IP inner_ip = pdu.rfind_pdu<RawPDU>().to<IP>();
+        // Critical section
+        {
+            std::lock_guard<std::mutex> _(lock);
+            iter = ttls.find(inner_ip.id());
+        } 
 
-            // It's an actual response
-            if(iter != ttls.end()) {
-                // Store it
-                results[inner_ip.id()] = ip->src_addr();
-            }
+        // It's an actual response
+        if(iter != ttls.end()) {
+            // Store it
+            results[inner_ip.id()] = ip.src_addr();
         }
         return running;
     }

examples/wps_detect.cpp

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

include/CMakeLists.txt

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

include/address_range.h

@@ -0,0 +1,331 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_ADDRESS_RANGE
+#define TINS_ADDRESS_RANGE
+
+#include <stdexcept>
+#include <iterator>
+#include "endianness.h"
+#include "internals.h"
+
+namespace Tins {
+/**
+ * \brief AddressRange iterator class.
+ */
+template<typename Address>
+class AddressRangeIterator : public std::iterator<std::forward_iterator_tag, const Address> {
+public:
+    typedef typename std::iterator<std::forward_iterator_tag, const Address>::value_type value_type;
+
+    struct end_iterator {
+
+    };
+
+    /**
+     * Constructs an iterator.
+     *
+     * \param first The address held by this iterator.
+     */
+    AddressRangeIterator(const value_type &addr)
+    : addr(addr), reached_end(false)
+    {
+
+    }
+
+    /**
+     * Constructs an iterator.
+     *
+     * \param first The address held by this iterator.
+     */
+    AddressRangeIterator(const value_type &address, end_iterator)
+    : addr(address)
+    {
+        reached_end = Internals::increment(addr);
+    }
+
+    /**
+     * Retrieves the current address pointed by this iterator.
+     */
+    const value_type& operator*() const {
+        return addr;
+    }
+
+    /**
+     * Retrieves a pointer to the current address pointed by this iterator.
+     */
+    const value_type* operator->() const {
+        return &addr;
+    }
+
+    /**
+     * Compares two iterators for equality.
+     *
+     * \param rhs The iterator with which to compare.
+     */
+    bool operator==(const AddressRangeIterator &rhs) const {
+        return reached_end == rhs.reached_end && addr == rhs.addr;
+    }
+
+    /**
+     * Compares two iterators for inequality.
+     *
+     * \param rhs The iterator with which to compare.
+     */
+    bool operator!=(const AddressRangeIterator &rhs) const {
+        return !(*this == rhs);
+    }
+
+    /**
+     * Increments this iterator.
+     */
+    AddressRangeIterator& operator++() {
+        reached_end = Internals::increment(addr);
+        return *this;
+    }
+
+    /**
+     * Increments this iterator.
+     */
+    AddressRangeIterator operator++(int) {
+        AddressRangeIterator copy(*this);
+        (*this)++;
+        return copy;
+    }
+private:
+    Address addr;
+    bool reached_end;
+};
+
+/**
+ * \brief Represents a range of addresses.
+ *
+ * This class provides a begin()/end() interface which allows
+ * 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 
+ * network and broadcast addresses are discarded:
+ *
+ * \code
+ * auto range = IPv4Address("192.168.5.0") / 24;
+ * for(const auto &addr : range) {
+ *     // process 192.168.5.1-254, .0 and .255 are discarded
+ *     process(addr);
+ * }
+ *
+ * // 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) 
+ * will allow the iteration over the entire range:
+ *
+ * \code
+ * AddressRange<IPv4Address> range("192.168.5.0", "192.168.5.255");
+ * for(const auto &addr : range) {
+ *     // 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 {
+public:
+    /**
+     * The type of addresses stored in the range.
+     */
+    typedef Address address_type;
+
+    /**
+     * The iterator type.
+     */
+    typedef AddressRangeIterator<address_type> const_iterator;
+
+    /**
+     * \brief The iterator type.
+     *
+     * This is the same type as const_iterator, since the
+     * addresses stored in this range are read only.
+     */
+    typedef const_iterator iterator;
+
+    /**
+     * \brief Constructs an address range from two addresses.
+     *
+     * 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. 
+     *
+     * 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
+     * should be accessed when using iterators.
+     */
+    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");
+    }
+
+    /**
+     * \brief Creates an address range from a base address
+     * and a network mask.
+     *
+     * \param first The base address.
+     * \param mask The network mask to be used.
+     */
+    static AddressRange from_mask(const address_type &first, const address_type &mask) {
+        return AddressRange<address_type>(
+            first, 
+            Internals::last_address_from_mask(first, mask), 
+            true
+        );
+    }
+
+    /**
+     * \brief Indicates whether an address is included in this range.
+     * \param addr The address to test.
+     * \return a bool indicating whether the address is in the range.
+     */
+    bool contains(const address_type &addr) const {
+        return (first < addr && addr < last) || addr == first || addr == last;
+    }
+
+    /**
+     * \brief Returns an interator to the beginning of this range.
+     * \brief const_iterator pointing to the beginning of this range.
+     */
+    const_iterator begin() const {
+        address_type addr = first;
+        if(only_hosts)
+            Internals::increment(addr);
+        return const_iterator(addr);
+    }
+
+    /**
+     * \brief Returns an interator to the end of this range.
+     * \brief const_iterator pointing to the end of this range.
+     */
+    const_iterator end() const {
+        address_type addr = last;
+        if(only_hosts)
+            Internals::decrement(addr);
+        return const_iterator(addr, typename const_iterator::end_iterator());
+    }
+
+    /**
+     * \brief Indicates whether this range is iterable.
+     *
+     * 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. 
+     * 
+     * \return bool indicating whether this range is iterable.
+     */
+    bool is_iterable() const {
+        // Since first < last, it's iterable
+        if(!only_hosts)
+            return true;
+        // We need that distance(first, last) >= 4
+        address_type addr(first);
+        for(int i = 0; i < 3; ++i) {
+            // If there's overflow before the last iteration, we're done
+            if(Internals::increment(addr) && i != 2)
+                return false;
+        }
+        // If addr <= last, it's OK.
+        return addr < last || addr == last;
+    }
+private:
+    address_type first, last;
+    bool only_hosts;
+};
+
+/**
+ * An IPv4 address range.
+ */
+typedef AddressRange<IPv4Address> IPv4Range;
+
+/**
+ * An IPv6 address range.
+ */
+typedef AddressRange<IPv6Address> IPv6Range;
+
+/**
+ * \brief Constructs an AddressRange from a base address and a mask.
+ * \param addr The range's first address.
+ * \param mask The bit-length of the prefix.
+ */
+template<size_t n>
+AddressRange<HWAddress<n> > operator/(const HWAddress<n> &addr, int mask) {
+    if(mask > 48)
+        throw std::logic_error("Prefix length cannot exceed 48");
+    HWAddress<n> last_addr;
+    typename HWAddress<n>::iterator it = last_addr.begin();
+    while(mask > 8) {
+        *it = 0xff;
+        ++it;
+        mask -= 8;
+    }
+    *it = 0xff << (8 - mask);
+    return AddressRange<HWAddress<6> >::from_mask(addr, last_addr);
+}
+
+/**
+ * \brief Constructs an IPv6Range from a base IPv6Address and a mask.
+ * \param addr The range's first address.
+ * \param mask The bit-length of the prefix.
+ */
+IPv6Range operator/(const IPv6Address &addr, int mask);
+
+/**
+ * \brief Constructs an IPv4Range from a base IPv4Address and a mask.
+ * \param addr The range's first address.
+ * \param mask The bit-length of the prefix.
+ */
+IPv4Range operator/(const IPv4Address &addr, int mask);
+} // namespace Tins
+
+#endif // TINS_ADDRESS_RANGE

include/arp.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,6 +31,7 @@
 #ifndef TINS_ARP_H
 #define TINS_ARP_H
 
+#include "macros.h"
 #include "pdu.h"
 #include "endianness.h"
 #include "hw_address.h"
@@ -70,10 +71,18 @@ namespace Tins {
         };
 
         /**
-         * \brief Default constructor for ARP PDU objects.
-         *
+         * \brief Constructs an ARP object using the provided addresses.
+         * 
          * ARP requests and replies can be constructed easily using
-         * ARP::make_arp_request/reply static functions.
+         * ARP::make_arp_request/reply static member functions.
+         * 
+         * \sa ARP::make_arp_request
+         * \sa ARP::make_arp_reply
+         * 
+         * \param target_ip The target IP address.
+         * \param sender_ip The sender IP address.
+         * \param target_hw The target hardware address.
+         * \param sender_hw The sender hardware address.
          */
         ARP(ipaddress_type target_ip = ipaddress_type(), 
             ipaddress_type sender_ip = ipaddress_type(), 
@@ -81,8 +90,14 @@ namespace Tins {
             const hwaddress_type &sender_hw = hwaddress_type());
 
         /**
-         * \brief Constructor which creates an ARP object from a buffer and adds all identifiable
-         * PDUs found in the buffer as children of this one.
+         * \brief Constructs an ARP object from a buffer.
+         * 
+         * If there is not enough size for an ARP header in the buffer,
+         * a malformed_packet exception is thrown. 
+         * 
+         * If the buffer is bigger than the size of the ARP header, 
+         * then the extra data is stored in a RawPDU.
+         * 
          * \param buffer The buffer from which this PDU will be constructed.
          * \param total_sz The total size of the buffer.
          */
@@ -118,41 +133,42 @@ namespace Tins {
         ipaddress_type target_ip_addr() const { return ipaddress_type(_arp.ar_tip); }
 
         /**
-         * \brief Getter for the hardware address format.
+         * \brief Getter for the hardware address format field.
          *
          * \return The hardware address format.
          */
         uint16_t hw_addr_format() const { return Endian::be_to_host(_arp.ar_hrd); }
 
         /**
-         * \brief Getter for the protocol address format.
+         * \brief Getter for the protocol address format field.
          *
          * \return The protocol address format.
          */
         uint16_t prot_addr_format() const { return Endian::be_to_host(_arp.ar_pro); }
 
         /**
-         * \brief Getter for the hardware address length.
+         * \brief Getter for the hardware address length field.
          *
          * \return The hardware address length.
          */
         uint8_t hw_addr_length() const { return _arp.ar_hln; }
 
         /**
-         * \brief Getter for the protocol address length.
+         * \brief Getter for the protocol address length field.
          *
          * \return The protocol address length.
          */
         uint8_t prot_addr_length() const { return _arp.ar_pln; }
 
         /**
-         * \brief Getter for the ARP opcode.
+         * \brief Getter for the ARP opcode field.
          *
          * \return The ARP opcode.
          */
         uint16_t opcode() const { return Endian::be_to_host(_arp.ar_op); }
 
-        /** \brief Getter for the header size.
+        /** 
+         * \brief Getter for the header size.
          * \return Returns the ARP header size.
          * \sa PDU::header_size
          */
@@ -188,35 +204,35 @@ namespace Tins {
         void target_ip_addr(ipaddress_type new_tgt_ip_addr);
 
         /**
-         * \brief Setter for the hardware address format.
+         * \brief Setter for the hardware address format field.
          *
          * \param new_hw_addr_fmt The new hardware address format.
          */
         void hw_addr_format(uint16_t new_hw_addr_fmt);
 
         /**
-         * \brief Setter for the protocol address format.
+         * \brief Setter for the protocol address format field.
          *
          * \param new_prot_addr_fmt The new protocol address format.
          */
         void prot_addr_format(uint16_t new_prot_addr_fmt);
 
         /**
-         * \brief Setter for the hardware address length.
+         * \brief Setter for the hardware address length field.
          *
          * \param new_hw_addr_len The new hardware address length.
          */
         void hw_addr_length(uint8_t new_hw_addr_len);
 
         /**
-         * \brief Setter for the protocol address length.
+         * \brief Setter for the protocol address length field.
          *
          * \param new_prot_addr_len The new protocol address length.
          */
         void prot_addr_length(uint8_t new_prot_addr_len);
 
         /**
-         * \brief Setter for the ARP opcode.
+         * \brief Setter for the ARP opcode field.
          *
          * \param new_opcode Flag enum value of the ARP opcode to set.
          */
@@ -226,57 +242,46 @@ namespace Tins {
          * \brief Getter for the PDU's type.
          * \sa PDU::pdu_type
          */
-        PDUType pdu_type() const { return PDU::ARP; }
+        PDUType pdu_type() const { return pdu_flag; }
 
         /**
-         * \brief Creates an ARP Request within a Layer 2 PDU using uint32_t for target and sender.
+         * \brief Creates an ARP Request within an EthernetII PDU.
          *
-         * Creates an ARP Request PDU and embeds it within a Layer 2 PDU ready to be
-         * sent. The target and sender's protocol address are given using uint32_t.
+         * Creates an ARP Request PDU and embeds it inside an EthernetII
+         * PDU.
          *
-         * \param iface string with the interface from where to send the ARP.
-         * \param target IPv4Address with the target's IP.
-         * \param sender IPv4Address with the sender's IP.
-         * \param hw_snd uint8_t array of 6 bytes containing the sender's hardware address.
-         * \return Returns a EthernetII containing the ARP Request.
+         * \param target The target's IP address.
+         * \param sender The sender's IP address.
+         * \param hw_snd The sender's hardware address.
+         * \return EthernetII object containing the ARP Request.
          */
-        static EthernetII make_arp_request(const NetworkInterface& iface, ipaddress_type target, 
+        static EthernetII make_arp_request(ipaddress_type target, 
           ipaddress_type sender, const hwaddress_type &hw_snd = hwaddress_type());
 
         /**
-         * \brief Creates an ARP Reply within a Layer 2 PDU using uint32_t for target and sender.
+         * \brief Creates an ARP Reply within an EthernetII PDU.
          *
-         * Creates an ARP Reply PDU and embeds it within a Layer 2 PDU ready to be
-         * sent. The target and sender's protocol address are given using uint32_t.
+         * Creates an ARP Reply PDU and embeds it inside an EthernetII 
+         * PDU.
          *
-         * \param iface string with the interface from where to send the ARP.
-         * \param target IPv4Address with the target's IP.
-         * \param sender IPv4Address with the sender's IP.
-         * \param hw_tgt uint8_t array of 6 bytes containing the target's hardware address.
-         * \param hw_snd uint8_t array of 6 bytes containing the sender's hardware address.
-         * \return Returns an EthetnetII containing the ARP Replay.
+         * \param target The target's IP address.
+         * \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.
          */
-        static EthernetII make_arp_reply(const NetworkInterface& iface, ipaddress_type target, 
+        static EthernetII make_arp_reply(ipaddress_type target, 
           ipaddress_type sender, const hwaddress_type &hw_tgt = hwaddress_type(), 
           const hwaddress_type &hw_snd = hwaddress_type());
 
-        /** \brief Check wether ptr points to a valid response for this PDU.
+        /** 
+         * \brief Check wether ptr points to a valid response for this PDU.
          *
          * \sa PDU::matches_response
          * \param ptr The pointer to the buffer.
          * \param total_sz The size of the buffer.
          */
-        bool matches_response(uint8_t *ptr, uint32_t total_sz);
-
-        /** \brief Clones this pdu, filling the corresponding header with data
-         * extracted from a buffer.
-         *
-         * \param ptr The pointer to the from from which the data will be extracted.
-         * \param total_sz The size of the buffer.
-         * \return The cloned PDU.
-         * \sa PDU::clone_packet
-         */
-        PDU *clone_packet(const uint8_t *ptr, uint32_t total_sz);
+        bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
         
         /**
          * \sa PDU::clone
@@ -285,6 +290,7 @@ namespace Tins {
             return new ARP(*this);
         }
     private:
+        TINS_BEGIN_PACK
         struct arphdr {
             uint16_t ar_hrd;	/* format of hardware address	*/
             uint16_t ar_pro;	/* format of protocol address	*/
@@ -300,11 +306,11 @@ namespace Tins {
             uint8_t ar_tha[hwaddress_type::address_size];	
             /* target IP address		*/
             uint32_t ar_tip;
-        } __attribute__((__packed__));
+        } TINS_END_PACK;
 
         void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
 
         arphdr _arp;
     };
-};
+}
 #endif //TINS_ARP_H

include/bootp.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -34,6 +34,7 @@
 #include <algorithm>
 #include <vector>
 #include "pdu.h"
+#include "macros.h"
 #include "endianness.h"
 #include "ip_address.h"
 #include "hw_address.h"
@@ -83,8 +84,11 @@ namespace Tins {
         BootP();
 
         /**
-         * \brief Constructor which creates a BootP object from a buffer and adds all identifiable
-         * PDUs found in the buffer as children of this one.
+         * \brief Constructs a BootP object from a buffer .
+         * 
+         * If there's not enough size for a BootP header, then a 
+         * malformed_packet exception is thrown.
+         * 
          * \param buffer The buffer from which this PDU will be constructed.
          * \param total_sz The total size of the buffer.
          * \param vend_field_size The vend field size to allocate.
@@ -271,7 +275,8 @@ namespace Tins {
                 _bootp.chaddr
             );
             // Fill what's left with zeros
-            std::fill(end, _bootp.chaddr + chaddr_type::address_size, 0);
+            if(end < _bootp.chaddr + chaddr_type::address_size)
+                std::fill(end, _bootp.chaddr + chaddr_type::address_size, 0);
         }
 
         /** 
@@ -292,11 +297,22 @@ namespace Tins {
          */
         void vend(const vend_type &new_vend);
 
+        /**
+         * \brief Check wether ptr points to a valid response for this PDU.
+         *
+         * This returns true if the xid field is equal.
+         * 
+         * \sa PDU::matches_response
+         * \param ptr The pointer to the buffer.
+         * \param total_sz The size of the buffer.
+         */
+        bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
+
         /**
          * \brief Getter for the PDU's type.
          * \sa PDU::pdu_type
          */
-        PDUType pdu_type() const { return PDU::BOOTP; }
+        PDUType pdu_type() const { return pdu_flag; }
 
         /**
          * \sa PDU::clone
@@ -320,6 +336,7 @@ namespace Tins {
         /**
          * Struct that represents the Bootp datagram.
          */
+        TINS_BEGIN_PACK
         struct bootphdr {
             uint8_t opcode;
             uint8_t htype;
@@ -335,11 +352,11 @@ namespace Tins {
             uint8_t chaddr[16];
             uint8_t sname[64];
             uint8_t file[128];
-        } __attribute__((__packed__));
+        } TINS_END_PACK;
 
         bootphdr _bootp;
         vend_type _vend;
     };
-};
+}
 
 #endif // TINS_BOOTP_H

include/config.h.in

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

include/constants.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -73,7 +73,8 @@ namespace Tins {
         
         struct Ethernet {
             enum e {
-                PUP = 0x0200,     /* Xerox PUP */
+                UNKNOWN = 0,
+                //~ PUP = 0x0200,     /* Xerox PUP */
                 SPRITE = 0x0500,  /* Sprite */
                 IP = 0x0800,      /* IP */
                 ARP = 0x0806,     /* Address resolution */
@@ -83,6 +84,7 @@ namespace Tins {
                 VLAN = 0x8100,    /* IEEE 802.1Q VLAN tagging */
                 IPX = 0x8137,	  /* IPX */
                 IPV6 = 0x86dd,    /* IP protocol version 6 */
+                PPPOED = 0x8863, /* PPPoE Discovery */
                 EAPOL = 0x888e,   /* EAPOL */
                 LOOPBACK = 0x9000 /* used to test interfaces */
             };
@@ -147,11 +149,11 @@ namespace Tins {
                 IEEE802154 = 804, /* IEEE 802.15.4 header.  */
                 IEEE802154_PHY = 805, /* IEEE 802.15.4 PHY header.  */
                 VOID_TYPE = 0xFFFF,	     /* Void type, nothing is known.  */
-                NONE = 0xFFFE,	      /* Zero header length.  */  
+                NONE = 0xFFFE	      /* Zero header length.  */  
             };
         };
-    };
-};
+    }
+}
 
 
 #endif // TINS_CONSTANTS_H

include/crypto.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,22 +27,72 @@
  *
  */
 
-#ifndef TINS_CRYPTO_H
+#include "config.h"
+
+#if !defined(TINS_CRYPTO_H) && defined(HAVE_DOT11)
 #define TINS_CRYPTO_H
 
 #include <map>
 #include <string>
 #include <algorithm>
 #include <vector>
-#include "dot11.h"
 #include "utils.h"
 #include "snap.h"
 #include "rawpdu.h"
+#include "handshake_capturer.h"
 
 namespace Tins {
 class PDU;
+class Dot11;
+class Dot11Data;
 
 namespace Crypto {
+    /**
+     * \cond
+     */
+    struct RC4Key;
+    #ifdef HAVE_WPA2_DECRYPTION
+    namespace WPA2 {
+        class invalid_handshake : public std::exception {
+        public:
+            const char *what() const throw() {
+                return "invalid handshake";
+            }
+        };
+        class SessionKeys {
+        public:
+            typedef Internals::byte_array<80> ptk_type;
+            typedef Internals::byte_array<32> pmk_type;
+            
+            SessionKeys();
+            SessionKeys(const RSNHandshake &hs, const pmk_type &pmk);
+            SNAP *decrypt_unicast(const Dot11Data &dot11, RawPDU &raw) const;
+        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;
+        };
+            
+        class SupplicantData {
+        public:
+            typedef HWAddress<6> address_type;
+            typedef SessionKeys::pmk_type pmk_type;
+            
+            SupplicantData(const std::string &psk, const std::string &ssid);
+            
+            const pmk_type &pmk() const;
+        private:
+            pmk_type pmk_;
+        };
+    }
+    #endif // HAVE_WPA2_DECRYPTION
+    /**
+     * \endcond
+     */
+
     /**
      * \brief RC4 Key abstraction.
      */
@@ -65,11 +115,11 @@ namespace Crypto {
     };
 
     /**
-     * 
+     * \brief Decrypts WEP-encrypted traffic.
      */
     class WEPDecrypter {
     public:
-        typedef Dot11::address_type address_type;
+        typedef HWAddress<6> address_type;
     
         /**
          * \brief Constructs a WEPDecrypter object.
@@ -93,19 +143,18 @@ namespace Crypto {
         void remove_password(const address_type &addr);
         
         /**
-         * \brief Decrypts the provided PDU and forwards the decrypted
-         * PDU to the functor held by this object.
+         * \brief Decrypts the provided PDU.
          * 
          * A Dot11Data PDU is looked up inside the provided PDU chain.
          * If no such PDU exists or there is no password associated
          * with the Dot11 packet's BSSID, then the PDU is left intact. 
          * 
          * Otherwise, the packet is decrypted using the given password. 
-         * If the CRC found after decrypting it is invalid,
-         * then false is returned.
+         * If the CRC found after decrypting is invalid, false is 
+         * returned.
          * 
-         * \return false if decryption failed due to invalid CRC, true
-         * otherwise.
+         * \return false if no decryption was performed or decryption 
+         * failed, true otherwise.
          */
         bool decrypt(PDU &pdu);
     private:
@@ -117,6 +166,96 @@ namespace Crypto {
         std::vector<uint8_t> key_buffer;
     };
 
+    #ifdef HAVE_WPA2_DECRYPTION
+    /**
+     * \brief Decrypts WPA2-encrypted traffic.
+     *
+     * This class takes valid PSK and SSID tuples, captures client handshakes,
+     * and decrypts their traffic afterwards.
+     */
+    class WPA2Decrypter {
+    public:
+        /*
+         * \brief The type used to store Dot11 addresses.
+         */
+        typedef HWAddress<6> address_type;
+        
+        /**
+         * \brief Adds an access points's information.
+         *
+         * This associates an SSID with a PSK, and allows the decryption of
+         * any BSSIDs that broadcast the same SSID. 
+         * 
+         * The decrypter will inspect beacon frames, looking for SSID tags 
+         * that contain the given SSID.
+         *
+         * Note that using this overload, the decryption of data frames and
+         * handshake capturing will be disabled until any access point 
+         * broadcasts the provided SSID(this shouldn't take long at all). 
+         * If this is not the desired behaviour, then you should check out
+         * the ovther add_ap_data overload.
+         * 
+         * \param psk The PSK associated with the SSID.
+         * \param ssid The network's SSID.
+         */
+        void add_ap_data(const std::string &psk, const std::string &ssid);
+
+        /**
+         * \brief Adds a access points's information, including its BSSID.
+         *
+         * This overload can be used if the BSSID associated with this SSID is 
+         * known beforehand. The addr parameter indicates which specific BSSID 
+         * is associated to the SSID. 
+         * 
+         * Note that if any other access point broadcasts the provided SSID, 
+         * it will be taken into account as well.
+         * 
+         * \param psk The PSK associated with this SSID.
+         * \param ssid The network's SSID.
+         * \param addr The access point's BSSID.
+         */
+        void add_ap_data(const std::string &psk, const std::string &ssid, const address_type &addr);
+        
+        /**
+         * \brief Decrypts the provided PDU.
+         * 
+         * A Dot11Data PDU is looked up inside the provided PDU chain.
+         * If no such PDU exists or no PSK was associated with the SSID
+         * broadcasted by the Dot11 packet's BSSID, or no EAPOL handshake 
+         * was captured for the client involved in the communication, 
+         * then the PDU is left intact. 
+         * 
+         * Otherwise, the packet is decrypted using the generated PTK. 
+         * If the resulting MIC is invalid, then the packet is left intact.
+         * 
+         * \return false if no decryption was performed, or the decryption 
+         * failed, true otherwise.
+         */
+        bool decrypt(PDU &pdu);
+    private:
+        typedef std::map<std::string, WPA2::SupplicantData> pmks_map;
+        typedef std::map<address_type, WPA2::SupplicantData> bssids_map;
+        typedef std::pair<address_type, address_type> addr_pair;
+        typedef std::map<addr_pair, WPA2::SessionKeys> keys_map;
+        
+        void try_add_keys(const Dot11Data &dot11, const RSNHandshake &hs);
+        addr_pair make_addr_pair(const address_type &addr1, const address_type &addr2) {
+            return (addr1 < addr2) ? 
+                std::make_pair(addr1, addr2) :
+                std::make_pair(addr2, addr1);
+        }
+        addr_pair extract_addr_pair(const Dot11Data &dot11);
+        addr_pair extract_addr_pair_dst(const Dot11Data &dot11);
+        bssids_map::const_iterator find_ap(const Dot11Data &dot11);
+        void add_access_point(const std::string &ssid, const address_type &addr);
+
+        RSNHandshakeCapturer capturer;
+        pmks_map pmks;
+        bssids_map aps;
+        keys_map keys;
+    };
+    #endif // HAVE_WPA2_DECRYPTION
+
     /**
      * \brief Pluggable decrypter object which can be used to decrypt
      * data on sniffing sessions.
@@ -183,7 +322,7 @@ namespace Crypto {
     void rc4(ForwardIterator start, ForwardIterator end, RC4Key &key, OutputIterator output);
     
     /**
-     * \brief Wrapper function to create DecrypterProxyes using a 
+     * \brief Wrapper function to create a DecrypterProxy using a 
      * WEPDecrypter as the Decrypter template parameter.
      * 
      * \param functor The functor to be forwarded to the DecrypterProxy
@@ -191,6 +330,20 @@ namespace Crypto {
      */
     template<typename Functor>
     DecrypterProxy<Functor, WEPDecrypter> make_wep_decrypter_proxy(const Functor &functor);
+
+    #ifdef HAVE_WPA2_DECRYPTION
+    /**
+     * \brief Wrapper function to create a DecrypterProxy using a 
+     * WPA2Decrypter as the Decrypter template parameter.
+     * 
+     * \param functor The functor to be forwarded to the DecrypterProxy
+     * constructor.
+     */
+    template<typename Functor>
+    DecrypterProxy<Functor, WPA2Decrypter> make_wpa2_decrypter_proxy(const Functor &functor) {
+        return DecrypterProxy<Functor, WPA2Decrypter>(functor);
+    }
+    #endif // HAVE_WPA2_DECRYPTION
     
     // Implementation section
     
@@ -229,7 +382,7 @@ namespace Crypto {
     {
         return DecrypterProxy<Functor, WEPDecrypter>(functor);
     }
-    
+
     // RC4 stuff
     
     template<typename ForwardIterator>

include/cxxstd.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_CXXSTD_H
+#define TINS_CXXSTD_H
+
+#include <memory>
+
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+    #define TINS_CXXSTD_GCC_FIX 1
+#else
+    #define TINS_CXXSTD_GCC_FIX 0
+#endif // __GXX_EXPERIMENTAL_CXX0X__
+
+#ifndef TINS_IS_CXX11
+#define TINS_IS_CXX11 (__cplusplus > 199711L || TINS_CXXSTD_GCC_FIX == 1 || _MSC_VER >= 1800)
+#endif  // TINS_IS_CXX11
+
+namespace Tins{
+namespace Internals {
+template<typename T>
+struct smart_ptr {
+#if TINS_IS_CXX11
+    typedef std::unique_ptr<T> type;
+#else
+    typedef std::auto_ptr<T> type;
+#endif
+};
+}
+}
+
+#endif // TINS_CXXSTD_H

include/dhcp.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -32,15 +32,19 @@
 
 
 #include <list>
+#include <vector>
 #include <string>
 #include "bootp.h"
 #include "pdu_option.h"
+#include "cxxstd.h"
 
 namespace Tins {
     /** 
      * \brief Class that represents the DHCP PDU.
-     * 
-     * The end option is added automatically at the end of the option list.
+     *
+     * When adding options, the "End" option is not added automatically. 
+     *
+     * \sa DHCP::end
      */
     class DHCP : public BootP {
     public:
@@ -66,7 +70,7 @@ namespace Tins {
         /** 
          * \brief DHCP options enum.
          */
-        enum Options {
+        enum OptionTypes {
             PAD,
             SUBNET_MASK,
             TIME_OFFSET,
@@ -142,12 +146,12 @@ namespace Tins {
         /**
          * The DHCP option type.
          */
-        typedef PDUOption<uint8_t> dhcp_option;
+        typedef PDUOption<uint8_t, DHCP> option;
         
         /**
          * The type used to store the DHCP options.
          */
-        typedef std::list<dhcp_option> options_type;
+        typedef std::list<option> options_type;
         
         /** 
          * \brief Creates an instance of DHCP.
@@ -158,35 +162,57 @@ namespace Tins {
         DHCP();
         
         /**
-         * \brief Constructor which creates a DHCP object from a buffer and adds all identifiable
-         * PDUs found in the buffer as children of this one.
+         * \brief Constructs a DHCP object from a buffer.
+         * 
+         * If there is not enough size for a BootP header, or any of
+         * the TLV options contains an invalid size field, then a
+         * malformed_packet exception is thrown.
+         * 
          * \param buffer The buffer from which this PDU will be constructed.
          * \param total_sz The total size of the buffer.
-         * Subclasses might use 0 to provide their own interpretation of this field.
          */
         DHCP(const uint8_t *buffer, uint32_t total_sz);
         
         /** 
          * \brief Adds a new option to this DHCP PDU.
-         * \param option The option to be added.
+         * \param opt The option to be added.
          */
-        void add_option(const dhcp_option &option);
+        void add_option(const option &opt);
+        
+        #if TINS_IS_CXX11
+            /** 
+             * \brief Adds a new option to this DHCP PDU.
+             * 
+             * The option is move-constructed.
+             * 
+             * \param opt The option to be added.
+             */
+            void add_option(option &&opt) {
+                internal_add_option(opt);
+                _options.push_back(std::move(opt));
+            }
+        #endif 
     
         /**
          * \brief Searchs for an option that matchs the given flag.
          * \param opt_flag The flag to be searched.
          * \return A pointer to the option, or 0 if it was not found.
          */
-        const dhcp_option *search_option(Options opt) const;
+        const option *search_option(OptionTypes opt) const;
         
         /** 
-         * \brief Adds a type option the the option list.
+         * \brief Adds a type option to the option list.
+         * 
+         * The new option is appended at the end of the list.
+         * 
          * \param type The type of this DHCP PDU.
          */
         void type(Flags type);
         
         /** 
-         * \brief Adds an end option the the option list.
+         * \brief Adds an end option to the option list.
+         * 
+         * The new option is appended at the end of the list.
          * 
          * The END option is not added automatically. You should explicitly
          * add it at the end of the DHCP options for the PDU to be
@@ -196,70 +222,109 @@ namespace Tins {
         
         /** 
          * \brief Adds a server identifier option.
-         * \param ip The ip of the server.
+         * 
+         * The new option is appended at the end of the list.
+         * 
+         * \param ip The server's IP address.
          */
         void server_identifier(ipaddress_type ip);
         
         /** 
          * \brief Adds an IP address lease time option.
+         * 
+         * The new option is appended at the end of the list.
+         * 
          * \param time The lease time.
          */
         void lease_time(uint32_t time);
         
         /** 
          * \brief Adds a lease renewal time option.
+         * 
+         * The new option is appended at the end of the list.
+         * 
          * \param time The lease renew time.
          */
         void renewal_time(uint32_t time);
         
         /** 
          * \brief Adds a rebind time option.
+         * 
+         * The new option is appended at the end of the list.
+         * 
          * \param time The lease rebind time.
          */
         void rebind_time(uint32_t time);
         
         /**
          * \brief Adds a subnet mask option.
+         * 
+         * The new option is appended at the end of the list.
+         * 
          * \param mask The subnet mask.
          */
         void subnet_mask(ipaddress_type mask);
         
         /** 
          * \brief Adds a routers option.
+         * 
+         * The new option is appended at the end of the list.
+         * 
          * \param routers A list of ip addresses.
          */
-        void routers(const std::list<ipaddress_type> &routers);
+        void routers(const std::vector<ipaddress_type> &routers);
         
         /** 
          * \brief Adds a domain name servers option.
+         * 
+         * The new option is appended at the end of the list.
+         * 
          * \param dns A list of ip addresses.
          */
-        void domain_name_servers(const std::list<ipaddress_type> &dns);
+        void domain_name_servers(const std::vector<ipaddress_type> &dns);
         
         /** 
          * \brief Adds a broadcast address option.
+         * 
+         * The new option is appended at the end of the list.
+         * 
          * \param addr The broadcast address.
          */
         void broadcast(ipaddress_type addr);
         
         /** 
          * \brief Adds a requested address option.
+         * 
+         * The new option is appended at the end of the list.
+         * 
          * \param addr The requested address.
          */
         void requested_ip(ipaddress_type addr);
         
         /** 
          * \brief Adds a domain name option.
+         * 
+         * The new option is appended at the end of the list.
+         * 
          * \param name The domain name.
          */
         void domain_name(const std::string &name);
+
+        /** 
+         * \brief Adds a hostname option.
+         * 
+         * The new option is appended at the end of the list.
+         * 
+         * \param name The hostname.
+         */
+        void hostname(const std::string &name);
         
         // Option getters
         
         /**
          * \brief Searchs for a type option.
          * 
-         * If the option is not found, a option_not_found exception
+         * If the option is not found, an option_not_found exception
          * is thrown.
          * 
          * \return uint8_t containing the type option.
@@ -269,7 +334,7 @@ namespace Tins {
         /**
          * \brief Searchs for a server identifier option.
          * 
-         * If the option is not found, a option_not_found exception
+         * If the option is not found, an option_not_found exception
          * is thrown.
          * 
          * \return ipaddress_type Containing the server identifier.
@@ -279,7 +344,7 @@ namespace Tins {
         /**
          * \brief Searchs for a lease time option.
          * 
-         * If the option is not found, a option_not_found exception
+         * If the option is not found, an option_not_found exception
          * is thrown.
          * 
          * \return uint32_t Containing the lease time.
@@ -289,7 +354,7 @@ namespace Tins {
         /**
          * \brief Searchs for a lease renewal time option.
          * 
-         * If the option is not found, a option_not_found exception
+         * If the option is not found, an option_not_found exception
          * is thrown.
          * 
          * \return uint32_t Containing the renewal time.
@@ -299,7 +364,7 @@ namespace Tins {
         /**
          * \brief Searchs for a rebind time option.
          * 
-         * If the option is not found, a option_not_found exception
+         * If the option is not found, an option_not_found exception
          * is thrown.
          * 
          * \return uint32_t Containing the rebind time.
@@ -309,7 +374,7 @@ namespace Tins {
         /**
          * \brief Searchs for a subnet mask option.
          * 
-         * If the option is not found, a option_not_found exception
+         * If the option is not found, an option_not_found exception
          * is thrown.
          * 
          * \return ipaddress_type Containing the subnet mask.
@@ -319,29 +384,29 @@ namespace Tins {
         /**
          * \brief Searchs for a routers option.
          * 
-         * If the option is not found, a option_not_found exception
+         * If the option is not found, an option_not_found exception
          * is thrown.
          * 
-         * \return std::list<ipaddress_type> Containing the routers 
+         * \return std::vector<ipaddress_type> Containing the routers 
          * option data.
          */
-        std::list<ipaddress_type> routers() const;
+        std::vector<ipaddress_type> routers() const;
         
         /**
          * \brief Searchs for a dns option.
          * 
-         * If the option is not found, a option_not_found exception
+         * If the option is not found, an option_not_found exception
          * is thrown.
          * 
          * \return std::list<ipaddress_type> Contanining the DNS servers
          * provided.
          */
-        std::list<ipaddress_type> domain_name_servers() const; 
+        std::vector<ipaddress_type> domain_name_servers() const; 
         
         /**
          * \brief Searchs for a broadcast option.
          * 
-         * If the option is not found, a option_not_found exception
+         * If the option is not found, an option_not_found exception
          * is thrown.
          * 
          * \return ipaddress_type Containing the broadcast address.
@@ -351,7 +416,7 @@ namespace Tins {
         /**
          * \brief Searchs for a requested option.
          * 
-         * If the option is not found, a option_not_found exception
+         * If the option is not found, an option_not_found exception
          * is thrown.
          * 
          * \return ipaddress_type Containing the requested IP address.
@@ -361,14 +426,25 @@ namespace Tins {
         /**
          * \brief Searchs for a domain name option.
          * 
-         * If the option is not found, a option_not_found exception
+         * If the option is not found, an option_not_found exception
          * is thrown.
          * 
          * \return std::string Containing the domain name.
          */
         std::string domain_name() const;
+
+        /**
+         * \brief Searchs for a hostname option.
+         * 
+         * If the option is not found, an option_not_found exception
+         * is thrown.
+         * 
+         * \return std::string Containing the hostname.
+         */
+        std::string hostname() const;
         
-        /** \brief Getter for the options list.
+        /** 
+         * \brief Getter for the options list.
          * \return The option list.
          */
         const options_type options() const { return _options; }
@@ -377,7 +453,7 @@ namespace Tins {
          * \brief Getter for the PDU's type.
          * \sa PDU::pdu_type
          */
-        PDUType pdu_type() const { return PDU::DHCP; }
+        PDUType pdu_type() const { return pdu_flag; }
         
         /** 
          * \brief Getter for the header size.
@@ -394,30 +470,23 @@ namespace Tins {
         }
     private:
         static const uint32_t MAX_DHCP_SIZE;
-        
-        template<typename T>
-        struct type2type {};
       
         void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
-        
+
         template<class T> 
-        T generic_search(Options opt, type2type<T>) const {
-            const dhcp_option *option = search_option(opt);
-            if(option && option->data_size() == sizeof(T))
-                return *(const T*)option->data_ptr();
-            else
+        T search_and_convert(OptionTypes opt) const {
+            const option *option = search_option(opt);
+            if(!option)
                 throw option_not_found();
+            return option->to<T>();
         }
         
-        std::list<ipaddress_type> generic_search(Options opt, type2type<std::list<ipaddress_type> >) const;
-        std::string generic_search(Options opt, type2type<std::string>) const;
-        ipaddress_type generic_search(Options opt, type2type<ipaddress_type>) const;
-        
-        serialization_type serialize_list(const std::list<ipaddress_type> &ip_list);
+        void internal_add_option(const option &opt);
+        serialization_type serialize_list(const std::vector<ipaddress_type> &ip_list);
         
         options_type _options;
         uint32_t _size;
     };
-};
+}
 
 #endif // TINS_DHCP_H

include/dhcpv6.h

@@ -0,0 +1,928 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_DHCPV6_H
+#define TINS_DHCPV6_H
+
+#include <cstring>
+#include <list>
+#include "pdu.h"
+#include "endianness.h"
+#include "small_uint.h"
+#include "ipv6_address.h"
+#include "pdu_option.h"
+
+namespace Tins {    
+/**
+ * Represents a DHCPv6 PDU.
+ */
+class DHCPv6 : public PDU {
+public:
+    /**
+     * Represents a DHCPv6 option. 
+     */
+    typedef PDUOption<uint16_t, DHCPv6> option;
+
+    /**
+     * The message types.
+     */
+    enum MessageType {
+        SOLICIT = 1,
+        ADVERTISE,
+        REQUEST,
+        CONFIRM,
+        RENEW,
+        REBIND,
+        REPLY,
+        RELEASE,
+        DECLINE,
+        RECONFIGURE,
+        INFO_REQUEST,
+        RELAY_FORWARD,
+        RELAY_REPLY,
+        LEASE_QUERY,
+        LEASE_QUERY_REPLY,
+        LEASE_QUERY_DONE,
+        LEASE_QUERY_DATA
+    };
+    
+    /**
+     * The DHCPv6 options.
+     */
+    enum OptionTypes {
+        CLIENTID = 1, 
+        SERVERID, 
+        IA_NA, 
+        IA_TA, 
+        IA_ADDR, 
+        OPTION_REQUEST, 
+        PREFERENCE, 
+        ELAPSED_TIME, 
+        RELAY_MSG, 
+        AUTH = 11, 
+        UNICAST, 
+        STATUS_CODE, 
+        RAPID_COMMIT, 
+        USER_CLASS, 
+        VENDOR_CLASS, 
+        VENDOR_OPTS, 
+        INTERFACE_ID, 
+        RECONF_MSG, 
+        RECONF_ACCEPT, 
+        SIP_SERVER_D, 
+        SIP_SERVER_A, 
+        DNS_SERVERS, 
+        DOMAIN_LIST, 
+        IA_PD, 
+        IAPREFIX, 
+        NIS_SERVERS, 
+        NISP_SERVERS, 
+        NIS_DOMAIN_NAME, 
+        NISP_DOMAIN_NAME, 
+        SNTP_SERVERS, 
+        INFORMATION_REFRESH_TIME, 
+        BCMCS_SERVER_D, 
+        BCMCS_SERVER_A, 
+        GEOCONF_CIVIC = 36, 
+        REMOTE_ID, 
+        SUBSCRIBER_ID, 
+        CLIENT_FQDN, 
+        PANA_AGENT, 
+        NEW_POSIX_TIMEZONE, 
+        NEW_TZDB_TIMEZONE, 
+        ERO, 
+        LQ_QUERY, 
+        CLIENT_DATA, 
+        CLT_TIME, 
+        LQ_RELAY_DATA, 
+        LQ_CLIENT_LINK, 
+        MIP6_HNIDF, 
+        MIP6_VDINF, 
+        V6_LOST, 
+        CAPWAP_AC_V6, 
+        RELAY_ID, 
+        NTP_SERVER, 
+        V6_ACCESS_DOMAIN, 
+        SIP_UA_CS_LIST, 
+        BOOTFILE_URL, 
+        BOOTFILE_PARAM, 
+        CLIENT_ARCH_TYPE, 
+        NII, 
+        GEOLOCATION, 
+        AFTR_NAME, 
+        ERP_LOCAL_DOMAIN_NAME, 
+        RSOO, 
+        PD_EXCLUDE, 
+        VSS, 
+        MIP6_IDINF, 
+        MIP6_UDINF, 
+        MIP6_HNP, 
+        MIP6_HAA, 
+        MIP6_HAF, 
+        RDNSS_SELECTION, 
+        KRB_PRINCIPAL_NAME, 
+        KRB_REALM_NAME, 
+        KRB_DEFAULT_REALM_NAME, 
+        KRB_KDC
+    };
+
+    /**
+     * The type used to store the DHCPv6 options.
+     */
+    typedef std::list<option> options_type;
+
+    /**
+     * The type used to store IP addresses.
+     */
+    typedef IPv6Address ipaddress_type;
+    
+    /**
+     * This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::DHCPv6;
+
+    /**
+     * The type used to store the Identity Association for Non-Temporary
+     * Addresses option.
+     */
+    struct ia_na_type {
+        typedef std::vector<uint8_t> options_type;
+        
+        uint32_t id, t1, t2;
+        options_type options;
+        
+        ia_na_type(uint32_t id = 0, uint32_t t1 = 0, uint32_t t2 = 0,
+          const options_type& options = options_type())
+        : id(id), t1(t1), t2(t2), options(options) {}
+
+        static ia_na_type from_option(const option &opt);
+    };
+    
+    /**
+     * The type used to store the Identity Association for Temporary
+     * Addresses option.
+     */
+    struct ia_ta_type {
+        typedef std::vector<uint8_t> options_type;
+        
+        uint32_t id;
+        options_type options;
+        
+        ia_ta_type(uint32_t id = 0,
+          const options_type& options = options_type())
+        : id(id), options(options) {}
+
+        static ia_ta_type from_option(const option &opt);
+    };
+
+    /**
+     * The type used to store the Identity Association Address option.
+     */
+    struct ia_address_type {
+        typedef std::vector<uint8_t> options_type;
+        
+        ipaddress_type address;
+        uint32_t preferred_lifetime, valid_lifetime;
+        options_type options;
+        
+        ia_address_type(ipaddress_type address = ipaddress_type(), 
+          uint32_t preferred_lifetime = 0, uint32_t valid_lifetime = 0, 
+          const options_type& options = options_type())
+        : address(address), preferred_lifetime(preferred_lifetime), 
+          valid_lifetime(valid_lifetime), options(options) {}
+
+        static ia_address_type from_option(const option &opt);
+    };
+    
+    /**
+     * The type used to store the Authentication option.
+     */
+    struct authentication_type {
+        typedef std::vector<uint8_t> auth_info_type;
+        
+        uint8_t protocol, algorithm, rdm;
+        uint64_t replay_detection;
+        auth_info_type auth_info;
+        
+        authentication_type(uint8_t protocol = 0, uint8_t algorithm = 0,
+          uint8_t rdm = 0, uint64_t replay_detection = 0,
+          const auth_info_type &auth_info = auth_info_type())
+        : protocol(protocol), algorithm(algorithm), rdm(rdm),
+        replay_detection(replay_detection), auth_info(auth_info) {}
+
+        static authentication_type from_option(const option &opt);
+    };
+    
+    /**
+     * The type used to store the Status Code option.
+     */
+    struct status_code_type {
+        uint16_t code;
+        std::string message;
+        
+        status_code_type(uint16_t code = 0, const std::string &message = "")
+        : code(code), message(message) { }
+
+        static status_code_type from_option(const option &opt);
+    };
+    
+    /**
+     * The type used to store the Vendor-specific Information option.
+     */
+    struct vendor_info_type {
+        typedef std::vector<uint8_t> data_type;
+        
+        uint32_t enterprise_number;
+        data_type data;
+        
+        vendor_info_type(uint32_t enterprise_number = 0, 
+          const data_type &data = data_type())
+        : enterprise_number(enterprise_number), data(data) { }
+
+        static vendor_info_type from_option(const option &opt);
+    };
+    
+    
+    /**
+     * The type used to store the User Class option's user class data.
+     */
+    typedef std::vector<uint8_t> class_option_data_type;
+    
+    /**
+     * The type used to store the User Class option.
+     */
+    //typedef std::vector<class_option_data_type> user_class_type;
+    struct user_class_type {
+        typedef std::vector<class_option_data_type> data_type;
+        data_type data;
+
+        user_class_type(const data_type &data = data_type())
+        : data(data)
+        {
+
+        }
+
+        static user_class_type from_option(const option &opt);
+    };
+    
+    /**
+     * The type used to store the Vendor Class option.
+     */
+    struct vendor_class_type {
+        typedef std::vector<class_option_data_type> class_data_type;
+        
+        uint32_t enterprise_number;
+        class_data_type vendor_class_data;
+        
+        vendor_class_type(uint32_t enterprise_number = 0, 
+          const class_data_type &vendor_class_data = class_data_type())
+        : enterprise_number(enterprise_number), 
+        vendor_class_data(vendor_class_data) { }
+
+        static vendor_class_type from_option(const option &opt);
+    };
+    
+    /**
+     * The type used to represent DUIDs Based on Link-layer Address Plus
+     * Time. 
+     */
+    struct duid_llt {
+        static const uint16_t duid_id = 1;
+        typedef std::vector<uint8_t> lladdress_type;
+        
+        uint16_t hw_type;
+        uint32_t time;
+        lladdress_type lladdress;
+        
+        duid_llt(uint16_t hw_type = 0, uint32_t time = 0,
+          const lladdress_type &lladdress = lladdress_type())
+        : hw_type(hw_type), time(time), lladdress(lladdress) {}
+        
+        PDU::serialization_type serialize() const;
+        
+        static duid_llt from_bytes(const uint8_t *buffer, uint32_t total_sz);
+    };
+    
+    /**
+     * The type used to represent DUIDs Based on Enterprise Number
+     */
+    struct duid_en {
+        static const uint16_t duid_id = 2;
+        typedef std::vector<uint8_t> identifier_type;
+        
+        uint32_t enterprise_number;
+        identifier_type identifier;
+        
+        duid_en(uint32_t enterprise_number = 0,
+          const identifier_type &identifier = identifier_type())
+        : enterprise_number(enterprise_number), identifier(identifier) {}
+        
+        PDU::serialization_type serialize() const;
+        
+        static duid_en from_bytes(const uint8_t *buffer, uint32_t total_sz);
+    };
+    
+    /**
+     * The type used to represent DUIDs Based on Link-layer Address.
+     */
+    struct duid_ll {
+        static const uint16_t duid_id = 3;
+        typedef std::vector<uint8_t> lladdress_type;
+        
+        uint16_t hw_type;
+        lladdress_type lladdress;
+        
+        duid_ll(uint16_t hw_type = 0, 
+          const lladdress_type &lladdress = lladdress_type())
+        : hw_type(hw_type), lladdress(lladdress) {}
+        
+        PDU::serialization_type serialize() const;
+        
+        static duid_ll from_bytes(const uint8_t *buffer, uint32_t total_sz);
+    };
+    
+    /**
+     * Type type used to represent DUIDs. This will be stored as the 
+     * value for the Client/Server Identifier options.
+     */
+    struct duid_type {
+        typedef PDU::serialization_type data_type;
+        
+        uint16_t id;
+        data_type data;
+        
+        duid_type(uint16_t id = 0, const data_type &data = data_type())
+        : id(id), data(data) {}
+        
+        duid_type(const duid_llt &identifier)
+        : id(duid_llt::duid_id), data(identifier.serialize()) {}
+        
+        duid_type(const duid_en &identifier)
+        : id(duid_en::duid_id), data(identifier.serialize()) {}
+        
+        duid_type(const duid_ll &identifier)
+        : id(duid_en::duid_id), data(identifier.serialize()) {}
+
+        static duid_type from_option(const option &opt);
+    };
+        
+    /**
+     * The type used to store the Option Request option.
+     */
+    typedef std::vector<uint16_t> option_request_type;
+    
+    /**
+     * The type used to store the Relay Message option.
+     */
+    typedef std::vector<uint8_t> relay_msg_type;
+    
+    /**
+     * The type used to store the Interface-ID option.
+     */
+    typedef std::vector<uint8_t> interface_id_type;
+
+    /**
+     * Default constructor.
+     */
+    DHCPv6();
+    
+    /**
+     * \brief Constructs a DHCPv6 object from a buffer.
+     * 
+     * If there is not enough size for the DHCPv6 header, or any
+     * of the TLV options contains an invalid size field, a 
+     * malformed_packet exception is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    DHCPv6(const uint8_t *buffer, uint32_t total_sz);
+
+    // Getters
+    
+    /**
+     * \brief Getter for the message type field.
+     *
+     * \return The stored message type field.
+     */
+    MessageType msg_type() const { 
+        return static_cast<MessageType>(header_data[0]); 
+    }
+    
+    /**
+     * \brief Getter for the hop count field.
+     *
+     * \return The stored hop count field.
+     */
+    uint8_t hop_count() const { return header_data[1]; }
+    
+    /**
+     * \brief Getter for the transaction id field.
+     *
+     * \return The stored transaction id field.
+     */
+    small_uint<24> transaction_id() const { 
+        return (header_data[1] << 16) | (header_data[2] << 8) | header_data[3];
+    }
+
+    /**
+     * \brief Getter for the peer address field.
+     *
+     * \return The stored peer address field.
+     */
+    const ipaddress_type &peer_address() const { return peer_addr; }
+    
+    /**
+     * \brief Getter for the link address field.
+     *
+     * \return The stored link address field.
+     */
+    const ipaddress_type &link_address() const { return link_addr; }
+    
+    /**
+     * \brief Getter for the DHCPv6 options.
+     *
+     * \return The stored options.
+     */
+    const options_type &options() const { return options_; }
+
+    // Setters
+    /**
+     * \brief Setter for the message type field.
+     *
+     * \param type The new message type.
+     */
+    void msg_type(MessageType type);
+    
+    /**
+     * \brief Setter for the hop count field.
+     *
+     * \param count The new hop count.
+     */
+    void hop_count(uint8_t count);
+    
+    /**
+     * \brief Setter for the transaction id field.
+     *
+     * \param id The new transaction id.
+     */
+    void transaction_id(small_uint<24> id);
+    
+    /**
+     * \brief Setter for the peer address field.
+     *
+     * \param count The new peer address.
+     */
+    void peer_address(const ipaddress_type &addr);
+    
+    /**
+     * \brief Setter for the link address field.
+     *
+     * \param count The new link address.
+     */
+    void link_address(const ipaddress_type &addr);
+    
+    // Option getters
+    
+    /**
+     * \brief Getter for the Identity Association for Non-Temporary
+     * Addresses option.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    ia_na_type ia_na() const;
+    
+    /**
+     * \brief Getter for the Identity Association for Temporary
+     * Addresses option.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    ia_ta_type ia_ta() const;
+    
+    /**
+     * \brief Getter for the Identity Association Address option.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    ia_address_type ia_address() const;
+    
+    /**
+     * \brief Getter for the Option Request option.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    option_request_type option_request() const;
+    
+    /**
+     * \brief Getter for the Preference option.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    uint8_t preference() const;
+    
+    /**
+     * \brief Getter for the Elapsed Time option.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    uint16_t elapsed_time() const;
+    
+    /**
+     * \brief Getter for the Relay Message option.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    relay_msg_type relay_message() const;
+    
+    /**
+     * \brief Getter for the Authentication option.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    authentication_type authentication() const;
+    
+    /**
+     * \brief Getter for the Server Unicast option.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    ipaddress_type server_unicast() const;
+    
+    /**
+     * \brief Getter for the Server Unicast option.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    status_code_type status_code() const;
+    
+    /**
+     * \brief Getter for the Rapid Commit option.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    bool has_rapid_commit() const;
+    
+    /**
+     * \brief Getter for the User Class option.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    user_class_type user_class() const;
+    
+    /**
+     * \brief Getter for the Vendor Class option.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    vendor_class_type vendor_class() const;
+    
+    /**
+     * \brief Getter for the Vendor-specific Information option.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    vendor_info_type vendor_info() const;
+    
+    /**
+     * \brief Getter for the Interface ID option.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    interface_id_type interface_id() const;
+
+    /**
+     * \brief Getter for the Reconfigure Message option.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    uint8_t reconfigure_msg() const;
+    
+    /**
+     * \brief Getter for the Reconfigure Accept option.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    bool has_reconfigure_accept() const;
+    
+    /**
+     * \brief Getter for the Client Identifier option.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    duid_type client_id() const;
+    
+    /**
+     * \brief Getter for the Server Identifier option.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    duid_type server_id() const;
+    
+    // Option setters
+    
+    /**
+     * \brief Setter for the Identity Association for Non-Temporary
+     * Addresses option.
+     * 
+     * \param value The new IA_NA option data.
+     */
+    void ia_na(const ia_na_type &value);
+    
+    /**
+     * \brief Setter for the Identity Association for Temporary
+     * Addresses option.
+     * 
+     * \param value The new IA_TA option data.
+     */
+    void ia_ta(const ia_ta_type &value);
+    
+    /**
+     * \brief Setter for the Identity Association Address option.
+     * 
+     * \param value The new IA Address option data.
+     */
+    void ia_address(const ia_address_type &value);
+    
+    /**
+     * \brief Setter for the Identity Association Address option.
+     * 
+     * \param value The new Option Request option data.
+     */
+    void option_request(const option_request_type &value);
+    
+    /**
+     * \brief Setter for the Preference option.
+     * 
+     * \param value The new Preference option data.
+     */
+    void preference(uint8_t value);
+    
+    /**
+     * \brief Setter for the Elapsed Time option.
+     * 
+     * \param value The new Elapsed Time option data.
+     */
+    void elapsed_time(uint16_t value);
+    
+    /**
+     * \brief Setter for the Relay Message option.
+     * 
+     * \param value The new Relay Message option data.
+     */
+    void relay_message(const relay_msg_type &value);
+    
+    /**
+     * \brief Setter for the Authentication option.
+     * 
+     * \param value The new Authentication option data.
+     */
+    void authentication(const authentication_type &value);
+    
+    /**
+     * \brief Setter for the Server Unicast option.
+     * 
+     * \param value The new Server Unicast option data.
+     */
+    void server_unicast(const ipaddress_type &value);
+    
+    /**
+     * \brief Setter for the Status Code option.
+     * 
+     * \param value The new Status Code option data.
+     */
+    void status_code(const status_code_type &value);
+    
+    /**
+     * \brief Adds a Rapid Commit option.
+     */
+    void rapid_commit();
+    
+    /**
+     * \brief Setter for the User Class option.
+     * 
+     * \param value The new User Class option data.
+     */
+    void user_class(const user_class_type &value);
+    
+    /**
+     * \brief Setter for the Vendor Class option.
+     * 
+     * \param value The new Vendor Class option data.
+     */
+    void vendor_class(const vendor_class_type &value);
+    
+    /**
+     * \brief Setter for the Vendor-specific Information option.
+     * 
+     * \param value The new Vendor-specific Information option data.
+     */
+    void vendor_info(const vendor_info_type &value);
+    
+    /**
+     * \brief Setter for the Interface ID option.
+     * 
+     * \param value The new Interface ID option data.
+     */
+    void interface_id(const interface_id_type &value);
+    
+    /**
+     * \brief Setter for the Reconfigure Message option.
+     * 
+     * \param value The new Reconfigure Message option data.
+     */
+    void reconfigure_msg(uint8_t value);
+    
+    /**
+     * \brief Adds a Reconfigure Accept option.
+     */
+    void reconfigure_accept();
+    
+    /**
+     * \brief Setter for the Client Identifier option.
+     * 
+     * \param value The new Client Identifier option data.
+     */
+    void client_id(const duid_type &value);
+    
+    /**
+     * \brief Setter for the Server Identifier option.
+     * 
+     * \param value The new Server Identifier option data.
+     */
+    void server_id(const duid_type &value);
+    
+    // Other stuff
+    
+    /**
+     * Indicates whether this is a relay agent/server message
+     */
+    bool is_relay_message() const;
+    
+    /**
+     * \brief Adds a DHCPv6 option.
+     * 
+     * The option is added after the last option in the option 
+     * fields.
+     * 
+     * \param opt The option to be added
+     */
+    void add_option(const option &opt);
+    
+    /**
+     * \brief Searchs for an option that matchs the given flag.
+     * 
+     * If the option is not found, a null pointer is returned. 
+     * Deleting the returned pointer will result in <b>undefined 
+     * behaviour</b>.
+     * 
+     * \param id The option identifier to be searched.
+     */
+    const option *search_option(OptionTypes id) const;
+
+    // PDU stuff
+    
+    /**
+     * \brief Returns the header size.
+     *
+     * This metod overrides PDU::header_size. \sa PDU::header_size
+     */
+    uint32_t header_size() const;
+    
+        /** 
+     * \brief Check wether ptr points to a valid response for this PDU.
+     *
+     * \sa PDU::matches_response
+     * \param ptr The pointer to the buffer.
+     * \param total_sz The size of the buffer.
+     */
+    bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
+    
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+    
+    /**
+     * \sa PDU::clone
+     */
+    DHCPv6 *clone() const {
+        return new DHCPv6(*this);
+    }
+private:
+    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *);
+    uint8_t* write_option(const option &option, uint8_t* buffer) const;
+    
+    template<template <typename> class Functor>
+    const option *safe_search_option(OptionTypes opt, uint32_t size) const {
+        const option *option = search_option(opt);
+        if(!option || Functor<uint32_t>()(option->data_size(), size))
+            throw option_not_found();
+        return option;
+    }
+
+    template<typename T>
+    T search_and_convert(OptionTypes opt) const {
+        const option *option = search_option(opt);
+        if(!option)
+            throw option_not_found();
+        return option->to<T>();
+    }
+
+    uint8_t header_data[4];
+    uint32_t options_size;
+    ipaddress_type link_addr, peer_addr;
+    options_type options_;
+};   
+
+namespace Internals {
+template<typename InputIterator>
+void class_option_data2option(InputIterator start, InputIterator end, 
+  std::vector<uint8_t>& buffer, size_t start_index = 0) 
+{
+    size_t index = start_index;
+    uint16_t uint16_t_buffer;
+    while(start != end) {
+        buffer.resize(buffer.size() + sizeof(uint16_t) + start->size());
+        uint16_t_buffer = Endian::host_to_be<uint16_t>(start->size());
+        std::memcpy(&buffer[index], &uint16_t_buffer, sizeof(uint16_t));
+        index += sizeof(uint16_t);
+        std::copy(start->begin(), start->end(), buffer.begin() + index);
+        index += start->size();
+        
+        start++;
+    }
+}
+
+template<typename OutputType>
+OutputType option2class_option_data(const uint8_t *ptr, uint32_t total_sz)
+{
+    typedef typename OutputType::value_type value_type;
+    OutputType output;
+    size_t index = 0;
+    while(index + 2 < total_sz) {
+        uint16_t size;
+        std::memcpy(&size, ptr + index, sizeof(uint16_t));
+        size = Endian::be_to_host(size);
+        index += sizeof(uint16_t);
+        if(index + size > total_sz)
+            throw option_not_found();
+        output.push_back(
+            value_type(ptr + index, ptr + index + size)
+        );
+        index += size;
+    }
+    if(index != total_sz)
+        throw malformed_option();
+    return output;
+}
+} 
+}
+
+#endif // TINS_DHCPV6_H

include/dns.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -36,12 +36,13 @@
 #include <cstring>
 #include <string>
 #include <map>
+#include "macros.h"
 #include "pdu.h"
 #include "endianness.h"
-#include "dns_record.h"
 
 namespace Tins {
     class IPv4Address;
+    class IPv6Address;
     
     /**
      * \class DNS
@@ -198,14 +199,24 @@ namespace Tins {
          */
         class Resource {
         public:
-            Resource(const std::string &nm, const std::string &ad, 
-              uint16_t t, uint16_t c, uint32_t tt) 
-            : dname_(nm), addr_(ad), type_(t), qclass_(c), ttl_(tt) {}
+            /**
+             * Constructs a Resource object.
+             *
+             * \param dname The domain name for which this records 
+             * provides an answer.
+             * \param data The resource's payload.
+             * \param type The type of this record.
+             * \param rclass The class of this record.
+             * \param ttl The time-to-live of this record.
+             */
+            Resource(const std::string &dname, const std::string &data, 
+              uint16_t type, uint16_t rclass, uint32_t ttl) 
+            : dname_(dname), data_(data), type_(type), qclass_(rclass), ttl_(ttl) {}
             
             Resource() : type_(), qclass_(), ttl_() {}
             
             /**
-             * \brief Getter for the dname field.
+             * \brief Getter for the domain name field.
              * 
              * This returns the domain name for which this record 
              * provides an answer.
@@ -213,9 +224,9 @@ namespace Tins {
             const std::string &dname() const { return dname_; }
             
             /**
-             * Getter for the type field.
+             * Getter for the data field. 
              */
-            const std::string &data() const { return addr_; }
+            const std::string &data() const { return data_; }
             
             /**
              * Getter for the query type field.
@@ -231,8 +242,52 @@ namespace Tins {
              * Getter for the type field.
              */
             uint32_t ttl() const { return ttl_; }
+
+            /**
+             * Setter for the domain name field.
+             */
+            void dname(const std::string &data) {
+                dname_ = data;
+            }
+
+            /**
+             * \brief Setter for the data field.
+             *
+             * The data will be encoded properly by the DNS class before
+             * being added to this packet. That means that if the type is
+             * A or AAAA, it will be properly encoded as an IPv4 or
+             * IPv6 address. 
+             * 
+             * The same happens for records that contain domain names,
+             * such as NS or CNAME. This data will be encoded using 
+             * DNS domain name encoding.
+             */
+            void data(const std::string &data) {
+                data_ = data;
+            }
+
+            /**
+             * Setter for the type field.
+             */
+            void type(uint16_t data) {
+                type_ = data;
+            }
+
+            /**
+             * Setter for the class field.
+             */
+            void query_class(uint16_t data) {
+                qclass_ = data;
+            }
+
+            /**
+             * Setter for the time-to-live field.
+             */
+            void ttl(uint16_t data) {
+                ttl_ = data;
+            }
         private:
-            std::string dname_, addr_;
+            std::string dname_, data_;
             uint16_t type_, qclass_;
             uint32_t ttl_;
         };
@@ -240,6 +295,7 @@ namespace Tins {
         typedef std::list<Query> queries_type;
         typedef std::list<Resource> resources_type;
         typedef IPv4Address address_type;
+        typedef IPv6Address address_v6_type;
         
         /**
          * \brief Default constructor.
@@ -249,7 +305,11 @@ namespace Tins {
         DNS();
         
         /**
-         * \brief Constructor which creates a DNS object from a buffer.
+         * \brief Constructs a DNS object from a buffer.
+         * 
+         * If there's not enough size for the DNS header, or any of the
+         * records are malformed, a malformed_packet is be thrown.
+         * 
          * \param buffer The buffer from which this PDU will be 
          * constructed.
          * \param total_sz The total size of the buffer.
@@ -475,81 +535,79 @@ namespace Tins {
         void add_query(const Query &query);
         
         /**
-         * \brief Add a query response.
+         * \brief Add an answer resource record.
          * 
-         * \param name The resolved name.
-         * \param type The type of this answer.
-         * \param qclass The class of this answer.
-         * \param ttl The time-to-live of this answer.
-         * \param ip The ip address of the resolved name.
+         * \param resource The resource to be added.
          */
-        void add_answer(const std::string &name, 
-          const DNSResourceRecord::info &info, address_type ip);
-                        
+        void add_answer(const Resource &resource);
+
         /**
-         * \brief Add a query response.
+         * \brief Add an authority resource record.
          * 
-         * \param name The resolved name.
-         * \param type The type of this answer.
-         * \param qclass The class of this answer.
-         * \param ttl The time-to-live of this answer.
-         * \param dname The domain of the resolved name.
+         * \param resource The resource to be added.
          */
-        void add_answer(const std::string &name, 
-          const DNSResourceRecord::info &info, const std::string &dname);
-                        
-        /**
-         * \brief Add a query response.
-         * 
-         * \param name The resolved name.
-         * \param type The type of this answer.
-         * \param qclass The class of this answer.
-         * \param ttl The time-to-live of this answer.
-         * \param data The data of this option.
-         * \param sz The size of the data.
-         */
-        void add_answer(const std::string &name, 
-          const DNSResourceRecord::info &info, const uint8_t *data, uint32_t sz);
+        void add_authority(const Resource &resource);
         
         /**
-         * \brief Add an authority record.
+         * \brief Add an additional resource record.
          * 
-         * \param name The resolved name.
-         * \param type The type of this record.
-         * \param qclass The class of this record.
-         * \param ttl The time-to-live of this record.
-         * \param data The data of this option.
-         * \param sz The size of the data.
+         * \param resource The resource to be added.
          */
-        void add_authority(const std::string &name, 
-          const DNSResourceRecord::info &info, const uint8_t *data, uint32_t sz);
-        
-        /**
-         * \brief Add an additional record.
-         * 
-         * \param name The resolved name.
-         * \param type The type of this record.
-         * \param qclass The class of this record.
-         * \param ttl The time-to-live of this record.
-         * \param ip The ip address of the resolved name.
-         */
-        void add_additional(const std::string &name, 
-          const DNSResourceRecord::info &info, uint32_t ip);
-                        
+        void add_additional(const Resource &resource);
         
         /**
          * \brief Getter for this PDU's DNS queries.
-         * \return std::list<Query> containing the queries in this
-         * record.
+         * 
+         * \return The query records in this PDU.
          */
         queries_type queries() const;
         
         /**
          * \brief Getter for this PDU's DNS answers
-         * \return std::list<Resource> containing the answers in this
-         * record.
+         * 
+         * \return The answer records in this PDU.
          */
         resources_type answers() const;
+
+        /**
+         * \brief Getter for this PDU's DNS authority records.
+         * 
+         * \return The authority records in this PDU.
+         */
+        resources_type authority() const;
+
+        /**
+         * \brief Getter for this PDU's DNS additional records.
+         * 
+         * \return The additional records in this PDU.
+         */
+        resources_type additional() const;
+        
+        /**
+         * \brief Encodes a domain name.
+         *
+         * This processes the input domain name and returns the encoded 
+         * version. Each label in the original domain name will be 
+         * prefixed with a byte that indicates the label's length. 
+         * The null-terminator byte <b>will</b> be included in the encoded
+         * string. No compression is performed.
+         *
+         * For example, given the input "www.example.com", the output would
+         * be "\x03www\x07example\x03com\x00".
+         * 
+         * \param domain_name The domain name to encode.
+         * \return The encoded domain name.
+         */
+        static std::string encode_domain_name(const std::string &domain_name);
+
+        /** 
+         * \brief Check wether ptr points to a valid response for this PDU.
+         *
+         * \sa PDU::matches_response
+         * \param ptr The pointer to the buffer.
+         * \param total_sz The size of the buffer.
+         */
+        bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
         
         /**
          * \sa PDU::clone
@@ -557,18 +615,8 @@ namespace Tins {
         DNS *clone() const {
             return new DNS(*this);
         }
-        
-        /**
-         * Helper function to create a resource record information
-         * 
-         * \param type The type of the query.
-         * \param qclass The class of the query.
-         * \param ttl The time-to-live of the query.
-         */
-        static DNSResourceRecord::info make_info(QueryType type, QueryClass qclass, uint32_t ttl) {
-            return DNSResourceRecord::info((uint16_t)type, (uint16_t)qclass, ttl);
-        }
     private:
+        TINS_BEGIN_PACK
         struct dnshdr {
             uint16_t id;
             #if TINS_IS_LITTLE_ENDIAN
@@ -598,39 +646,27 @@ namespace Tins {
             #endif
             uint16_t questions, answers,
                      authority, additional;
-        } __attribute__((packed));
+        } TINS_END_PACK;
         
-        typedef std::map<uint16_t, std::string> SuffixMap;
-        typedef std::map<uint16_t, uint16_t> SuffixIndices;
-        typedef std::list<DNSResourceRecord> ResourcesType;
         typedef std::list<Query> QueriesType;
+        typedef std::vector<std::pair<uint32_t*, uint32_t> > sections_type;
         
-        const uint8_t *build_resource_list(ResourcesType &lst, const uint8_t *ptr, uint32_t &sz, uint16_t nrecs);
-        uint32_t find_domain_name(const std::string &dname);
-        bool find_domain_name(const std::string &dname, const ResourcesType &lst, uint16_t &out);
-        void parse_domain_name(const std::string &dn, std::string &out) const;
-        void unparse_domain_name(const std::string &dn, std::string &out) const;
-        void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
-        uint8_t *serialize_list(const ResourcesType &lst, uint8_t *buffer) const;
-        void compose_name(const uint8_t *ptr, uint32_t sz, std::string &out) const;
-        void convert_resources(const ResourcesType &lst, std::list<Resource> &res) const;
-        DNSResourceRecord make_record(const std::string &name, const DNSResourceRecord::info &info, uint32_t ip);
-        DNSResourceRecord make_record(const std::string &name, const DNSResourceRecord::info &info, const std::string &dname);
-        DNSResourceRecord make_record(const std::string &name, const DNSResourceRecord::info &info, const uint8_t *ptr, uint32_t len);
-        void add_suffix(uint32_t index, const uint8_t *data, uint32_t sz) const;
-        uint32_t build_suffix_map(uint32_t index, const ResourcesType &lst) const;
-        uint32_t build_suffix_map(uint32_t index, const QueriesType &lst) const;
-        void build_suffix_map() const ;
+        const uint8_t* compose_name(const uint8_t *ptr, char *out_ptr) const;
+        void convert_records(const uint8_t *ptr, const uint8_t *end, resources_type &res) const;
+        const uint8_t* find_section_end(const uint8_t *ptr, const uint32_t num_records) const;
+        const uint8_t* find_dname_end(const uint8_t *ptr) const;
+        void update_records(uint32_t &section_start, uint32_t num_records, uint32_t threshold, uint32_t offset);
+        uint8_t *update_dname(uint8_t *ptr, uint32_t threshold, uint32_t offset);
+        static void inline_convert_v4(uint32_t value, char *output);
         static bool contains_dname(uint16_t type);
+        void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
+        void add_record(const Resource &resource, const sections_type &sections);
         
         dnshdr dns;
-        uint32_t extra_size;
-        std::list<Query> queries_;
-        ResourcesType ans, arity, addit;
-        mutable SuffixMap suffixes;
-        mutable SuffixIndices suffix_indices;
+        byte_array records_data;
+        uint32_t answers_idx, authority_idx, additional_idx;
     };
-};
+}
 
 #endif // TINS_DNS_H
 

include/dns_record.h

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

include/dot11/CMakeLists.txt

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

include/dot11/dot11_assoc.h

@@ -0,0 +1,622 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "../config.h"
+
+#if !defined(TINS_DOT11_DOT11_ASSOC_H) && defined(HAVE_DOT11)
+#define TINS_DOT11_DOT11_ASSOC_H
+
+#include "../dot11/dot11_mgmt.h"
+
+namespace Tins {
+/**
+ * \brief Class representing a Disassociation frame in the IEEE 802.11 Protocol.
+ *
+ */
+class Dot11Disassoc : public Dot11ManagementFrame {
+public:
+   /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::DOT11_DIASSOC;
+
+    /**
+     * \brief Constructor for creating a 802.11 Disassociation.
+     *
+     * Constructs a 802.11 Disassociation taking the destination
+     * and source hardware address.
+     *
+     * \param dst_hw_addr The destination hardware address.
+     * \param src_hw_addr The source hardware address.
+     */
+    Dot11Disassoc(const address_type &dst_hw_addr = address_type(), 
+                const address_type &src_hw_addr = address_type());
+
+    /**
+     * \brief Constructs a Dot11Disassoc object from a buffer and 
+     * adds all identifiable PDUs found in the buffer as children 
+     * of this one.
+     *
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for the header in the buffer
+     * or the input data is malformed, a malformed_packet exception 
+     * is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot11Disassoc(const uint8_t *buffer, uint32_t total_sz);
+
+    /**
+     * \brief Getter for the reason code field.
+     *
+     * \return The stored reason code.
+     */
+    uint16_t reason_code() const { return Endian::le_to_host(_body.reason_code); }
+
+    /**
+     * \brief Setter for the reason code field.
+     *
+     * \param new_reason_code The reason code to be set.
+     */
+    void reason_code(uint16_t new_reason_code);
+
+    /**
+     * \brief Returns the frame's header length.
+     *
+     * \return An uint32_t with the header's size.
+     * \sa PDU::header_size()
+     */
+    uint32_t header_size() const;
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     * \param flag The flag to match
+     * \sa PDU::matches_flag
+     */
+    bool matches_flag(PDUType flag) const {
+       return flag == pdu_flag || Dot11ManagementFrame::matches_flag(flag);
+    }
+
+    /**
+     * \brief Clones this PDU.
+     *
+     * \sa PDU::clone
+     */
+    Dot11Disassoc *clone() const {
+        return new Dot11Disassoc(*this);
+    }
+private:
+    struct DisassocBody {
+        uint16_t reason_code;
+    };
+
+    uint32_t write_fixed_parameters(uint8_t *buffer, uint32_t total_sz);
+
+    DisassocBody _body;
+};
+
+/**
+ * \brief Class representing an Association Request frame in the IEEE 802.11 Protocol.
+ *
+ */
+class Dot11AssocRequest : public Dot11ManagementFrame {
+public:
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::DOT11_ASSOC_REQ;
+
+    /**
+     * \brief Constructor for creating a 802.11 Association Request.
+     *
+     * Constructs a 802.11 Association Request taking the
+     * destination and source hardware address.
+     *
+     * \param dst_hw_addr The destination hardware address.
+     * \param src_hw_addr The source hardware address.
+     */
+    Dot11AssocRequest(const address_type &dst_hw_addr = address_type(), 
+                    const address_type &src_hw_addr = address_type());
+
+    /**
+     * \brief Constructs a Dot11AssocRequest object from a buffer 
+     * and adds all identifiable PDUs found in the buffer as children 
+     * of this one.
+     * 
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for the header in the buffer
+     * or the input data is malformed, a malformed_packet exception 
+     * is thrown.
+     *
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot11AssocRequest(const uint8_t *buffer, uint32_t total_sz);
+
+    /**
+     * \brief Getter for the Capabilities Information.
+     *
+     * \return A constant refereence to the stored Capabilities 
+     * Information field.
+     */
+    const capability_information& capabilities() const { return _body.capability;}
+
+    /**
+     * \brief Getter for the Capabilities Information.
+     *
+     * \return A refereence to the stored Capabilities Information 
+     * field.
+     */
+    capability_information& capabilities() { return _body.capability;}
+
+    /**
+     * \brief Getter for the listen interval field.
+     *
+     * \return The stored listen interval field.
+     */
+    uint16_t listen_interval() const { return Endian::le_to_host(_body.listen_interval); }
+
+    /**
+     * \brief Setter for the listen interval field.
+     *
+     * \param new_listen_interval The listen interval to be set.
+     */
+    void listen_interval(uint16_t new_listen_interval);
+
+    /**
+     * \brief Returns the frame's header length.
+     *
+     * \return An uint32_t with the header's size.
+     * \sa PDU::header_size()
+     */
+    uint32_t header_size() const;
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     * \param flag The flag to match
+     * \sa PDU::matches_flag
+     */
+    bool matches_flag(PDUType flag) const {
+       return flag == pdu_flag || Dot11ManagementFrame::matches_flag(flag);
+    }
+
+    /**
+     * \brief Clones this PDU.
+     *
+     * \sa PDU::clone
+     */
+    Dot11AssocRequest *clone() const {
+        return new Dot11AssocRequest(*this);
+    }
+private:
+    struct AssocReqBody {
+        capability_information capability;
+        uint16_t listen_interval;
+    };
+
+    uint32_t write_fixed_parameters(uint8_t *buffer, uint32_t total_sz);
+
+    AssocReqBody _body;
+};
+
+/**
+ * \brief Class representing an Association Response frame in the IEEE 802.11 Protocol.
+ *
+ */
+class Dot11AssocResponse : public Dot11ManagementFrame {
+public:
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::DOT11_ASSOC_RESP;
+
+    /**
+     * \brief Constructor for creating a 802.11 Association Response.
+     *
+     * Constructors a 802.11 Association Response taking destination 
+     * and source hardware address.
+     *
+     * \param dst_hw_addr The destination hardware address.
+     * \param src_hw_addr The source hardware address.
+     */
+    Dot11AssocResponse(const address_type &dst_hw_addr = address_type(), 
+                        const address_type &src_hw_addr = address_type());
+
+    /**
+     * \brief Constructor which creates a Dot11AssocResponse object 
+     * from a buffer and adds all identifiable PDUs found in the 
+     * buffer as children of this one.
+     *
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for the header in the buffer
+     * or the input data is malformed, a malformed_packet exception 
+     * is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot11AssocResponse(const uint8_t *buffer, uint32_t total_sz);
+
+    /**
+     * \brief Getter for the Capabilities Information field.
+     *
+     * \return A constant reference to the stored Capabilities 
+     * Information field.
+     */
+    const capability_information& capabilities() const { return _body.capability;}
+
+    /**
+     * \brief Getter for the Capabilities Information field.
+     *
+     * \return A reference to the stored Capabilities 
+     * Information field.
+     */
+    capability_information& capabilities() { return _body.capability;}
+
+    /**
+     * \brief Getter for the status code field.
+     *
+     * \return The stored status code.
+     */
+    uint16_t status_code() const { return Endian::le_to_host(_body.status_code); }
+
+    /**
+     * \brief Getter for the AID field.
+     *
+     * \return The stored AID field.
+     */
+    uint16_t aid() const { return Endian::le_to_host(_body.aid); }
+
+    /**
+     * \brief Setter for the status code.
+     *
+     * \param new_status_code The status code to be set.
+     */
+    void status_code(uint16_t new_status_code);
+
+    /**
+     * \brief Setter for the AID field.
+     *
+     * \param new_aid The AID value to be set.
+     */
+    void aid(uint16_t new_aid);
+
+    /**
+     * \brief Returns the frame's header length.
+     *
+     * \return An uint32_t with the header's size.
+     * \sa PDU::header_size()
+     */
+    uint32_t header_size() const;
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     * \param flag The flag to match
+     * \sa PDU::matches_flag
+     */
+    bool matches_flag(PDUType flag) const {
+       return flag == pdu_flag || Dot11ManagementFrame::matches_flag(flag);
+    }
+
+    /**
+     * \brief Clones this PDU.
+     *
+     * \sa PDU::clone
+     */
+    Dot11AssocResponse *clone() const {
+        return new Dot11AssocResponse(*this);
+    }
+private:
+    struct AssocRespBody {
+        capability_information capability;
+        uint16_t status_code;
+        uint16_t aid;
+    };
+
+    uint32_t write_fixed_parameters(uint8_t *buffer, uint32_t total_sz);
+
+    AssocRespBody _body;
+};
+
+/**
+ * \brief Class representing an ReAssociation Request frame in the IEEE 802.11 Protocol.
+ *
+ */
+class Dot11ReAssocRequest : public Dot11ManagementFrame {
+public:
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::DOT11_REASSOC_REQ;
+
+    /**
+     * \brief Constructor for creating a 802.11 ReAssociation Request.
+     *
+     * Constructors a 802.11 Association Request taking the destination 
+     * and source hardware address.
+     *
+     * \param dst_hw_addr The destination hardware address.
+     * \param src_hw_addr The source hardware address.
+     */
+    Dot11ReAssocRequest(const address_type &dst_hw_addr = address_type(), 
+                        const address_type &src_hw_addr = address_type());
+
+    /**
+     * \brief Constructs a Dot11AssocRequest object from a buffer 
+     * and adds all identifiable PDUs found in the buffer as 
+     * children of this one.
+     * 
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for the header in the buffer
+     * or the input data is malformed, a malformed_packet exception 
+     * is thrown.
+     *
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot11ReAssocRequest(const uint8_t *buffer, uint32_t total_sz);
+
+    /**
+     * \brief Getter for the Capabilities Information.
+     *
+     * \return A constant reference to the stored Capabilities 
+     * Information field.
+     */
+    const capability_information& capabilities() const { return _body.capability;}
+
+    /**
+     * \brief Getter for the Capabilities Information.
+     *
+     * \return A reference to the stored Capabilities Information 
+     * field.
+     */
+    capability_information& capabilities() { return _body.capability;}
+
+    /**
+     * \brief Getter for the listen interval field.
+     *
+     * \return The stored listen interval.
+     */
+    uint16_t listen_interval() const { return Endian::le_to_host(_body.listen_interval); }
+
+    /**
+     * \brief Getter for the current ap field.
+     *
+     * \return The current ap.
+     */
+    address_type current_ap() const { return _body.current_ap; }
+
+    /**
+     * \brief Setter for the listen interval field.
+     *
+     * \param new_listen_interval The listen interval to be set.
+     */
+    void listen_interval(uint16_t new_listen_interval);
+
+    /**
+     * \brief Setter for the current ap.
+     *
+     * \param new_current_ap The address of the current ap.
+     */
+    void current_ap(const address_type &new_current_ap);
+
+    /**
+     * \brief Returns the frame's header length.
+     *
+     * \return An uint32_t with the header's size.
+     * \sa PDU::header_size()
+     */
+    uint32_t header_size() const;
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     * \param flag The flag to match
+     * \sa PDU::matches_flag
+     */
+    bool matches_flag(PDUType flag) const {
+       return flag == pdu_flag || Dot11ManagementFrame::matches_flag(flag);
+    }
+
+    /**
+     * \brief Clones this PDU.
+     *
+     * \sa PDU::clone
+     */
+    Dot11ReAssocRequest *clone() const {
+        return new Dot11ReAssocRequest(*this);
+    }
+private:
+    struct ReAssocReqBody {
+        capability_information capability;
+        uint16_t listen_interval;
+        uint8_t current_ap[address_type::address_size];
+    };
+
+    uint32_t write_fixed_parameters(uint8_t *buffer, uint32_t total_sz);
+
+    ReAssocReqBody _body;
+};
+
+/**
+ * \brief IEEE 802.11 ReAssociation Response frame.
+ *
+ */
+class Dot11ReAssocResponse : public Dot11ManagementFrame {
+public:
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::DOT11_REASSOC_RESP;
+
+    /**
+     * \brief Constructor for creating a 802.11 Association Response.
+     *
+     * Constructs a 802.11 ReAssociation Response taking the 
+     * destination and source hardware address.
+     *
+     * \param dst_hw_addr The destination hardware address.
+     * \param src_hw_addr The source hardware address.
+     */
+    Dot11ReAssocResponse(const address_type &dst_hw_addr = address_type(), 
+                        const address_type &src_hw_addr = address_type());
+
+    /**
+     * \brief Constructs a Dot11ReAssocResponse object from a buffer 
+     * and adds all identifiable PDUs found in the buffer as children 
+     * of this one.
+     * 
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for the header in the buffer
+     * or the input data is malformed, a malformed_packet exception 
+     * is thrown.
+     *
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot11ReAssocResponse(const uint8_t *buffer, uint32_t total_sz);
+
+    /**
+     * \brief Getter for the Capabilities Information.
+     *
+     * \return A constant reference to the stored Capabilities 
+     * Information field.
+     */
+    const capability_information& capabilities() const { return _body.capability;}
+
+    /**
+     * \brief Getter for the Capabilities Information.
+     *
+     * \return A reference to the stored Capabilities Information 
+     * field.
+     */
+    capability_information& capabilities() { return _body.capability;}
+
+    /**
+     * \brief Getter for the status code field.
+     *
+     * \return The stored status code.
+     */
+    uint16_t status_code() const { return Endian::le_to_host(_body.status_code); }
+
+    /**
+     * \brief Getter for the AID field.
+     *
+     * \return The stored AID field value.
+     */
+    uint16_t aid() const { return Endian::le_to_host(_body.aid); }
+
+    /**
+     * \brief Setter for the status code field.
+     *
+     * \param new_status_code The status code to be set.
+     */
+    void status_code(uint16_t new_status_code);
+
+    /**
+     * \brief Setter for the AID field.
+     *
+     * \param new_aid The AID to be set.
+     */
+    void aid(uint16_t new_aid);
+
+    /**
+     * \brief Returns the frame's header length.
+     *
+     * \return An uint32_t with the header's size.
+     * \sa PDU::header_size()
+     */
+    uint32_t header_size() const;
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     * \param flag The flag to match
+     * \sa PDU::matches_flag
+     */
+    bool matches_flag(PDUType flag) const {
+       return flag == pdu_flag || Dot11ManagementFrame::matches_flag(flag);
+    }
+
+    /**
+     * \brief Clones this PDU.
+     *
+     * \sa PDU::clone
+     */
+    Dot11ReAssocResponse *clone() const {
+        return new Dot11ReAssocResponse(*this);
+    }
+private:
+    struct ReAssocRespBody {
+        capability_information capability;
+        uint16_t status_code;
+        uint16_t aid;
+    };
+
+    uint32_t write_fixed_parameters(uint8_t *buffer, uint32_t total_sz);
+
+    ReAssocRespBody _body;
+};
+} // namespace Tins
+
+#endif // TINS_DOT11_DOT11_ASSOC_H

include/dot11/dot11_auth.h

@@ -0,0 +1,260 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "../config.h"
+
+#if !defined(TINS_DOT11_DOT11_AUTH_H) && defined(HAVE_DOT11)
+#define TINS_DOT11_DOT11_AUTH_H
+
+#include "../dot11/dot11_mgmt.h"
+
+namespace Tins {
+/**
+ * \brief IEEE 802.11 Authentication Request frame.
+ */
+class Dot11Authentication : public Dot11ManagementFrame {
+public:
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::DOT11_AUTH;
+
+    /**
+     * \brief Constructor for creating a 802.11 Authentication.
+     *
+     * Constructs a 802.11 Dot11Authentication taking the 
+     * destination and source hardware address.
+     *
+     * \param dst_hw_addr The destination hardware address.
+     * \param src_hw_addr The source hardware address.
+     */
+    Dot11Authentication(const address_type &dst_hw_addr = address_type(), 
+                        const address_type &src_hw_addr = address_type());
+
+    /**
+     * \brief Constructs a Dot11Authentication object from a buffer 
+     * and adds all identifiable PDUs found in the buffer as children 
+     * of this one.
+     * 
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for the header in the buffer
+     * or the input data is malformed, a malformed_packet exception 
+     * is thrown.
+     *
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot11Authentication(const uint8_t *buffer, uint32_t total_sz);
+
+    /**
+     * \brief Getter for the Authetication Algorithm Number field.
+     *
+     * \return The stored authentication algorithm number.
+     */
+    uint16_t auth_algorithm() const {return Endian::le_to_host(_body.auth_algorithm); }
+
+    /**
+     * \brief Getter for the Authetication Sequence Number field.
+     *
+     * \return The stored authentication sequence number.
+     */
+    uint16_t auth_seq_number() const {return Endian::le_to_host(_body.auth_seq_number); }
+
+    /**
+     * \brief Getter for the status code field.
+     *
+     * \return The stored status code.
+     */
+    uint16_t status_code() const { return Endian::le_to_host(_body.status_code); }
+
+    /**
+     * \brief Setter for the Authetication Algorithm Number field.
+     *
+     * \param new_auth_algorithm The Authetication Algorithm Number 
+     * to be set.
+     */
+    void auth_algorithm(uint16_t new_auth_algorithm);
+
+    /**
+     * \brief Setter for the Authetication Sequence Number field.
+     *
+     * \param new_auth_seq_number The Authetication Sequence Number 
+     * to be set.
+     */
+    void auth_seq_number(uint16_t new_auth_seq_number);
+
+    /**
+     * \brief Setter for the status code field.
+     *
+     * \param new_status_code The status code to be set.
+     */
+    void status_code(uint16_t new_status_code);
+
+    /**
+     * \brief Returns the frame's header length.
+     *
+     * \return An uint32_t with the header's size.
+     * \sa PDU::header_size()
+     */
+    uint32_t header_size() const;
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     * \param flag The flag to match
+     * \sa PDU::matches_flag
+     */
+    bool matches_flag(PDUType flag) const {
+       return flag == pdu_flag || Dot11ManagementFrame::matches_flag(flag);
+    }
+
+    /**
+     * \brief Clones this PDU.
+     *
+     * \sa PDU::clone
+     */
+    Dot11Authentication *clone() const {
+        return new Dot11Authentication(*this);
+    }
+private:
+    struct AuthBody {
+        uint16_t auth_algorithm;
+        uint16_t auth_seq_number;
+        uint16_t status_code;
+    };
+
+    uint32_t write_fixed_parameters(uint8_t *buffer, uint32_t total_sz);
+
+    AuthBody _body;
+
+};
+
+/**
+ * \brief IEEE 802.11 Deauthentication frame.
+ *
+ */
+class Dot11Deauthentication : public Dot11ManagementFrame {
+public:
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::DOT11_DEAUTH;
+
+    /**
+     * \brief Constructor for creating a 802.11 Deauthentication.
+     *
+     * Constructs a 802.11 Deauthentication taking the 
+     * destination and source hardware address.
+     *
+     * \param dst_hw_addr The destination hardware address.
+     * \param src_hw_addr The source hardware address.
+     */
+    Dot11Deauthentication(const address_type &dst_hw_addr = address_type(), 
+                        const address_type &src_hw_addr = address_type());
+
+    /**
+     * \brief Constructs a Dot11Deauthentication object from a buffer 
+     * and adds all identifiable PDUs found in the buffer as children 
+     * of this one.
+     * 
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for the header in the buffer
+     * or the input data is malformed, a malformed_packet exception 
+     * is thrown.
+     *
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot11Deauthentication(const uint8_t *buffer, uint32_t total_sz);
+
+    /**
+     * \brief Getter for the reason code field.
+     *
+     * \return The reason code to be set.
+     */
+    uint16_t reason_code() const { return Endian::le_to_host(_body.reason_code); }
+
+    /**
+     * \brief Setter for the reason code field.
+     *
+     * \param new_reason_code The reason code to be set.
+     */
+    void reason_code(uint16_t new_reason_code);
+
+    /**
+     * \brief Returns the frame's header length.
+     *
+     * \return An uint32_t with the header's size.
+     * \sa PDU::header_size()
+     */
+    uint32_t header_size() const;
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     * \param flag The flag to match
+     * \sa PDU::matches_flag
+     */
+    bool matches_flag(PDUType flag) const {
+       return flag == pdu_flag || Dot11ManagementFrame::matches_flag(flag);
+    }
+
+    /**
+     * \brief Clones this PDU.
+     *
+     * \sa PDU::clone
+     */
+    Dot11Deauthentication *clone() const {
+        return new Dot11Deauthentication(*this);
+    }
+private:
+    struct DeauthBody {
+        uint16_t reason_code;
+    };
+
+    uint32_t write_fixed_parameters(uint8_t *buffer, uint32_t total_sz);
+
+    DeauthBody _body;
+};
+} // namespace Tins
+
+
+#endif // TINS_DOT11_DOT11_AUTH_H

include/dot11/dot11_base.h

@@ -0,0 +1,522 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */ 
+
+#include "../config.h"
+
+#if !defined(TINS_DOT11_DOT11_H) && defined(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"
+
+namespace Tins {
+class RSNInformation;
+
+/**
+ * \brief Class representing an 802.11 frame.
+ */
+class Dot11 : public PDU {
+public:
+    /**
+     * The type used to store hardware addresses.
+     */
+    typedef HWAddress<6> address_type;
+
+    /**
+     * \brief IEEE 802.11 options struct.
+     */
+    typedef PDUOption<uint8_t, Dot11> option;
+
+    /**
+     * The type used to store tagged options.
+     */
+    typedef std::list<option> options_type;
+
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::DOT11;
+
+    /**
+     * \brief Broadcast hardware address.
+     */
+    static const address_type BROADCAST;
+
+    /**
+     * The endianness used by Dot11.
+     */
+    static const endian_type endianness = LE;
+
+    /**
+     * \brief Enum for the different types of 802.11 frames.
+     *
+     */
+    enum Types {
+        MANAGEMENT = 0,
+        CONTROL = 1,
+        DATA = 2
+    };
+
+    /**
+     * \brief Enum for the different types of tagged options.
+     */
+    enum OptionTypes {
+        SSID,
+        SUPPORTED_RATES,
+        FH_SET,
+        DS_SET,
+        CF_SET,
+        TIM,
+        IBSS_SET,
+        COUNTRY,
+        HOPPING_PATTERN_PARAMS,
+        HOPPING_PATTERN_TABLE,
+        REQUEST_INFORMATION,
+        BSS_LOAD,
+        EDCA,
+        TSPEC,
+        TCLAS,
+        SCHEDULE,
+        CHALLENGE_TEXT,
+        POWER_CONSTRAINT = 32,
+        POWER_CAPABILITY,
+        TPC_REQUEST,
+        TPC_REPORT,
+        SUPPORTED_CHANNELS,
+        CHANNEL_SWITCH,
+        MEASUREMENT_REQUEST,
+        MEASUREMENT_REPORT,
+        QUIET,
+        IBSS_DFS,
+        ERP_INFORMATION,
+        TS_DELAY,
+        TCLAS_PROCESSING,
+        QOS_CAPABILITY = 46,
+        RSN = 48,
+        EXT_SUPPORTED_RATES = 50,
+        VENDOR_SPECIFIC = 221
+    };
+
+    /**
+     * \brief Enum for the different subtypes of 802.11 management frames.
+     *
+     */
+    enum ManagementSubtypes {
+        ASSOC_REQ = 0,
+        ASSOC_RESP = 1,
+        REASSOC_REQ = 2,
+        REASSOC_RESP = 3,
+        PROBE_REQ = 4,
+        PROBE_RESP = 5,
+        BEACON = 8,
+        ATIM = 9,
+        DISASSOC = 10,
+        AUTH = 11,
+        DEAUTH = 12
+    };
+
+    /**
+     * \brief Enum for the different subtypes of 802.11 control frames.
+     *
+     */
+    enum ControlSubtypes {
+        BLOCK_ACK_REQ = 8,
+        BLOCK_ACK = 9,
+        PS = 10,
+        RTS = 11,
+        CTS = 12,
+        ACK = 13,
+        CF_END = 14,
+        CF_END_ACK = 15
+    };
+
+    /**
+     * \brief Enum fro the different subtypes of 802.11 data frames.
+     *
+     */
+    enum DataSubtypes {
+        DATA_DATA = 0,
+        DATA_CF_ACK = 1,
+        DATA_CF_POLL = 2,
+        DATA_CF_ACK_POLL = 3,
+        DATA_NULL = 4,
+        CF_ACK = 5,
+        CF_POLL = 6,
+        CF_ACK_POLL = 7,
+        QOS_DATA_DATA = 8,
+        QOS_DATA_CF_ACK = 9,
+        QOS_DATA_CF_POLL = 10,
+        QOS_DATA_CF_ACK_POLL = 11,
+        QOS_DATA_NULL = 12
+    };
+    
+    /**
+     * \brief Constructs an 802.11 PDU.
+     *
+     * \param dst_hw_addr The destination hardware address.
+     */
+    Dot11(const address_type &dst_hw_addr = address_type());
+
+    /**
+     * \brief Constructs 802.11 PDU from a buffer and adds all 
+     * identifiable PDUs found in the buffer as children of this one.
+     * 
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for a 802.11 header in the 
+     * buffer, a malformed_packet exception is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot11(const uint8_t *buffer, uint32_t total_sz);
+
+    /**
+     * \brief Getter for the protocol version field.
+     *
+     * \return The stored protocol version field.
+     */
+    small_uint<2> protocol() const { return _header.control.protocol; }
+
+    /**
+     * \brief Getter for the Type field.
+     *
+     * \return The stored Type field.
+     */
+    small_uint<2> type() const { return _header.control.type; }
+
+    /**
+     * \brief Getter for the Subtype field.
+     *
+     * \return The stored Subtype field.
+     */
+    small_uint<4> subtype() const { return _header.control.subtype; }
+
+    /**
+     * \brief Getter for the To-DS field.
+     *
+     * \return The stored To-DS field.
+     */
+    small_uint<1> to_ds() const { return _header.control.to_ds; }
+
+    /**
+     * \brief Getter for the From-DS field.
+     *
+     * \return The stored From-DS field.
+     */
+    small_uint<1> from_ds() const { return _header.control.from_ds; }
+
+    /**
+     * \brief Getter for the More-Frag field.
+     *
+     * \return The stored More-Frag field.
+     */
+    small_uint<1> more_frag() const { return _header.control.more_frag; }
+
+    /**
+     * \brief Getter for the Retry field.
+     *
+     * \return The stored Retry field.
+     */
+    small_uint<1> retry() const { return _header.control.retry; }
+
+    /**
+     * \brief Getter for the Power-Management field.
+     *
+     * \return The stored Power-Management field.
+     */
+    small_uint<1> power_mgmt() const { return _header.control.power_mgmt; }
+
+    /**
+     * \brief Getter for the WEP field.
+     *
+     * \return The stored WEP field.
+     */
+    small_uint<1> wep() const { return _header.control.wep; }
+
+    /**
+     * \brief Getter for the Order field.
+     *
+     * \return The stored Order field.
+     */
+    small_uint<1> order() const { return _header.control.order; }
+
+    /**
+     * \brief Getter for the Duration-ID field.
+     *
+     * \return The stored Duration-ID field.
+     */
+    uint16_t duration_id() const { return Endian::le_to_host(_header.duration_id); }
+
+    /**
+     * \brief Getter for the first address.
+     *
+     * \return The stored first address.
+     */
+    address_type addr1() const { return _header.addr1; }
+
+    // Setters
+
+    /**
+     * \brief Setter for the protocol version field.
+     *
+     * \param new_proto The new protocol version field value.
+     */
+    void protocol(small_uint<2> new_proto);
+
+    /**
+     * \brief Setter for the type field.
+     *
+     * \param new_type The new type field value.
+     */
+    void type(small_uint<2> new_type);
+
+    /**
+     * \brief Setter for the subtype field.
+     *
+     * \param new_subtype The new subtype field value.
+     */
+    void subtype(small_uint<4> new_subtype);
+
+    /**
+     * \brief Setter for the To-DS field.
+     *
+     * \param new_value The new To-DS field value.
+     */
+    void to_ds(small_uint<1> new_value);
+
+    /**
+     * \brief Setter for the From-DS field.
+     *
+     * \param new_value The new From-DS field value.
+     */
+    void from_ds(small_uint<1> new_value);
+
+    /**
+     * \brief Setter for the More-Frag field.
+     *
+     * \param new_value The new More-Frag field value.
+     */
+    void more_frag(small_uint<1> new_value);
+
+    /**
+     * \brief Setter for the Retry field.
+     *
+     * \param new_value The new Retry field value.
+     */
+    void retry(small_uint<1> new_value);
+
+    /**
+     * \brief Setter for the Power-Management field.
+     *
+     * \param new_value The new Power-Management field value.
+     */
+    void power_mgmt(small_uint<1> new_value);
+
+    /**
+     * \brief Setter for the WEP field.
+     *
+     * \param new_value The new WEP field value.
+     */
+    void wep(small_uint<1> new_value);
+
+    /**
+     * \brief Setter for the Order field.
+     *
+     * \param new_value The new Order field value.
+     */
+    void order(small_uint<1> new_value);
+
+    /**
+     * \brief Setter for the Duration-ID field.
+     *
+     * \param new_duration_id The new Duration-ID field value.
+     */
+    void duration_id(uint16_t new_duration_id);
+
+    /**
+     * \brief Setter for the first address.
+     *
+     * \param new_addr1 The new first address.
+     */
+    void addr1(const address_type &new_addr1);
+
+    /* Virtual methods */
+    /**
+     * \brief Returns the 802.11 frame's header length.
+     *
+     * \return An uint32_t with the header's size.
+     * \sa PDU::header_size()
+     */
+    uint32_t header_size() const;
+    
+    #ifndef WIN32
+    /**
+     * \sa PDU::send()
+     */
+    void send(PacketSender &sender, const NetworkInterface &iface);
+    #endif // WIN32
+    
+    /**
+     * \brief Adds a new option to this Dot11 PDU.
+     * \param opt The option to be added.
+     */
+    void add_option(const option &opt);
+    
+    #if TINS_IS_CXX11
+        /**
+         * \brief Adds a new option to this Dot11 PDU.
+         * 
+         * The option is move-constructed
+         * 
+         * \param opt The option to be added.
+         */
+        void add_option(option &&opt) {
+            internal_add_option(opt);
+            _options.push_back(std::move(opt));
+        }
+    #endif
+
+    /**
+     * \brief Looks up a tagged option in the option list.
+     * 
+     * The returned pointer <b>must not</b> be free'd.
+     * 
+     * \param opt The option identifier.
+     * \return The option found, or 0 if no such option has been set.
+     */
+    const option *search_option(OptionTypes opt) const;
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+    
+    /**
+     * \sa PDU::clone
+     */
+    Dot11 *clone() const {
+        return new Dot11(*this);
+    }
+
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     * \param flag The flag to match
+     * \sa PDU::matches_flag
+     */
+    bool matches_flag(PDUType flag) const {
+       return flag == pdu_flag;
+    }
+    
+    /**
+     * \brief Getter for the option list.
+     * 
+     * \return The options list.
+     */
+    const options_type &options() const { return _options; }
+
+    /**
+     * \brief Allocates an Dot11 PDU from a buffer.
+     * 
+     * This can be used somehow as a "virtual constructor". This 
+     * method instantiates the appropriate subclass of Dot11 from the 
+     * given buffer.
+     * 
+     * The allocated class' type will be figured out from the
+     * information provided in the buffer.
+     * 
+     * \param buffer The buffer from which to take the PDU data.
+     * \param total_sz The total size of the buffer.
+     * \return The allocated Dot11 PDU.
+     */
+    static Dot11 *from_bytes(const uint8_t *buffer, uint32_t total_sz);
+protected:
+    virtual uint32_t write_ext_header(uint8_t *buffer, uint32_t total_sz) { return 0; }
+    virtual uint32_t write_fixed_parameters(uint8_t *buffer, uint32_t total_sz) { return 0; }
+    void parse_tagged_parameters(const uint8_t *buffer, uint32_t total_sz);
+    void add_tagged_option(OptionTypes opt, uint8_t len, const uint8_t *val);
+protected:
+    /**
+     * Struct that represents the 802.11 header
+     */
+    TINS_BEGIN_PACK
+    struct ieee80211_header {
+        TINS_BEGIN_PACK
+        struct {
+        #if TINS_IS_LITTLE_ENDIAN
+            uint16_t protocol:2,
+                    type:2,
+                    subtype:4,
+                    to_ds:1,
+                    from_ds:1,
+                    more_frag:1,
+                    retry:1,
+                    power_mgmt:1,
+                    more_data:1,
+                    wep:1,
+                    order:1;
+        #elif TINS_IS_BIG_ENDIAN
+            uint16_t subtype:4,
+                    type:2,
+                    protocol:2,
+                    order:1,
+                    wep:1,
+                    more_data:1,
+                    power_mgmt:1,
+                    retry:1,
+                    more_frag:1,
+                    from_ds:1,
+                    to_ds:1;
+        #endif
+        } TINS_END_PACK control;
+        uint16_t duration_id;
+        uint8_t addr1[address_type::address_size];
+
+    } TINS_END_PACK;
+private:
+    Dot11(const ieee80211_header *header_ptr);
+    
+    void internal_add_option(const option &opt);
+    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
+
+
+    ieee80211_header _header;
+    uint32_t _options_size;
+    options_type _options;
+};
+}
+
+#endif // TINS_DOT11_DOT11_H

include/dot11/dot11_beacon.h

@@ -0,0 +1,166 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */    
+
+#include "../config.h"
+
+#if !defined(TINS_DOT11_DOT11_BEACON_H) && defined(HAVE_DOT11)
+#define TINS_DOT11_DOT11_BEACON_H
+
+#include "../dot11/dot11_mgmt.h"
+
+namespace Tins {
+    /**
+     * \brief Class representing an 802.11 Beacon.
+     *
+     */
+    class Dot11Beacon : public Dot11ManagementFrame {
+    public:
+        /**
+         * \brief This PDU's flag.
+         */
+        static const PDU::PDUType pdu_flag = PDU::DOT11_BEACON;
+
+        /**
+         * \brief Constructor for creating a 802.11 Beacon.
+         *
+         * Constructs a 802.11 Beacon taking destination and source 
+         * hardware address.
+         *
+         * \param dst_hw_addr The destination hardware address.
+         * \param src_hw_addr The source hardware address.
+         */
+        Dot11Beacon(const address_type &dst_hw_addr = address_type(), 
+                    const address_type &src_hw_addr = address_type());
+
+        /**
+         * \brief Constructs a Dot11Beacon object from a buffer and adds
+         * all identifiable PDUs found in the buffer as children of this 
+         * one.
+         *
+         * If the next PDU is not recognized, then a RawPDU is used.
+         * 
+         * If there is not enough size for the header in the buffer
+         * or the input data is malformed, a malformed_packet exception 
+         * is thrown.
+         * 
+         * \param buffer The buffer from which this PDU will be constructed.
+         * \param total_sz The total size of the buffer.
+         */
+        Dot11Beacon(const uint8_t *buffer, uint32_t total_sz);
+
+        /**
+         * \brief Getter for the timestamp field.
+         *
+         * \return The stored timestamp value.
+         */
+        uint64_t timestamp() const { return Endian::le_to_host(_body.timestamp); }
+
+        /**
+         * \brief Getter for the interval field.
+         *
+         * \return The stored interval value.
+         */
+        uint16_t interval() const { return Endian::le_to_host(_body.interval); }
+
+        /**
+         * \brief Getter for the Capabilities Information structure.
+         *
+         * \return A constant refereence to the stored Capabilities 
+         * Information field.
+         */
+        const capability_information& capabilities() const { return _body.capability; }
+
+        /**
+         * \brief Getter for the Capabilities Information.
+         *
+         * \return A refereence to the stored Capabilities Information 
+         * field.
+         */
+        capability_information& capabilities() { return _body.capability; }
+
+        /**
+         * \brief Setter for the timestamp field.
+         *
+         * \param new_timestamp The timestamp to be set.
+         */
+        void timestamp(uint64_t new_timestamp);
+
+        /**
+         * \brief Setter for the interval field.
+         *
+         * \param new_interval The interval to be set.
+         */
+        void interval(uint16_t new_interval);
+
+        /**
+         * \brief Returns the frame's header length.
+         *
+         * \return An uint32_t with the header's size.
+         * \sa PDU::header_size()
+         */
+        uint32_t header_size() const;
+
+        /**
+         * \brief Check wether this PDU matches the specified flag.
+         * \param flag The flag to match
+         * \sa PDU::matches_flag
+         */
+        bool matches_flag(PDUType flag) const {
+           return flag == pdu_flag || Dot11ManagementFrame::matches_flag(flag);
+        }
+
+        /**
+         * \brief Clones this PDU.
+         *
+         * \sa PDU::clone
+         */
+        Dot11Beacon *clone() const {
+            return new Dot11Beacon(*this);
+        }
+
+        /**
+         * \brief Getter for the PDU's type.
+         * \sa PDU::pdu_type
+         */
+        PDUType pdu_type() const { return pdu_flag; }
+    private:
+        TINS_BEGIN_PACK
+        struct BeaconBody {
+            uint64_t timestamp;
+            uint16_t interval;
+            capability_information capability;
+        } TINS_END_PACK;
+
+        uint32_t write_fixed_parameters(uint8_t *buffer, uint32_t total_sz);
+
+        BeaconBody _body;
+    };
+} // namespace Tins
+
+#endif // TINS_DOT11_DOT11_BEACON_H

include/dot11/dot11_control.h

@@ -0,0 +1,746 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "../config.h"
+
+#if !defined(TINS_DOT11_DOT11_CONTROL_H) && defined(HAVE_DOT11)
+
+#define TINS_DOT11_DOT11_CONTROL_H
+
+#include "../dot11/dot11_base.h"
+
+namespace Tins {
+/**
+ * \brief Class that represents an 802.11 control frame.
+ */
+class Dot11Control : public Dot11 {
+public:
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::DOT11_CONTROL;
+    
+    /**
+     * \brief Constructor for creating a 802.11 control frame PDU
+     *
+     * Constructs a 802.11 Control PDU taking the destination and 
+     * source hardware addresses.
+     *
+     * \param dst_addr The destination hardware address.
+     */
+    Dot11Control(const address_type &dst_addr = address_type());
+
+    /**
+     * \brief Constructs a Dot11Control object from a buffer and
+     * adds all identifiable PDUs found in the buffer as children 
+     * of this one.
+     * 
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for the header in the buffer
+     * or the input data is malformed, a malformed_packet exception 
+     * is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot11Control(const uint8_t *buffer, uint32_t total_sz);
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return PDU::DOT11_CONTROL; }
+
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     * \param flag The flag to match
+     * \sa PDU::matches_flag
+     */
+    bool matches_flag(PDUType flag) const {
+       return flag == PDU::DOT11_CONTROL || Dot11::matches_flag(flag);
+    }
+};
+
+/**
+ * \brief Class that represents an abstraction of the 802.11 control frames
+ * that contain a target address.
+ */
+class Dot11ControlTA : public Dot11Control {
+public:
+    /**
+     * \brief Getter for the target address field.
+     */
+    address_type target_addr() const { return _taddr; }
+
+    /**
+     * \brief Setter for the target address field.
+     * \param addr The new target address.
+     */
+    void target_addr(const address_type &addr);
+protected:
+    /**
+     * \brief Constructor for creating a 802.11 control frame TA PDU
+     *
+     * Constructs a 802.11 PDU taking the destination and source 
+     * hardware addresses.
+     *
+     * \param dst_addr The destination hardware address.
+     * \param target_addr The source hardware address.
+     */
+    Dot11ControlTA(const address_type &dst_addr = address_type(), 
+                const address_type &target_addr = address_type());
+
+    /**
+     * \brief Constructs a Dot11ControlTA object from a buffer and
+     * adds all identifiable PDUs found in the buffer as children 
+     * of this one.
+     * 
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for the header in the buffer
+     * or the input data is malformed, a malformed_packet exception 
+     * is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot11ControlTA(const uint8_t *buffer, uint32_t total_sz);
+
+    /**
+     * \brief Returns the 802.11 frame's header length.
+     *
+     * \return An uint32_t with the header's size.
+     * \sa PDU::header_size()
+     */
+    uint32_t header_size() const;
+protected:
+    /**
+     * \brief Getter for the control ta additional fields size.
+     */
+    uint32_t controlta_size() const { return _taddr.size() + sizeof(ieee80211_header); }
+
+    uint32_t write_ext_header(uint8_t *buffer, uint32_t total_sz);
+private:
+
+    address_type _taddr;
+};
+
+/**
+ * \brief IEEE 802.11 RTS frame.
+ */
+class Dot11RTS : public Dot11ControlTA {
+public:
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::DOT11_RTS;
+
+    /**
+     * \brief Constructor for creating a 802.11 RTS frame PDU
+     *
+     * Constructs a 802.11 RTS PDU taking the destination and source
+     * hardware addresses.
+     *
+     * \param dst_addr The destination hardware address.
+     * \param target_addr The source hardware address.
+     */
+    Dot11RTS(const address_type &dst_addr = address_type(), 
+            const address_type &target_addr = address_type());
+                
+    /**
+     * \brief Constructs a Dot11RTS object from a buffer and adds all 
+     * identifiable PDUs found in the buffer as children of this one.
+     * 
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for the header in the buffer
+     * or the input data is malformed, a malformed_packet exception 
+     * is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot11RTS(const uint8_t *buffer, uint32_t total_sz);
+
+    /**
+     * \brief Clones this PDU.
+     *
+     * \sa PDU::clone
+     */
+    Dot11RTS *clone() const {
+        return new Dot11RTS(*this);
+    }
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     * \param flag The flag to match
+     * \sa PDU::matches_flag
+     */
+    bool matches_flag(PDUType flag) const {
+       return flag == pdu_flag || Dot11Control::matches_flag(flag);
+    }
+};
+
+class Dot11PSPoll : public Dot11ControlTA {
+public:
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::DOT11_PS_POLL;
+
+    /**
+     * \brief Constructor for creating a 802.11 PS-Poll frame PDU
+     *
+     * Constructs a 802.11 PDU taking the destination and source 
+     * hardware addresses.
+     *
+     * \param dst_addr The destination hardware address.
+     * \param target_addr The source hardware address.
+     */
+    Dot11PSPoll(const address_type &dst_addr = address_type(), 
+                const address_type &target_addr = address_type());
+
+    /**
+     * \brief Constructs a Dot11PSPoll object from a buffer and
+     * adds all identifiable PDUs found in the buffer as children of 
+     * this one.
+     * 
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for the header in the buffer
+     * or the input data is malformed, a malformed_packet exception 
+     * is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot11PSPoll(const uint8_t *buffer, uint32_t total_sz);
+
+    /**
+     * \brief Clones this PDU.
+     *
+     * \sa PDU::clone
+     */
+    Dot11PSPoll *clone() const {
+        return new Dot11PSPoll(*this);
+    }
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     * \param flag The flag to match
+     * \sa PDU::matches_flag
+     */
+    bool matches_flag(PDUType flag) const {
+       return flag == pdu_flag || Dot11Control::matches_flag(flag);
+    }
+};
+
+class Dot11CFEnd : public Dot11ControlTA {
+public:
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::DOT11_CF_END;
+
+    /**
+     * \brief Constructor for creating a 802.11 CF-End frame PDU
+     *
+     * Constructs a 802.11 PDU taking the destination and source 
+     * hardware addresses.
+     *
+     * \param dst_addr The destination hardware address.
+     * \param target_addr The source hardware address.
+     */
+    Dot11CFEnd(const address_type &dst_addr = address_type(), 
+            const address_type &target_addr = address_type());
+                
+    /**
+     * \brief Constructs a Dot11CFEnd object from a buffer and adds 
+     * all identifiable PDUs found in the buffer as children of this 
+     * one.
+     * 
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for the header in the buffer
+     * or the input data is malformed, a malformed_packet exception 
+     * is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot11CFEnd(const uint8_t *buffer, uint32_t total_sz);
+
+    /**
+     * \brief Clones this PDU.
+     *
+     * \sa PDU::clone
+     */
+    Dot11CFEnd *clone() const {
+        return new Dot11CFEnd(*this);
+    }
+
+     /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     * \param flag The flag to match
+     * \sa PDU::matches_flag
+     */
+    bool matches_flag(PDUType flag) const {
+       return flag == pdu_flag || Dot11Control::matches_flag(flag);
+    }
+};
+
+class Dot11EndCFAck : public Dot11ControlTA {
+public:
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::DOT11_END_CF_ACK;
+
+    /**
+     * \brief Constructor for creating a 802.11 End-CF-Ack frame PDU
+     *
+     * Constructs a 802.11 PDU taking the destination and source 
+     * hardware addresses.
+     * 
+     * \param dst_addr The destination hardware address.
+     * \param target_addr The source hardware address.
+     */
+    Dot11EndCFAck(const address_type &dst_addr = address_type(), 
+                const address_type &target_addr = address_type());
+
+    /**
+     * \brief Constructs a Dot11EndCFAck frame object from a buffer 
+     * and adds all identifiable PDUs found in the buffer as children 
+     * of this one.
+     * 
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for the header in the buffer
+     * or the input data is malformed, a malformed_packet exception 
+     * is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot11EndCFAck(const uint8_t *buffer, uint32_t total_sz);
+
+    /**
+     * \brief Clones this PDU.
+     *
+     * \sa PDU::clone
+     */
+    Dot11EndCFAck *clone() const {
+        return new Dot11EndCFAck(*this);
+    }
+
+     /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     * \param flag The flag to match
+     * \sa PDU::matches_flag
+     */
+    bool matches_flag(PDUType flag) const {
+       return flag == pdu_flag || Dot11Control::matches_flag(flag);
+    }
+};
+
+class Dot11Ack : public Dot11Control {
+public:
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::DOT11_ACK;
+
+    /**
+     * \brief Constructor for creating a 802.11 Ack frame PDU
+     *
+     * Constructs a 802.11 PDU taking the destination and source 
+     * hardware addresses.
+     *
+     * \param dst_addr The destination hardware address.
+     */
+    Dot11Ack(const address_type &dst_addr = address_type());
+
+    /**
+     * \brief Constructs a Dot11Ack frame object from a buffer and
+     * adds all identifiable PDUs found in the buffer as children of 
+     * this one.
+     * 
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for the header in the buffer
+     * or the input data is malformed, a malformed_packet exception 
+     * is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot11Ack(const uint8_t *buffer, uint32_t total_sz);
+
+    /**
+     * \brief Clones this PDU.
+     *
+     * \sa PDU::clone
+     */
+    Dot11Ack *clone() const {
+        return new Dot11Ack(*this);
+    }
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     * \param flag The flag to match
+     * \sa PDU::matches_flag
+     */
+    bool matches_flag(PDUType flag) const {
+       return flag == pdu_flag || Dot11Control::matches_flag(flag);
+    }
+};
+
+/**
+ * \brief Class that represents an 802.11 Block Ack Request PDU.
+ */
+class Dot11BlockAckRequest : public Dot11ControlTA {
+public:
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::DOT11_BLOCK_ACK_REQ;
+
+    /**
+     * \brief Constructor for creating a 802.11 Block Ack request frame PDU
+     *
+     * Constructs a 802.11 PDU taking the destination and source 
+     * hardware addresses.
+     * 
+     * \param dst_addr The destination hardware address.
+     * \param target_addr The source hardware address.
+     */
+    Dot11BlockAckRequest(const address_type &dst_addr = address_type(), 
+                        const address_type &target_addr = address_type());
+
+    /**
+     * \brief Constructs a Dot11BlockAckRequest object from a buffer 
+     * and adds all identifiable PDUs found in the buffer as children 
+     * of this one.
+     * 
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for the header in the buffer
+     * or the input data is malformed, a malformed_packet exception 
+     * is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot11BlockAckRequest(const uint8_t *buffer, uint32_t total_sz);
+
+    /* Getter */
+
+    /**
+     * \brief Getter for the bar control field.
+     * \return The stored bar control field.
+     */
+    small_uint<4> bar_control() const { 
+        #if TINS_IS_LITTLE_ENDIAN
+        return _bar_control & 0xf; 
+        #else
+        return (_bar_control >> 8) & 0xf; 
+        #endif
+    }
+
+    /**
+     * \brief Getter for the start sequence field.
+     * \return The stored start sequence.
+     */
+    small_uint<12> start_sequence() const { 
+        #if TINS_IS_LITTLE_ENDIAN
+        return (_start_sequence >> 4) & 0xfff; 
+        #else
+        return (Endian::le_to_host<uint16_t>(_start_sequence) >> 4) & 0xfff; 
+        #endif
+    }
+    
+    /**
+     * \brief Getter for the fragment number field.
+     * \return The stored fragment number field.
+     */
+    small_uint<4> fragment_number() const { 
+        #if TINS_IS_LITTLE_ENDIAN
+        return _start_sequence & 0xf; 
+        #else
+        return (_start_sequence >> 8) & 0xf; 
+        #endif
+    }
+    
+    /**
+     * \brief Returns the 802.11 frame's header length.
+     *
+     * \return The header's size.
+     * \sa PDU::header_size()
+     */
+    uint32_t header_size() const;
+
+    /* Setter */
+
+    /**
+     * \brief Setter for the bar control field.
+     * \param bar The bar control field to be set.
+     */
+    void bar_control(small_uint<4> bar);
+
+    /**
+     * \brief Setter for the start sequence field.
+     * \param bar The start sequence field to be set.
+     */
+    void start_sequence(small_uint<12> seq);
+    
+    /**
+     * \brief Setter for the fragment number field.
+     * \param frag The fragment number field to be set.
+     */
+    void fragment_number(small_uint<4> frag);
+
+    /**
+     * \brief Clones this PDU.
+     *
+     * \sa PDU::clone
+     */
+    Dot11BlockAckRequest *clone() const {
+        return new Dot11BlockAckRequest(*this);
+    }
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     * \param flag The flag to match
+     * \sa PDU::matches_flag
+     */
+    bool matches_flag(PDUType flag) const {
+       return flag == pdu_flag || Dot11Control::matches_flag(flag);
+    }
+protected:
+    uint32_t write_ext_header(uint8_t *buffer, uint32_t total_sz);
+private:
+    void init_block_ack();
+
+    uint16_t _bar_control;
+    uint16_t _start_sequence;
+};
+
+/**
+ * \brief Class that represents an 802.11 block ack frame.
+ */
+class Dot11BlockAck : public Dot11ControlTA {
+public:
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::DOT11_BLOCK_ACK;
+    
+    /**
+     * The size of the bitmap field.
+     */
+    static const size_t bitmap_size = 8;
+
+    /**
+     * \brief Constructor for creating a 802.11 Block Ack frame PDU
+     *
+     * Constructs a 802.11 PDU taking the destination and source 
+     * hardware addresses.
+     * 
+     * \param dst_addr The destination hardware address.
+     * \param target_addr The source hardware address.
+     */
+    Dot11BlockAck(const address_type &dst_addr = address_type(), 
+                const address_type &target_addr = address_type());
+
+    /**
+     * \brief Constructs a Dot11BlockAck frame object from a buffer 
+     * and adds all identifiable PDUs found in the buffer as children 
+     * of this one.
+     * 
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for the header in the buffer
+     * or the input data is malformed, a malformed_packet exception 
+     * is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot11BlockAck(const uint8_t *buffer, uint32_t total_sz);
+
+    /* Getters */
+
+    /**
+     * \brief Getter for the bar control field.
+     * \return The stored bar control field.
+     */
+    small_uint<4> bar_control() const { 
+        #if TINS_IS_LITTLE_ENDIAN
+        return _bar_control & 0xf; 
+        #else
+        return (_bar_control >> 8) & 0xf; 
+        #endif
+    }
+
+    /**
+     * \brief Getter for the start sequence field.
+     * \return The stored start sequence.
+     */
+    small_uint<12> start_sequence() const { 
+        #if TINS_IS_LITTLE_ENDIAN
+        return (_start_sequence >> 4) & 0xfff; 
+        #else
+        return (Endian::le_to_host<uint16_t>(_start_sequence) >> 4) & 0xfff; 
+        #endif
+    }
+    
+    /**
+     * \brief Getter for the fragment number field.
+     * \return The stored fragment number field.
+     */
+    small_uint<4> fragment_number() const { 
+        #if TINS_IS_LITTLE_ENDIAN
+        return _start_sequence & 0xf; 
+        #else
+        return (_start_sequence >> 8) & 0xf; 
+        #endif
+    }
+    
+    /**
+     * \brief Returns the 802.11 frame's header length.
+     *
+     * \return An uint32_t with the header's size.
+     * \sa PDU::header_size()
+     */
+    uint32_t header_size() const;
+
+    /* Setters */
+
+    /**
+     * \brief Setter for the bar control field.
+     * \param bar The bar control field to be set.
+     */
+    void bar_control(small_uint<4> bar);
+
+    /**
+     * \brief Setter for the start sequence field.
+     * \param bar The start sequence field to be set.
+     */
+    void start_sequence(small_uint<12> seq);
+    
+    /**
+     * \brief Setter for the fragment number field.
+     * \param frag The fragment number field to be set.
+     */
+    void fragment_number(small_uint<4> frag);
+
+    /**
+     * \brief Getter for the bitmap field.
+     * 
+     * The returned pointer <b>must not</b> be free'd.
+     * 
+     * \return The bitmap field.
+     */
+    const uint8_t *bitmap() const { return _bitmap; }
+
+    /**
+     * \brief Setter for the bitmap field.
+     * \param bit The new bitmap field to be set.
+     */
+    void bitmap(const uint8_t *bit);
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     * \param flag The flag to match
+     * \sa PDU::matches_flag
+     */
+    bool matches_flag(PDUType flag) const {
+       return flag == pdu_flag || Dot11Control::matches_flag(flag);
+    }
+
+    /**
+     * \brief Clones this PDU.
+     *
+     * \sa PDU::clone
+     */
+    Dot11BlockAck *clone() const {
+        return new Dot11BlockAck(*this);
+    }
+private:
+    void init_block_ack();
+    uint32_t write_ext_header(uint8_t *buffer, uint32_t total_sz);
+
+    uint16_t _bar_control, _start_sequence;
+    uint8_t _bitmap[bitmap_size];
+};
+} // namespace Tins
+#endif // TINS_DOT11_DOT11_CONTROL_H

include/dot11/dot11_data.h

@@ -0,0 +1,345 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "../config.h"
+
+#if !defined(TINS_DOT11_DOT11_DATA_H) && defined(HAVE_DOT11)
+#define TINS_DOT11_DOT11_DATA_H
+
+#include "../dot11/dot11_base.h"
+
+namespace Tins {
+class Dot11Data : public Dot11 {
+public:
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::DOT11_DATA;
+    
+    /**
+     * \brief Constructor for creating a 802.11 Data frame.
+     *
+     * Constructs a 802.11 Data frame taking the
+     * destination and source hardware addresses.
+     *
+     * \param dst_hw_addr The destination hardware address.
+     * \param src_hw_addr The source hardware address.
+     */
+    Dot11Data(const address_type &dst_hw_addr = address_type(), 
+            const address_type &src_hw_addr = address_type());
+                
+    /**
+     * \brief Constructs a Dot11Data object from a buffer and adds 
+     * all identifiable PDUs found in the buffer as children of 
+     * this one.
+     * 
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for the header in the buffer
+     * or the input data is malformed, a malformed_packet exception 
+     * is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot11Data(const uint8_t *buffer, uint32_t total_sz);
+    
+    /**
+     * \brief Getter for the second address.
+     *
+     * \return The stored second address.
+     */
+    address_type addr2() const { return _ext_header.addr2; }
+
+    /**
+     * \brief Getter for the third address.
+     *
+     * \return The stored third address.
+     */
+    address_type addr3() const { return _ext_header.addr3; }
+
+    /**
+     * \brief Getter for the fragment number field.
+     *
+     * \return The stored fragment number.
+     */
+    small_uint<4> frag_num() const { 
+        #if TINS_IS_LITTLE_ENDIAN
+        return _ext_header.frag_seq & 0xf; 
+        #else
+        return (_ext_header.frag_seq >> 8) & 0xf; 
+        #endif
+    }
+
+    /**
+     * \brief Getter for the sequence number field.
+     *
+     * \return The stored sequence number.
+     */
+    small_uint<12> seq_num() const { 
+        #if TINS_IS_LITTLE_ENDIAN
+        return (_ext_header.frag_seq >> 4) & 0xfff; 
+        #else
+        return (Endian::le_to_host<uint16_t>(_ext_header.frag_seq) >> 4) & 0xfff; 
+        #endif
+    }
+
+    /**
+     * \brief Getter for the fourth address.
+     *
+     * \return The fourth address.
+     */
+    address_type addr4() const { return _addr4; }
+
+    /**
+     * \brief Setter for the second address.
+     *
+     * \param new_addr2 The second address to be set.
+     */
+    void addr2(const address_type &new_addr2);
+
+    /**
+     * \brief Setter for the third address.
+     *
+     * \param new_addr3 The third address to be set.
+     */
+    void addr3(const address_type &new_addr3);
+
+    /**
+     * \brief Setter for the fragment number field.
+     *
+     * \param new_frag_num The fragment number to be set.
+     */
+    void frag_num(small_uint<4> new_frag_num);
+
+    /**
+     * \brief Setter for the sequence number field.
+     *
+     * \param new_seq_num The sequence number to be set.
+     */
+    void seq_num(small_uint<12> new_seq_num);
+
+    /**
+     * \brief Setter for the fourth address field.
+     *
+     * \param new_addr4 The fourth address to be set.
+     */
+    void addr4(const address_type &new_addr4);
+
+    /**
+     * \brief Retrieves the frame's source address.
+     *
+     * This is a wrapper over the addr* member functions which
+     * takes into account the value of the FromDS and ToDS bits.
+     *
+     * If FromDS == ToDS == 1, the return value is not defined.
+     */
+    address_type src_addr() const {
+        if(!from_ds() && !to_ds())
+            return addr2();
+        if(!from_ds() && to_ds())
+            return addr2();
+        return addr3();
+    }
+
+    /**
+     * \brief Retrieves the frame's destination address.
+     *
+     * This is a wrapper over the addr* member functions which
+     * takes into account the value of the FromDS and ToDS bits.
+     *
+     * If FromDS == ToDS == 1, the return value is not defined.
+     */
+    address_type dst_addr() const {
+        if(!from_ds() && !to_ds())
+            return addr1();
+        if(!from_ds() && to_ds())
+            return addr3();
+        return addr1();
+    }
+
+    /**
+     * \brief Retrieves the frame's BSSID address.
+     *
+     * This is a wrapper over the addr* member functions which
+     * takes into account the value of the FromDS and ToDS bits.
+     *
+     * If FromDS == ToDS == 1, the return value is not defined.
+     */
+    address_type bssid_addr() const {
+        if(!from_ds() && !to_ds())
+            return addr3();
+        if(!from_ds() && to_ds())
+            return addr1();
+        return addr2();
+    }
+
+    /**
+     * \brief Returns the 802.11 frame's header length.
+     *
+     * \return An uint32_t with the header's size.
+     * \sa PDU::header_size()
+     */
+    uint32_t header_size() const;
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     * \param flag The flag to match
+     * \sa PDU::matches_flag
+     */
+    bool matches_flag(PDUType flag) const {
+       return flag == pdu_flag || Dot11::matches_flag(flag);
+    }
+
+    /**
+     * \brief Clones this PDU.
+     *
+     * \sa PDU::clone
+     */
+    Dot11Data *clone() const {
+        return new Dot11Data(*this);
+    }
+protected:
+    TINS_BEGIN_PACK
+    struct ExtendedHeader {
+        uint8_t addr2[address_type::address_size];
+        uint8_t addr3[address_type::address_size];
+        uint16_t frag_seq;
+    } TINS_END_PACK;
+    
+    struct no_inner_pdu { };
+    Dot11Data(const uint8_t *buffer, uint32_t total_sz, no_inner_pdu);
+
+    uint32_t init(const uint8_t *buffer, uint32_t total_sz);
+    uint32_t write_ext_header(uint8_t *buffer, uint32_t total_sz);
+
+    uint32_t data_frame_size() { 
+        return Dot11::header_size() + sizeof(_ext_header) + 
+            ((from_ds() && to_ds()) ? _addr4.size() : 0); 
+    }
+private:
+    ExtendedHeader _ext_header;
+    address_type _addr4;
+};
+
+class Dot11QoSData : public Dot11Data {
+public:
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::DOT11_QOS_DATA;
+
+    /**
+     * \brief Constructor for creating a 802.11 QoS Data PDU
+     *
+     * Constructs a 802.11 QoS Data PDU taking the
+     * destination and source hardware addresses.
+     *
+     * \param dst_hw_addr The destination hardware address.
+     * \param src_hw_addr The source hardware address.
+     */
+    Dot11QoSData(const address_type &dst_hw_addr = address_type(), 
+                const address_type &src_hw_addr = address_type());
+
+    /**
+     * \brief Constructors Dot11QoSData object from a buffer and adds
+     * all identifiable PDUs found in the buffer as children of this 
+     * one.
+     * 
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for the header in the buffer
+     * or the input data is malformed, a malformed_packet exception 
+     * is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot11QoSData(const uint8_t *buffer, uint32_t total_sz);
+    
+    /**
+     * \brief Getter for the QOS Control field.
+     *
+     * \return The stored QOS Control field value.
+     */
+    uint16_t qos_control() const { return Endian::le_to_host(_qos_control); }
+
+    /**
+     * \brief Setter for the QOS Control field.
+     *
+     * \param new_qos_control The QOS Control to be set.
+     */
+    void qos_control(uint16_t new_qos_control);
+
+    /**
+     * \brief Returns the frame's header length.
+     *
+     * \return An uint32_t with the header's size.
+     * \sa PDU::header_size()
+     */
+    uint32_t header_size() const;
+
+    /**
+     * \brief Clones this PDU.
+     *
+     * \sa PDU::clone
+     */
+    Dot11QoSData *clone() const {
+        return new Dot11QoSData(*this);
+    }
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return PDU::DOT11_QOS_DATA; }
+
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     * \param flag The flag to match
+     * \sa PDU::matches_flag
+     */
+    bool matches_flag(PDUType flag) const {
+       return flag == PDU::DOT11_QOS_DATA || Dot11Data::matches_flag(flag);
+    }
+private:
+    uint32_t write_fixed_parameters(uint8_t *buffer, uint32_t total_sz);
+
+
+    uint16_t _qos_control;
+};
+}
+
+#endif // TINS_DOT11_DOT11_DATA_H

include/dot11/dot11_probe.h

@@ -0,0 +1,233 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "../config.h"
+
+#if !defined(TINS_DOT11_DOT11_PROBE_H) && defined(HAVE_DOT11)
+
+#define TINS_DOT11_DOT11_PROBE_H
+
+#include "../dot11/dot11_mgmt.h"
+
+namespace Tins {
+/**
+ * \brief Class representing an Probe Request frame in the IEEE 802.11 Protocol.
+ *
+ */
+class Dot11ProbeRequest : public Dot11ManagementFrame {
+public:
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::DOT11_PROBE_REQ;
+
+    /**
+     * \brief Constructor for creating a 802.11 Probe Request.
+     *
+     * Constructs a 802.11 Probe Request taking the 
+     * destination and source hardware address.
+     *
+     * \param dst_hw_addr The destination hardware address.
+     * \param src_hw_addr The source hardware address.
+     */
+    Dot11ProbeRequest(const address_type &dst_hw_addr = address_type(), 
+                    const address_type &src_hw_addr = address_type());
+
+    /**
+     * \brief Constructs a Dot11ProbeRequest object from a buffer 
+     * and adds all identifiable PDUs found in the buffer as children 
+     * of this one.
+     * 
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for the header in the buffer
+     * or the input data is malformed, a malformed_packet exception 
+     * is thrown.
+     *
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot11ProbeRequest(const uint8_t *buffer, uint32_t total_sz);
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return PDU::DOT11_PROBE_REQ; }
+
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     * \param flag The flag to match
+     * \sa PDU::matches_flag
+     */
+    bool matches_flag(PDUType flag) const {
+       return flag == pdu_flag || Dot11ManagementFrame::matches_flag(flag);
+    }
+
+    /**
+     * \brief Clones this PDU.
+     *
+     * \sa PDU::clone()
+     */
+    Dot11ProbeRequest* clone() const {
+        return new Dot11ProbeRequest(*this);
+    }
+
+};
+
+/**
+ * \brief Class representing an Probe Response frame in the IEEE 802.11 Protocol.
+ *
+ */
+class Dot11ProbeResponse : public Dot11ManagementFrame {
+public:
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::DOT11_PROBE_RESP;
+
+    /**
+     * \brief Constructor for creating a 802.11 Probe Response.
+     *
+     * Constructs a 802.11 Probe Response taking the
+     * destination and source hardware addresses.
+     *
+     * \param dst_hw_addr The destination hardware address.
+     * \param src_hw_addr The source hardware address.
+     */
+    Dot11ProbeResponse(const address_type &dst_hw_addr = address_type(), 
+                    const address_type &src_hw_addr = address_type());
+
+    /**
+     * \brief Constructs a Dot11ProbeResponse object from a buffer 
+     * and adds all identifiable PDUs found in the buffer as children 
+     * of this one.
+     * 
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for the header in the buffer
+     * or the input data is malformed, a malformed_packet exception 
+     * is thrown.
+     *
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot11ProbeResponse(const uint8_t *buffer, uint32_t total_sz);
+
+    /**
+     * \brief Getter for the timestamp field.
+     *
+     * \return The stored timestamp value.
+     */
+    uint64_t timestamp() const { return Endian::le_to_host(_body.timestamp); }
+
+    /**
+     * \brief Getter for the interval field.
+     *
+     * \return The stored interval value.
+     */
+    uint16_t interval() const { return Endian::le_to_host(_body.interval); }
+
+    /**
+     * \brief Getter for the Capabilities Information.
+     *
+     * \return A constant reference to the stored Capabilities 
+     * Information field.
+     */
+    const capability_information& capabilities() const { return _body.capability;}
+
+    /**
+     * \brief Getter for the Capabilities Information.
+     *
+     * \return A reference to the stored Capabilities Information 
+     * field.
+     */
+    capability_information& capabilities() { return _body.capability;}
+
+    /**
+     * \brief Setter for the timestamp field.
+     *
+     * \param new_timestamp The timestamp to be set.
+     */
+    void timestamp(uint64_t new_timestamp);
+
+    /**
+     * \brief Setter for the interval field.
+     *
+     * \param new_interval The interval to be set.
+     */
+    void interval(uint16_t new_interval);
+
+    /**
+     * \brief Returns the frame's header length.
+     *
+     * \return An uint32_t with the header's size.
+     * \sa PDU::header_size()
+     */
+    uint32_t header_size() const;
+
+    /**
+     * \brief Clones this PDU.
+     *
+     * \sa PDU::clone()
+     */
+    Dot11ProbeResponse* clone() const {
+        return new Dot11ProbeResponse(*this);
+    }
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     * \param flag The flag to match
+     * \sa PDU::matches_flag
+     */
+    bool matches_flag(PDUType flag) const {
+       return flag == pdu_flag || Dot11ManagementFrame::matches_flag(flag);
+    }
+protected:
+
+private:
+    TINS_BEGIN_PACK
+    struct ProbeResp {
+        uint64_t timestamp;
+        uint16_t interval;
+        capability_information capability;
+    } TINS_END_PACK;
+
+    ProbeResp _body;
+
+    uint32_t write_fixed_parameters(uint8_t *buffer, uint32_t total_sz);
+};
+} // namespace Tins
+#endif // TINS_DOT11_DOT11_PROBE_H

include/dot1q.h

@@ -0,0 +1,212 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_DOT1Q_H
+#define TINS_DOT1Q_H
+
+#include "pdu.h"
+#include "endianness.h"
+#include "small_uint.h"
+
+namespace Tins {
+/**
+ * Represents an IEEE 802.1q PDU.
+ */
+class Dot1Q : public PDU {
+public:
+    /**
+     * This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::DOT1Q;
+    
+    /**
+     * Default constructor
+     */
+    Dot1Q(small_uint<12> tag_id = 0, bool append_pad = true);
+
+    /**
+     * \brief Constructs a Dot1Q object from a buffer and adds all 
+     * identifiable PDUs found in the buffer as children of this 
+     * one. 
+     * 
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for a Dot1Q header in the buffer,
+     * a malformed_packet exception is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot1Q(const uint8_t *buffer, uint32_t total_sz);
+
+    // Getters
+
+    /**
+     * \brief Returns the header size.
+     *
+     * This metod overrides PDU::header_size. \sa PDU::header_size
+     */
+    uint32_t header_size() const;
+
+    /**
+     * \brief Returns the frame's trailer size.
+     * \return The trailer's size.
+     */
+    uint32_t trailer_size() const;
+
+    /**
+     * \brief Getter for the priority field.
+     * \return The stored priority field value.
+     */
+    small_uint<3> priority() const {
+        return _header.priority;
+    }
+
+    /**
+     * \brief Getter for the Canonical Format Identifier field.
+     * \return The stored CFI field value.
+     */
+    small_uint<1> cfi() const {
+        return _header.cfi;
+    }
+
+    /**
+     * \brief Getter for the VLAN ID field.
+     * \return The stored VLAN ID field value.
+     */
+    small_uint<12> id() const {
+        #if TINS_IS_LITTLE_ENDIAN
+            return _header.idL | (_header.idH << 8);
+        #else
+            return _header.id;
+        #endif
+    }
+
+    /**
+     * \brief Getter for the payload type field.
+     * \return The stored type field value.
+     */
+    uint16_t payload_type() const {
+        return Endian::be_to_host(_header.type);
+    }
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+    
+    /**
+     * \sa PDU::clone
+     */
+    Dot1Q *clone() const {
+        return new Dot1Q(*this);
+    }
+
+    /**
+     * \brief Retrieves the flag indicating whether padding will be
+     * appended at the end of this packet.
+     */
+    bool append_padding() const {
+        return _append_padding;
+    }
+
+    // Setters
+
+    /**
+     * \brief Setter for the priority field.
+     * \param new_priority The new priority field value.
+     */
+    void priority(small_uint<3> new_priority);
+
+    /**
+     * \brief Setter for the Canonical Format Identifie field.
+     * \param new_cfi The new CFI field value.
+     */
+    void cfi(small_uint<1> new_cfi);
+
+    /**
+     * \brief Setter for the VLAN ID field.
+     * \param new_id The new VLAN ID field value.
+     */
+    void id(small_uint<12> new_id);
+
+    /**
+     * \brief Setter for the payload type field.
+     * \param new_type The new type field value.
+     */
+    void payload_type(uint16_t new_type);
+    
+    /**
+     * \brief Indicates whether the appropriate padding will be 
+     * at the end of the packet.
+     * 
+     * This flag could be disabled in case two or more contiguous Dot1Q 
+     * PDUs are added to a packet. In that case, only the Dot1Q which is 
+     * closer to the link layer should add the padding at the end.
+     * 
+     * \param value A boolean indicating whether padding will be appended.
+     */
+    void append_padding(bool value);
+    
+    /** 
+     * \brief Check wether ptr points to a valid response for this PDU.
+     *
+     * \sa PDU::matches_response
+     * \param ptr The pointer to the buffer.
+     * \param total_sz The size of the buffer.
+     */
+    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);
+
+    TINS_BEGIN_PACK
+    struct dot1q_hdr {
+        #if TINS_IS_BIG_ENDIAN
+            uint16_t priority:3,
+                    cfi:1,
+                    id:12;
+            uint16_t type;
+        #else
+            uint16_t idH:4,
+                    cfi:1,
+                    priority:3,
+                    idL:8;
+            uint16_t type;
+        #endif
+    } TINS_END_PACK;
+    
+    static uint16_t get_id(const dot1q_hdr *hdr);
+    
+    dot1q_hdr _header;
+    bool _append_padding;
+};
+}
+
+#endif // TINS_DOT1Q_H

include/dot3.h

@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_DOT3_H
+#define TINS_DOT3_H
+
+#include <stdint.h>
+#include "macros.h"
+#include "pdu.h"
+#include "endianness.h"
+#include "hw_address.h"
+
+namespace Tins {
+
+    /** 
+     * \brief Class representing an Ethernet II PDU.
+     */
+    class Dot3 : public PDU {
+    public:
+        /**
+         * \brief The address type.
+         */
+        typedef HWAddress<6> address_type; 
+        
+        /**
+         * \brief This PDU's flag.
+         */
+        static const PDU::PDUType pdu_flag = PDU::IEEE802_3;
+
+        /**
+         * \brief Represents the Dot3 broadcast address.
+         */
+        static const address_type BROADCAST;
+
+        /**
+         * \brief Constructor for creating an Dot3 PDU
+         *
+         * Constructor that builds an Dot3 PDU taking the interface name,
+         * destination's and source's MAC.
+         *
+         * \param dst_hw_addr The destination hardware address.
+         * \param src_hw_addr The source hardware address.
+         * \param child The PDU which will be set as the inner PDU.
+         */
+        Dot3(const address_type &dst_hw_addr = address_type(), 
+            const address_type &src_hw_addr = address_type());
+
+        /**
+         * \brief Constructs a Dot3 object from a buffer and adds a
+         * LLC object with the remaining data as the inner PDU.
+         * 
+         * If there is not enough size for a Dot3 header, a 
+         * malformed_packet exception is thrown.
+         * 
+         * \param buffer The buffer from which this PDU will be constructed.
+         * \param total_sz The total size of the buffer.
+         */
+        Dot3(const uint8_t *buffer, uint32_t total_sz);
+
+        /* Getters */
+        /**
+         * \brief Getter for the destination hardware address.
+         *
+         * \return The destination hardware address.
+         */
+        address_type dst_addr() const { return _eth.dst_mac; }
+
+        /**
+         * \brief Getter for the source hardware address.
+         *
+         * \return The source hardware address.
+         */
+        address_type src_addr() const { return _eth.src_mac; }
+
+        /**
+         * \brief Getter for the length field.
+         * \return The length field value.
+         */
+        uint16_t length() const { return Endian::be_to_host(_eth.length); };
+
+        /* Setters */
+
+        /**
+         * \brief Setter for the destination hardware address.
+         *
+         * \param new_dst_mac The new destination hardware address.
+         */
+        void dst_addr(const address_type &new_dst_mac);
+
+        /**
+         * \brief Setter for the source hardware address.
+         *
+         * \param new_src_mac The new source hardware address.
+         */
+        void src_addr(const address_type &new_src_mac);
+
+        /**
+         * \brief Setter for the length field.
+         *
+         * \param new_length uint16_t with the new value of the length field.
+         */
+        void length(uint16_t new_length);
+
+        /* Virtual methods */
+        /**
+         * \brief Returns the Dot3 frame's header length.
+         *
+         * \return An uint32_t with the header's size.
+         * \sa PDU::header_size()
+         */
+        uint32_t header_size() const;
+        
+        #ifndef WIN32
+        /**
+         * \sa PDU::send()
+         */
+        void send(PacketSender &sender, const NetworkInterface &iface);
+        #endif // WIN32
+
+        /** 
+         * \brief Check wether ptr points to a valid response for this PDU.
+         *
+         * \sa PDU::matches_response
+         * \param ptr The pointer to the buffer.
+         * \param total_sz The size of the buffer.
+         */
+        bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
+
+        #ifndef WIN32
+        /** 
+         * \sa PDU::recv_response
+         */
+        PDU *recv_response(PacketSender &sender, const NetworkInterface &iface);
+        #endif // WIN32
+
+        /**
+         * \brief Getter for the PDU's type.
+         * \sa PDU::pdu_type
+         */
+        PDUType pdu_type() const { return pdu_flag; }
+
+        /**
+         * \sa PDU::clone
+         */
+        Dot3 *clone() const {
+            return new Dot3(*this);
+        }
+    private:
+        /**
+         * Struct that represents the Ethernet II header
+         */
+        TINS_BEGIN_PACK
+        struct ethhdr {
+            uint8_t dst_mac[address_type::address_size];
+            uint8_t src_mac[address_type::address_size];
+            uint16_t length;
+        } TINS_END_PACK;
+
+        void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
+
+
+        ethhdr _eth;
+    };
+}
+
+
+#endif // TINS_DOT3_H

include/eapol.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -32,6 +32,7 @@
 
 #include <stdint.h>
 #include "pdu.h"
+#include "macros.h"
 #include "small_uint.h"
 #include "endianness.h"
 
@@ -66,6 +67,12 @@ namespace Tins {
         /**
          * \brief Static method to instantiate the correct EAPOL subclass 
          * based on a raw buffer.
+         * 
+         * If no valid EAPOL type is detected, a null pointer is returned.
+         * 
+         * \sa RC4EAPOL
+         * \sa RSNEAPOL
+         * 
          * \param buffer The buffer from which the data will be taken.
          * \param total_sz The total size of the buffer.
          */
@@ -134,11 +141,6 @@ namespace Tins {
          */
         EAPOL(uint8_t packet_type, EAPOLTYPE type);
         
-        /**
-         * \brief Copy constructor.
-         */
-        EAPOL(const EAPOL &other);
-        
         /**
          * \brief Constructor which creates an EAPOL object from a buffer.
          * \param buffer The buffer from which this PDU will be constructed.
@@ -146,13 +148,12 @@ namespace Tins {
          */
         EAPOL(const uint8_t *buffer, uint32_t total_sz);
         
-        void copy_eapol_fields(const EAPOL *other);
-        
+        TINS_BEGIN_PACK
         struct eapolhdr {
             uint8_t version, packet_type;
             uint16_t length;
             uint8_t type;
-        } __attribute__((__packed__));
+        } TINS_END_PACK;
         
         /**
          * \brief Virtual method which should serialize the subclass specific
@@ -202,12 +203,16 @@ namespace Tins {
         static const size_t key_sign_size = 16;
     
         /**
-         * \brief Creates an instance of RC4EAPOL
+         * \brief Default constructor.
          */
         RC4EAPOL();
         
         /**
-         * \brief Constructor which creates an RC4EAPOL object from a buffer.
+         * \brief Constructs a RC4EAPOL object from a buffer.
+         * 
+         * If there is not enough size for a RC4EAPOL header in the 
+         * buffer, a malformed_packet exception is thrown.
+         * 
          * \param buffer The buffer from which this PDU will be constructed.
          * \param total_sz The total size of the buffer.
          */
@@ -324,7 +329,7 @@ namespace Tins {
          * \param flag The flag to match
          * \sa PDU::matches_flag
          */
-        bool matches_flag(PDUType flag) {
+        bool matches_flag(PDUType flag) const {
            return flag == PDU::RC4EAPOL || EAPOL::matches_flag(flag);
         }
         
@@ -337,6 +342,7 @@ namespace Tins {
             return new RC4EAPOL(*this);
         }
     private:
+        TINS_BEGIN_PACK
         struct rc4hdr {
             uint16_t key_length;
             uint64_t replay_counter;
@@ -344,7 +350,7 @@ namespace Tins {
             uint8_t key_index:7,
                     key_flag:1;
             uint8_t key_sign[16];
-        } __attribute__((__packed__));
+        } TINS_END_PACK;
         
         void write_body(uint8_t *buffer, uint32_t total_sz);
         
@@ -400,7 +406,11 @@ namespace Tins {
         RSNEAPOL();
         
         /**
-         * \brief Constructor which creates an RSNEAPOL object from a buffer.
+         * \brief Constructs a RSNEAPOL object from a buffer.
+         * 
+         * If there is not enough size for the RSNEAPOL header, a
+         * malformed_packet exception is thrown.
+         * 
          * \param buffer The buffer from which this PDU will be constructed.
          * \param total_sz The total size of the buffer.
          */
@@ -463,8 +473,8 @@ namespace Tins {
         const key_type &key() const { return _key; }
         
         /**
-         * \brief Getter for the key_mic field.
-         * \return The key_mic field.
+         * \brief Getter for the key mic field.
+         * \return 1 if this EAPOL PDU contains a valid MIC, 0 otherwise.
          */
         small_uint<1> key_mic() const { return _header.key_mic; };
 
@@ -490,17 +500,18 @@ namespace Tins {
          * \brief Getter for the encrypted field.
          * \return The encrypted field.
          */
-        small_uint<1 > encrypted() const { return _header.encrypted; };
+        small_uint<1> encrypted() const { return _header.encrypted; };
 
         /**
-         * \brief Getter for the key_descriptor field.
-         * \return The key_descriptor field.
+         * \brief Getter for the key descriptor field.
+         * \return The key descriptor field.
          */
         small_uint<3> key_descriptor() const { return _header.key_descriptor; };
 
         /**
-         * \brief Getter for the key_t field.
-         * \return The key_t field.
+         * \brief Getter for the key type field.
+         * 
+         * \return 1 if this is a pairwise key, 0 otherwise.
          */
         small_uint<1> key_t() const { return _header.key_t; };
 
@@ -665,7 +676,7 @@ namespace Tins {
          * \param flag The flag to match
          * \sa PDU::matches_flag
          */
-        bool matches_flag(PDUType flag) {
+        bool matches_flag(PDUType flag) const {
            return flag == PDU::RSNEAPOL || EAPOL::matches_flag(flag);
         }
         
@@ -678,6 +689,7 @@ namespace Tins {
             return new RSNEAPOL(*this);
         }
     private:
+        TINS_BEGIN_PACK
         struct rsnhdr {
         #if TINS_IS_LITTLE_ENDIAN
             uint16_t key_mic:1,
@@ -716,7 +728,7 @@ namespace Tins {
             uint8_t mic[mic_size];
             uint16_t wpa_length;
         #endif
-        } __attribute__((__packed__));
+        } TINS_END_PACK;
         
         void write_body(uint8_t *buffer, uint32_t total_sz);
         
@@ -724,6 +736,6 @@ namespace Tins {
         rsnhdr _header;
         key_type _key;
     };
-};
+}
 
 #endif // TINS_EAPOL_H

include/endianness.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,21 +31,46 @@
 #define TINS_ENDIANNESS_H
 
 #include <stdint.h>
-#ifndef WIN32
+#include "macros.h"
+
+#if defined(__APPLE__)
+    #include <sys/types.h>
+    #define TINS_IS_LITTLE_ENDIAN (BYTE_ORDER == LITTLE_ENDIAN)
+    #define TINS_IS_BIG_ENDIAN (BYTE_ORDER == BIG_ENDIAN)
+#elif defined(BSD)
+    #include <sys/endian.h>
+    #define TINS_IS_LITTLE_ENDIAN (_BYTE_ORDER == _LITTLE_ENDIAN)
+    #define TINS_IS_BIG_ENDIAN (_BYTE_ORDER == _BIG_ENDIAN)
+#elif defined(WIN32)
+    // Assume windows == little endian. fixme later
+    #define TINS_IS_LITTLE_ENDIAN 1
+    #define TINS_IS_BIG_ENDIAN 0
+#else
     #include <endian.h>
+    #define TINS_IS_LITTLE_ENDIAN (__BYTE_ORDER == __LITTLE_ENDIAN)
+    #define TINS_IS_BIG_ENDIAN (__BYTE_ORDER == __BIG_ENDIAN)
 #endif
 
-#define TINS_IS_LITTLE_ENDIAN (__BYTE_ORDER == __LITTLE_ENDIAN)
-#define TINS_IS_BIG_ENDIAN (__BYTE_ORDER == __BIG_ENDIAN)
+
 
 namespace Tins {
 namespace Endian {
+    /** 
+     * \brief "Changes" a 8-bit integral value's endianess. This is an
+     * identity function.
+     *
+     * \param data The data to convert.
+     */
+    inline uint8_t do_change_endian(uint8_t data) {
+        return data;
+    }
+    
     /** 
      * \brief Changes a 16-bit integral value's endianess.
      *
      * \param data The data to convert.
      */
-    inline uint16_t change_endian(uint16_t data) {
+    inline uint16_t do_change_endian(uint16_t data) {
         return ((data & 0xff00) >> 8)  | ((data & 0x00ff) << 8);
     }
     
@@ -54,7 +79,7 @@ namespace Endian {
      *
      * \param data The data to convert.
      */
-    inline uint32_t change_endian(uint32_t data) {
+    inline uint32_t do_change_endian(uint32_t data) {
         return (((data & 0xff000000) >> 24) | ((data & 0x00ff0000) >> 8)  |
                 ((data & 0x0000ff00) << 8)  | ((data & 0x000000ff) << 24));
     }
@@ -64,9 +89,61 @@ namespace Endian {
      *
      * \param data The data to convert.
      */
-     inline uint64_t change_endian(uint64_t data) {
-        return (((uint64_t)(change_endian((uint32_t)((data << 32) >> 32))) << 32) |
-                (change_endian(((uint32_t)(data >> 32)))));
+     inline uint64_t do_change_endian(uint64_t data) {
+        return (((uint64_t)(do_change_endian((uint32_t)(data & 0xffffffff))) << 32) |
+                (do_change_endian(((uint32_t)(data >> 32)))));
+     }
+     
+    /**
+     * \cond
+     */
+    
+    // Helpers to convert
+    template<typename T>
+    struct conversion_dispatch_helper {
+        static T dispatch(T data) {
+            return do_change_endian(data);
+        }
+    };
+    
+    
+    template<size_t>
+    struct conversion_dispatcher;
+    
+    template<>
+    struct conversion_dispatcher<sizeof(uint8_t)> 
+    : public conversion_dispatch_helper<uint8_t> 
+    { };
+    
+    template<>
+    struct conversion_dispatcher<sizeof(uint16_t)> 
+    : public conversion_dispatch_helper<uint16_t> 
+    { };
+    
+    template<>
+    struct conversion_dispatcher<sizeof(uint32_t)> 
+    : public conversion_dispatch_helper<uint32_t> 
+    { };
+    
+    template<>
+    struct conversion_dispatcher<sizeof(uint64_t)> 
+    : public conversion_dispatch_helper<uint64_t> 
+    { };
+    
+    /**
+     * \endcond
+     */
+    
+    /**
+     * \brief Changes an integral value's endianess.
+     * 
+     * This dispatchs to the corresponding function.
+     *
+     * \param data The data to convert.
+     */ 
+     template<typename T>
+     inline T change_endian(T data) {
+         return conversion_dispatcher<sizeof(T)>::dispatch(data);
      }
     
     #if TINS_IS_LITTLE_ENDIAN

include/ethernetII.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,11 +31,10 @@
 #define TINS_ETHERNET_II_H
 
 #include <stdint.h>
-
+#include "macros.h"
 #include "pdu.h"
 #include "endianness.h"
 #include "hw_address.h"
-#include "network_interface.h"
 
 namespace Tins {
 
@@ -60,24 +59,23 @@ namespace Tins {
         static const address_type BROADCAST;
 
         /**
-         * \brief Constructor for creating an ethernet PDU
+         * \brief Constructs an ethernet II PDU.
          *
-         * Constructor that builds an ethernet PDU taking the interface name,
-         * destination's and source's MAC.
-         *
-         * \param iface string containing the interface's name from where to send the packet.
-         * \param dst_hw_addr address_type containing the destination's MAC(optional).
-         * \param src_hw_addr address_type containing the source's MAC(optional).
-         * \param child PDU* with the PDU contained by the ethernet PDU (optional).
+         * \param dst_hw_addr address_type containing the destination's MAC.
+         * \param src_hw_addr address_type containing the source's MAC.
          */
-        EthernetII(const NetworkInterface& iface = NetworkInterface(), 
-                    const address_type &dst_hw_addr = address_type(), 
-                    const address_type &src_hw_addr = address_type(), 
-                    PDU* child = 0);
+        EthernetII(const address_type &dst_hw_addr = address_type(), 
+                    const address_type &src_hw_addr = address_type());
 
         /**
-         * \brief Constructor which creates an EthernetII object from a buffer and adds all identifiable
-         * PDUs found in the buffer as children of this one.
+         * \brief Constructs a EthernetII object from a buffer and adds 
+         * all identifiable PDUs found in the buffer as children of 
+         * this one.
+         * 
+         * If the next PDU is not recognized, then a RawPDU is used.
+         * 
+         * If there is not enough size for a EthernetII header in the 
+         * buffer, a malformed_packet exception is thrown.
          * 
          * \param buffer The buffer from which this PDU will be constructed.
          * \param total_sz The total size of the buffer.
@@ -100,13 +98,6 @@ namespace Tins {
          */
         address_type src_addr() const { return _eth.src_mac; }
 
-        /**
-         * \brief Getter for the interface.
-         *
-         * \return Returns the interface in which this PDU will be sent.
-         */
-        const NetworkInterface &iface() const { return _iface; }
-
         /**
          * \brief Getter for the payload_type
          * \return The payload type.
@@ -129,13 +120,6 @@ namespace Tins {
          */
         void src_addr(const address_type &new_src_addr);
 
-        /**
-         * \brief Setter for the interface.
-         *
-         * \param new_iface the interface to be set.
-         */
-        void iface(const NetworkInterface& new_iface);
-
         /**
          * \brief Setter for the payload type.
          *
@@ -152,29 +136,38 @@ namespace Tins {
          */
         uint32_t header_size() const;
         
+        /**
+         * \brief Returns the ethernet II frame's padding.
+         *
+         * \return An uint32_t with the padding size.
+         * \sa PDU::trailer_size()
+         */
+        uint32_t trailer_size() const;
+
         // Windows does not support sending L2 PDUs.
         #ifndef WIN32
         /**
          * \sa PDU::send()
          */
-        void send(PacketSender &sender);
+        void send(PacketSender &sender, const NetworkInterface &iface);
         #endif // WIN32
 
-        /** \brief Check wether ptr points to a valid response for this PDU.
+        /** 
+         * \brief Check wether ptr points to a valid response for this PDU.
          *
          * \sa PDU::matches_response
          * \param ptr The pointer to the buffer.
          * \param total_sz The size of the buffer.
          */
-        bool matches_response(uint8_t *ptr, uint32_t total_sz);
+        bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
 
         #ifndef WIN32
-        /** \brief Receives a matching response for this packet.
+        /** 
+         * \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);
+        PDU *recv_response(PacketSender &sender, const NetworkInterface &iface);
         #endif // WIN32
 
         /**
@@ -183,16 +176,6 @@ namespace Tins {
          */
         PDUType pdu_type() const { return PDU::ETHERNET_II; }
 
-        /** \brief Clones this pdu, filling the corresponding header with data
-         * extracted from a buffer.
-         *
-         * \param ptr The pointer to the from from which the data will be extracted.
-         * \param total_sz The size of the buffer.
-         * \return The cloned PDU.
-         * \sa PDU::clone_packet
-         */
-        PDU *clone_packet(const uint8_t *ptr, uint32_t total_sz);
-
         /**
          * \sa PDU::clone
          */
@@ -203,19 +186,19 @@ namespace Tins {
         /**
          * Struct that represents the Ethernet II header
          */
+        TINS_BEGIN_PACK
         struct ethhdr {
             uint8_t dst_mac[address_type::address_size];
             uint8_t src_mac[address_type::address_size];
             uint16_t payload_type;
-        } __attribute__((__packed__));
+        } TINS_END_PACK;
         
         void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
 
         ethhdr _eth;
-        NetworkInterface _iface;
     };
 
-};
+}
 
 
 #endif // TINS_ETHERNET_II_H

include/exceptions.h

@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_EXCEPTIONS_H
+#define TINS_EXCEPTIONS_H
+
+#include <string>
+#include <stdexcept>
+
+namespace Tins {
+/**
+ * \brief Exception thrown when an option is not found.
+ */
+class option_not_found : public std::runtime_error {
+public:
+    option_not_found()
+    : std::runtime_error(std::string()) { }
+
+    // try to avoid allocations by doing this.
+    const char* what() const throw() {
+        return "Option not found";
+    }
+};
+
+/**
+ * \brief Exception thrown when a malformed packet is parsed.
+ */
+class malformed_packet : public std::runtime_error {
+public:
+    malformed_packet()
+    : std::runtime_error(std::string()) { }
+    
+    const char* what() const throw() {
+        return "Malformed packet";
+    }
+};
+
+/**
+ * \brief Exception thrown when a PDU is not found when using PDU::rfind_pdu.
+ */
+class pdu_not_found : public std::runtime_error {
+public:
+    pdu_not_found()
+    : std::runtime_error(std::string()) { }
+    
+    const char* what() const throw() {
+        return "PDU not found";
+    }
+};
+
+/**
+ * \brief Exception thrown when PDU::send requires a valid interface,
+ * but an invalid is used.
+ */
+class invalid_interface : public std::runtime_error {
+public:
+    invalid_interface()
+    : std::runtime_error(std::string()) { }
+    
+    const char* what() const throw() {
+        return "Invalid interface";
+    }
+};
+
+/**
+ * \brief Exception thrown when PacketSender fails to open a socket.
+ */
+class socket_open_error : public std::runtime_error {
+public:
+    socket_open_error(const std::string &msg) 
+    : std::runtime_error(msg) { }
+};
+
+/**
+ * \brief Exception thrown when PacketSender fails to close a socket.
+ */
+class socket_close_error : public std::runtime_error {
+public:
+    socket_close_error(const std::string &msg) 
+    : std::runtime_error(msg) { }
+};
+
+/**
+ * \brief Exception thrown when PacketSender fails to write on a socket.
+ */
+class socket_write_error : public std::runtime_error {
+public:
+    socket_write_error(const std::string &msg) 
+    : std::runtime_error(msg) { }
+};
+
+/**
+ * \brief Exception thrown when an invalid socket type is provided
+ * to PacketSender.
+ */
+class invalid_socket_type : public std::exception {
+public:
+    const char *what() const throw() {
+        return "The provided socket type is invalid";
+    }
+};
+
+/**
+ * \brief Exception thrown when an unkown link layer PDU type is 
+ * found while sniffing.
+ */
+class unknown_link_type : public std::exception {
+public:
+    const char *what() const throw() {
+        return "The sniffed link layer PDU type is unknown";
+    }
+};
+
+/**
+ * \brief Exception thrown when a malformed option is found.
+ */
+class malformed_option : public std::exception {
+public:
+    const char *what() const throw() {
+        return "Malformed option";
+    }
+};
+
+/**
+ * \brief Exception thrown when a call to tins_cast fails.
+ */
+class bad_tins_cast : public std::exception {
+public:
+    const char *what() const throw() {
+        return "Bad Tins cast";
+    }
+};
+
+/**
+ * \brief Exception thrown when sniffing a protocol that
+ * has been disabled at compile time.
+ */
+class protocol_disabled : public std::exception {
+public:
+    const char *what() const throw() {
+        return "Protocol disabled";
+    }
+};
+
+} // Tins
+
+#endif // TINS_EXCEPTIONS_H

include/handshake_capturer.h

@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "config.h"
+
+#if !defined(TINS_HANDSHAKE_CAPTURER_H)  && defined(HAVE_DOT11)
+#define TINS_HANDSHAKE_CAPTURER_H
+
+#include <vector>
+#include <map>
+#include <utility>
+#include "hw_address.h"
+#include "eapol.h"
+
+// .h
+namespace Tins {
+    /**
+     * \brief Generic EAPOL handshake.
+     *
+     * Stores both the client and supplicant addresses, as well as 
+     * all of the EAPOL packets used during the handshake.
+     */
+    template<typename T>
+    class EAPOLHandshake {
+    public:
+        typedef std::vector<T> container_type;
+        typedef HWAddress<6> address_type;
+        
+        /**
+         * \brief Default constructor.
+         */
+        EAPOLHandshake() { }
+
+        /**
+         * Constructs an EAPOLHandshake object.
+         * 
+         * \param client_address The client address.
+         * \param supplicant_address The supplicant address.
+         * \param cont The container that holds the EAPOL packets used
+         * in the handshake.
+         */
+        EAPOLHandshake(const address_type &client_address, 
+          const address_type &supplicant_address, const container_type &cont) 
+        : cl_address_(client_address), suppl_address_(supplicant_address), 
+        handshake_(cont) 
+        {
+            
+        }
+        
+        /**
+         * \return const address_type&
+         */
+        const address_type &client_address() const {
+            return cl_address_;
+        }
+        
+        /**
+         * \return const address_type&
+         */
+        const address_type &supplicant_address() const {
+            return suppl_address_;
+        }
+        
+        /**
+         * \return const container_type&
+         */
+        const container_type &handshake() const {
+            return handshake_;
+        }
+    private:
+        address_type cl_address_, suppl_address_;
+        container_type handshake_;
+    };
+    
+    /**
+     * The type used to store RSN handshakes.
+     */
+    typedef EAPOLHandshake<RSNEAPOL> RSNHandshake;
+    
+    /**
+     * Captures 802.1X RSN handshakes.
+     */
+    class RSNHandshakeCapturer {
+    public:
+        /**
+         * The type of handshakes that will be captured.
+         */
+        typedef RSNHandshake handshake_type;
+
+        /**
+         * The type in which all of the captured handshakes
+         * will be stored.
+         */
+        typedef std::vector<handshake_type> handshakes_type;
+        
+        /**
+         * \brief Processes a packet.
+         * 
+         * This will fetch the RSNEAPOL layer, if any, and store
+         * it in an intermediate storage. When a handshake is 
+         * completed, it will be stored separately. 
+         *
+         * \sa RSNHandshakeCapturer::handshakes
+         */
+        bool process_packet(const PDU &pdu);
+
+        /**
+         * \brief Retrieves the completed handshakes.
+         *
+         * This will return the handshakes that have been completed 
+         * so far. A handshake is completed when the 4-way handshake
+         * is captured.
+         *
+         * \sa RSNHandshakeCapturer::clear_handshakes
+         */
+        const handshakes_type &handshakes() const {
+            return completed_handshakes_;
+        }
+
+        /**
+         * \brief Clears the completed handshakes.
+         *
+         * Since completed handshakes are stored in a std::vector,
+         * it is advisable to remove all of them once they have been 
+         * processed.
+         */
+        void clear_handshakes() {
+            completed_handshakes_.clear();
+        }
+    private:
+        typedef handshake_type::address_type address_type;
+        typedef handshake_type::container_type eapol_list;
+        typedef std::map<std::pair<address_type, address_type>, eapol_list> handshake_map;
+    
+        bool do_insert(const handshake_map::key_type &key, const RSNEAPOL *eapol, 
+          size_t expected);
+    
+        handshake_map handshakes_;
+        handshakes_type completed_handshakes_;
+    };
+}
+
+#endif // TINS_HANDSHAKE_CAPTURER_H

include/hw_address.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -37,6 +37,7 @@
 #include <iomanip>
 #include <iostream>
 #include <sstream>
+#include "cxxstd.h"
 
 namespace Tins {
 /**
@@ -68,6 +69,11 @@ public:
      * elements in this address.
      */
     static const size_t address_size = n;
+
+    /**
+     * \brief The broadcast address.
+     */
+    static const HWAddress<n, Storage> broadcast;
     
     /**
      * \brief Constructor from a const storage_type*.
@@ -137,11 +143,18 @@ public:
      */
     template<size_t i>
     HWAddress(const HWAddress<i> &rhs) {
-        std::copy(
-            rhs.begin(),
-            rhs.begin() + std::min(i, n),
-            begin()
+        // Fill extra bytes
+        std::fill(
+            // Copy as most as we can
+            std::copy(
+                rhs.begin(),
+                rhs.begin() + std::min(i, n),
+                begin()
+            ),
+            end(),
+            0
         );
+        
     }
     
     /**
@@ -226,6 +239,27 @@ public:
         return address_size;
     }
     
+    /**
+     * \brief Indicates whether this is a broadcast address.
+     */
+    bool is_broadcast() const {
+        return *this == broadcast;
+    }
+    
+    /**
+     * \brief Indicates whether this is a multicast address.
+     */
+    bool is_multicast() const {
+        return (buffer[0] & 0x01);
+    }
+
+    /**
+     * \brief Indicates whether this is an unicast address.
+     */
+    bool is_unicast() const {
+        return !is_broadcast() && !is_multicast();
+    }
+
     /**
      * \brief Convert this address to a hex-notation std::string address.
      * 
@@ -236,6 +270,15 @@ public:
         oss << *this;
         return oss.str();
     }
+
+    /**
+     * \brief Retrieves the i-th storage_type in this address.
+     *
+     * \param i The element to retrieve.
+     */
+    storage_type operator[](size_t i) const {
+        return buffer[i];
+    }
     
     /**
      * \brief Writes this HWAddress in hex-notation to a std::ostream.
@@ -295,13 +338,16 @@ 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()) {
+    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] == ':')
@@ -311,6 +357,7 @@ void HWAddress<n, Storage>::convert(const std::string &hw_addr,
             i++;
         }
         *(output++) = tmp;
+        count++;
         if(i < hw_addr.size()) {
             if(hw_addr[i] == ':')
                 i++;
@@ -318,6 +365,23 @@ void HWAddress<n, Storage>::convert(const std::string &hw_addr,
                 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("ff:ff:ff:ff:ff:ff");
+} // namespace Tins
+#if TINS_IS_CXX11
+namespace std
+{
+template<size_t n>
+struct hash<Tins::HWAddress<n>> {
+    size_t operator()(const Tins::HWAddress<n> &addr) const {
+        return std::hash<std::string>()(addr.to_string());
+    }
+};
+} // namespace std
+#endif
 #endif // TINS_HWADDRESS_H

include/icmp.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,9 +30,22 @@
 #ifndef TINS_ICMP_H
 #define TINS_ICMP_H
 
+// Windows likes to define macros with not-so-common-names, which break
+// this code
+#ifdef WIN32
+    #ifdef TIMESTAMP_REQUEST
+        #undef TIMESTAMP_REQUEST
+    #endif // TIMESTAMP_REQUEST
 
+    #ifdef TIMESTAMP_REPLY
+        #undef TIMESTAMP_REPLY
+    #endif // TIMESTAMP_REPLY
+#endif // WIN32
+
+#include "macros.h"
 #include "pdu.h"
 #include "endianness.h"
+#include "ip_address.h"
 
 namespace Tins {
 
@@ -48,6 +61,11 @@ namespace Tins {
          */
         static const PDU::PDUType pdu_flag = PDU::ICMP;
     
+        /**
+         * The type used to store addresses.
+         */
+        typedef IPv4Address address_type;
+
         /** \brief ICMP flags
          */
         enum Flags {
@@ -58,8 +76,12 @@ namespace Tins {
             ECHO_REQUEST     = 8,
             TIME_EXCEEDED    = 11,
             PARAM_PROBLEM    = 12,
+            TIMESTAMP_REQUEST = 13,
+            TIMESTAMP_REPLY  = 14,
             INFO_REQUEST     = 15,
-            INFO_REPLY       = 16
+            INFO_REPLY       = 16,
+            ADDRESS_MASK_REQUEST = 17,
+            ADDRESS_MASK_REPLY = 18
         };
 
         /**
@@ -71,8 +93,13 @@ namespace Tins {
         ICMP(Flags flag = ECHO_REQUEST);
 
         /**
-         * \brief Constructor which creates an ICMP object from a buffer and adds all identifiable
-         * PDUs found in the buffer as children of this one.
+         * \brief Constructs an ICMP object from a buffer.
+         * 
+         * If there is not enough size for an ICMP header, a 
+         * malformed_packet exception is thrown.
+         * 
+         * Any extra data in the buffer will be stored in a RawPDU.
+         * 
          * \param buffer The buffer from which this PDU will be constructed.
          * \param total_sz The total size of the buffer.
          */
@@ -91,13 +118,6 @@ namespace Tins {
          */
         void type(Flags type);
 
-        /**
-         * \brief Setter for checksum field.
-         *
-         * \param new_check uint16_t with the new checksum.
-         */
-        void check(uint16_t new_check);
-
         /**
          * \brief Setter for the id field.
          *
@@ -115,9 +135,9 @@ namespace Tins {
         /**
          * \brief Setter for the gateway field.
          *
-         * \param new_gw uint32_t with the new gateway.
+         * \param new_gw The new value for the gateway field.
          */
-        void gateway(uint32_t new_gw);
+        void gateway(address_type new_gw);
 
         /**
          * \brief Setter for the mtu field.
@@ -133,6 +153,34 @@ namespace Tins {
          */
         void pointer(uint8_t new_pointer);
 
+        /**
+         * \brief Setter for the original timestamp field.
+         *
+         * \param new_timestamp the value to be set.
+         */
+        void original_timestamp(uint32_t new_timestamp);
+
+        /**
+         * \brief Setter for the receive timestamp field.
+         *
+         * \param new_timestamp the value to be set.
+         */
+        void receive_timestamp(uint32_t new_timestamp);
+
+        /**
+         * \brief Setter for the transmit timestamp field.
+         *
+         * \param new_timestamp the value to be set.
+         */
+        void transmit_timestamp(uint32_t new_timestamp);
+
+        /**
+         * \brief Setter for the address mask field.
+         *
+         * \param new_mask the value to be set.
+         */
+        void address_mask(address_type new_mask);
+
         /**
          * \brief Sets echo request flag for this PDU.
          *
@@ -141,14 +189,6 @@ namespace Tins {
          */
         void set_echo_request(uint16_t id, uint16_t seq);
 
-        /**
-         * \brief Sets echo request flag for this PDU.
-         *
-         * This uses a global id and sequence number to fill the request's
-         * fields.
-         */
-        void set_echo_request();
-
         /**
          * \brief Sets echo reply flag for this PDU.
          *
@@ -157,14 +197,6 @@ namespace Tins {
          */
         void set_echo_reply(uint16_t id, uint16_t seq);
 
-        /**
-         * \brief Sets echo reply flag for this PDU.
-         *
-         * This uses a global id and sequence number to fill the request's
-         * fields.
-         */
-        void set_echo_reply();
-
         /**
          * \brief Sets information request flag for this PDU.
          *
@@ -217,7 +249,7 @@ namespace Tins {
          * \param address Address of the gateway to which traffic should
          * be sent.
          */
-        void set_redirect(uint8_t icode, uint32_t address);
+        void set_redirect(uint8_t icode, address_type address);
 
         /**
          * \brief Getter for the ICMP type flag.
@@ -238,7 +270,7 @@ namespace Tins {
          *
          * \return Returns the checksum as an unit16_t.
          */
-        uint16_t check() const { return Endian::be_to_host(this->_icmp.check); }
+        uint16_t checksum() const { return Endian::be_to_host(_icmp.check); }
 
         /**
          * \brief Getter for the echo id.
@@ -257,23 +289,55 @@ namespace Tins {
         /**
          * \brief Getter for the gateway field.
          *
-         * \return Returns the gateways in an unit32_t.
+         * \return Returns the gateway field value.
          */
-         uint32_t gateway() const { return Endian::be_to_host(this->_icmp.un.gateway); }
+        address_type gateway() const { 
+            return address_type(Endian::be_to_host(_icmp.un.gateway)); 
+        }
 
          /**
           * \brief Getter for the pointer field.
           *
-          * \return Returns the pointer value.
+          * \return Returns the pointer field value.
           */
         uint8_t pointer() const { return this->_icmp.un.pointer; }
         
         /**
           * \brief Getter for the mtu field.
           *
-          * \return Returns the mtu value in an uint16_t.
+          * \return Returns the mtu field value.
           */
-        uint16_t mtu() const { return Endian::be_to_host(this->_icmp.un.frag.mtu); }
+        uint16_t mtu() const { return Endian::be_to_host(_icmp.un.frag.mtu); }
+
+        /**
+          * \brief Getter for the original timestamp field.
+          *
+          * \return Returns the original timestamp value.
+          */
+        uint32_t original_timestamp() const { return Endian::be_to_host(_orig_timestamp_or_address_mask); }
+
+        /**
+          * \brief Getter for the receive timestamp field.
+          *
+          * \return Returns the receive timestamp value.
+          */
+        uint32_t receive_timestamp() const { return Endian::be_to_host(_recv_timestamp); }
+
+        /**
+          * \brief Getter for the transmit timestamp field.
+          *
+          * \return Returns the transmit timestamp value.
+          */
+        uint32_t transmit_timestamp() const { return Endian::be_to_host(_trans_timestamp); }
+
+        /**
+          * \brief Getter for the address mask field.
+          *
+          * \return Returns the address mask value.
+          */
+        address_type address_mask() const { 
+            return address_type(Endian::be_to_host(_orig_timestamp_or_address_mask)); 
+        }
 
         /**
          * \brief Returns the header size.
@@ -290,7 +354,7 @@ namespace Tins {
          * \param ptr The pointer to the buffer.
          * \param total_sz The size of the buffer.
          */
-        bool matches_response(uint8_t *ptr, uint32_t total_sz);
+        bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
 
         /**
          * \brief Getter for the PDU's type.
@@ -298,17 +362,6 @@ namespace Tins {
          * \sa PDU::pdu_type
          */
         PDUType pdu_type() const { return PDU::ICMP; }
-
-        /**
-         * \brief Clones this pdu, filling the corresponding header with data
-         * extracted from a buffer.
-         *
-         * \param ptr The pointer to the from from which the data will be extracted.
-         * \param total_sz The size of the buffer.
-         * \return The cloned PDU.
-         * \sa PDU::clone_packet
-         */
-        PDU *clone_packet(const uint8_t *ptr, uint32_t total_sz);
         
         /**
          * \sa PDU::clone
@@ -317,8 +370,7 @@ namespace Tins {
             return new ICMP(*this);
         }
     private:
-        static uint16_t global_id, global_seq;
-
+        TINS_BEGIN_PACK
         struct icmphdr {
             uint8_t	type;
             uint8_t	code;
@@ -330,12 +382,14 @@ namespace Tins {
                 } echo;
                 uint32_t gateway;
                 struct {
-                    uint16_t __unused;
+                    uint16_t unused;
                     uint16_t mtu;
                 } frag;
                 uint8_t pointer;
             } un;
-        } __attribute__((__packed__));
+        } 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.
@@ -345,7 +399,8 @@ namespace Tins {
         void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
 
         icmphdr _icmp;
+        uint32_t _orig_timestamp_or_address_mask, _recv_timestamp, _trans_timestamp;
     };
-};
+}
 
 #endif // TINS_ICMP_H

include/ieee802_3.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,191 +30,11 @@
 #ifndef TINS_IEEE802_3_H
 #define TINS_IEEE802_3_H
 
-#include <stdint.h>
-
-#include "pdu.h"
-#include "endianness.h"
-#include "hw_address.h"
-#include "network_interface.h"
+#include "dot3.h"
 
 namespace Tins {
-
-    /** 
-     * \brief Class representing an Ethernet II PDU.
-     */
-    class IEEE802_3 : public PDU {
-    public:
-        /**
-         * \brief The address type.
-         */
-        typedef HWAddress<6> address_type; 
-        
-        /**
-         * \brief This PDU's flag.
-         */
-        static const PDU::PDUType pdu_flag = PDU::IEEE802_3;
-
-        /**
-         * \brief Represents the IEEE802_3 broadcast address.
-         */
-        static const address_type BROADCAST;
-
-        /**
-         * \brief Constructor for creating an IEEE802_3 PDU
-         *
-         * Constructor that builds an IEEE802_3 PDU taking the interface name,
-         * destination's and source's MAC.
-         *
-         * \param iface string containing the interface's name from where to send the packet.
-         * \param dst_hw_addr The destination hardware address.
-         * \param src_hw_addr The source hardware address.
-         * \param child The PDU which will be set as the inner PDU.
-         */
-        IEEE802_3(const NetworkInterface& iface = NetworkInterface(), 
-                  const address_type &dst_hw_addr = address_type(), 
-                  const address_type &src_hw_addr = address_type(), 
-                  PDU* child = 0);
-
-        /**
-         * \brief Constructor which creates an IEEE802_3 object from a buffer and adds all identifiable
-         * PDUs found in the buffer as children of this one.
-         * \param buffer The buffer from which this PDU will be constructed.
-         * \param total_sz The total size of the buffer.
-         */
-        IEEE802_3(const uint8_t *buffer, uint32_t total_sz);
-
-        /* Getters */
-        /**
-         * \brief Getter for the destination hardware address.
-         *
-         * \return The destination hardware address.
-         */
-        address_type dst_addr() const { return _eth.dst_mac; }
-
-        /**
-         * \brief Getter for the source hardware address.
-         *
-         * \return The source hardware address.
-         */
-        address_type src_addr() const { return _eth.src_mac; }
-
-        /**
-         * \brief Getter for the interface.
-         *
-         * \return The network interface.
-         */
-        const NetworkInterface &iface() const { return this->_iface; }
-
-        /**
-         * \brief Getter for the length field.
-         * \return The length field value.
-         */
-        uint16_t length() const { return Endian::be_to_host(_eth.length); };
-
-        /* Setters */
-
-        /**
-         * \brief Setter for the destination hardware address.
-         *
-         * \param new_dst_mac The new destination hardware address.
-         */
-        void dst_addr(const address_type &new_dst_mac);
-
-        /**
-         * \brief Setter for the source hardware address.
-         *
-         * \param new_src_mac The new source hardware address.
-         */
-        void src_addr(const address_type &new_src_mac);
-
-        /**
-         * \brief Setter for the interface.
-         *
-         * \param new_iface The interface in which to send this PDU.
-         */
-        void iface(const NetworkInterface &new_iface);
-
-        /**
-         * \brief Setter for the length field.
-         *
-         * \param new_length uint16_t with the new value of the length field.
-         */
-        void length(uint16_t new_length);
-
-        /* Virtual methods */
-        /**
-         * \brief Returns the IEEE802_3 frame's header length.
-         *
-         * \return An uint32_t with the header's size.
-         * \sa PDU::header_size()
-         */
-        uint32_t header_size() const;
-        
-        #ifndef WIN32
-        /**
-         * \sa PDU::send()
-         */
-        void send(PacketSender &sender);
-        #endif // WIN32
-
-        /** \brief Check wether ptr points to a valid response for this PDU.
-         *
-         * \sa PDU::matches_response
-         * \param ptr The pointer to the buffer.
-         * \param total_sz The size of the buffer.
-         */
-        bool matches_response(uint8_t *ptr, uint32_t total_sz);
-
-        #ifndef WIN32
-        /** \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);
-        #endif // WIN32
-
-        /**
-         * \brief Getter for the PDU's type.
-         * \sa PDU::pdu_type
-         */
-        PDUType pdu_type() const { return PDU::IEEE802_3; }
-
-        /** 
-         * \brief Clones this pdu, filling the corresponding header with data
-         * extracted from a buffer.
-         *
-         * \param ptr The pointer to the from from which the data will be extracted.
-         * \param total_sz The size of the buffer.
-         * \return The cloned PDU.
-         * \sa PDU::clone_packet
-         */
-        PDU *clone_packet(const uint8_t *ptr, uint32_t total_sz);
-
-        /**
-         * \sa PDU::clone
-         */
-        IEEE802_3 *clone() const {
-            return new IEEE802_3(*this);
-        }
-    private:
-        /**
-         * Struct that represents the Ethernet II header
-         */
-        struct ethhdr {
-            uint8_t dst_mac[address_type::address_size];
-            uint8_t src_mac[address_type::address_size];
-            uint16_t length;
-        } __attribute__((__packed__));
-
-        void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
-
-
-        ethhdr _eth;
-        NetworkInterface _iface;
-    };
-
-};
+    typedef Dot3 IEEE802_3;
+}
 
 
 #endif // TINS_IEEE802_3_H

include/internals.h

@@ -0,0 +1,207 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+ 
+#ifndef TINS_INTERNALS_H
+#define TINS_INTERNALS_H
+
+#include <sstream>
+#include <string>
+#include <stdint.h>
+#include "constants.h"
+#include "pdu.h"
+#include "hw_address.h"
+
+/**
+ * \cond
+ */
+namespace Tins {
+class IPv4Address;
+class IPv6Address;
+
+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_flag(PDU::PDUType type, const uint8_t *buffer, uint32_t size);
+
+Constants::Ethernet::e pdu_flag_to_ether_type(PDU::PDUType flag);
+Constants::IP::e pdu_flag_to_ip_type(PDU::PDUType flag);
+
+template<typename T>
+bool increment_buffer(T &addr) {
+    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;
+}
+
+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;
+};
+} // namespace Internals
+} // namespace Tins
+/**
+ * \endcond
+ */
+
+#endif

include/ip.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -36,6 +36,8 @@
 #include "endianness.h"
 #include "ip_address.h"
 #include "pdu_option.h"
+#include "macros.h"
+#include "cxxstd.h"
 
 namespace Tins {
 
@@ -49,7 +51,7 @@ namespace Tins {
     class IP : public PDU {
     public:
         /**
-         * his PDU's flag.
+         * This PDU's flag.
          */
         static const PDU::PDUType pdu_flag = PDU::IP;
     
@@ -99,6 +101,7 @@ namespace Tins {
         /**
          * \brief The type used to represent an option's type.
          */
+        TINS_BEGIN_PACK
         struct option_identifier {
         #if TINS_IS_LITTLE_ENDIAN
             uint8_t number:5,
@@ -161,12 +164,12 @@ namespace Tins {
             bool operator==(const option_identifier &rhs) const {
                 return number == rhs.number && op_class == rhs.op_class && copied == rhs.copied;
             }
-        } __attribute__((__packed__));
+        } TINS_END_PACK;
         
         /**
          * The IP options type.
          */
-        typedef PDUOption<option_identifier> ip_option;
+        typedef PDUOption<option_identifier, IP> option;
 
         /**
          * The type of the security option.
@@ -181,6 +184,8 @@ namespace Tins {
             : security(sec), compartments(comp), 
               handling_restrictions(hand_res), transmission_control(tcc) 
               {}
+            
+            static security_type from_option(const option &opt);
         };
         
         /**
@@ -195,6 +200,8 @@ namespace Tins {
             generic_route_option_type(uint8_t ptr = 0, 
               routes_type rts = routes_type())
             : pointer(ptr), routes(rts) {}
+            
+            static generic_route_option_type from_option(const option &opt);
         };
         
         /**
@@ -212,6 +219,11 @@ namespace Tins {
          */
         typedef generic_route_option_type record_route_type;
 
+        /**
+         * The type used to store IP options.
+         */
+        typedef std::list<option> options_type;
+
         /**
          * \brief Constructor for building the IP PDU.
          *
@@ -221,16 +233,18 @@ namespace Tins {
          *
          * \param ip_dst The destination ip address(optional).
          * \param ip_src The source ip address(optional).
-         * \param child pointer to a PDU which will be set as the inner_pdu 
-         * for the packet being constructed(optional).
          */
         IP(address_type ip_dst = address_type(), 
-            address_type ip_src = address_type(), 
-            PDU *child = 0);
+            address_type ip_src = address_type());
 
         /**
-         * \brief Constructor which creates an IP object from a buffer and adds all identifiable
-         * PDUs found in the buffer as children of this one.
+         * \brief Constructs an IP object from a buffer and adds all 
+         * identifiable PDUs found in the buffer as children of this 
+         * one.
+         * 
+         * If there is not enough size for an IP header, a 
+         * malformed_packet exception is thrown.
+         * 
          * \param buffer The buffer from which this PDU will be constructed.
          * \param total_sz The total size of the buffer.
          */
@@ -257,7 +271,9 @@ namespace Tins {
          *
          * \return The total length of this IP PDU.
          */
-        uint16_t tot_len() const { return Endian::be_to_host(_ip.tot_len); }
+        uint16_t tot_len() const { 
+            return Endian::be_to_host(_ip.tot_len); 
+        }
 
         /**
          * \brief Getter for the id field.
@@ -292,7 +308,7 @@ namespace Tins {
          *
          * \return The checksum for this IP PDU.
          */
-        uint16_t check() const { return Endian::be_to_host(_ip.check); }
+        uint16_t checksum() const { return Endian::be_to_host(_ip.check); }
 
         /**
          * \brief Getter for the source address field.
@@ -313,14 +329,13 @@ namespace Tins {
          */
         small_uint<4> version() const  { return _ip.version; }
 
-        /* Setters */
-
-        /**
-         * \brief Setter for the header length field.
-         *
-         * \param new_head_len The new header length.
+        /** 
+         * \brief Getter for the IP options.
+         * \return The stored options.
          */
-        void head_len(small_uint<4> new_head_len);
+        const options_type &options() const  { return _ip_options; }
+
+        /* Setters */
 
         /**
          * \brief Setter for the type of service field.
@@ -329,13 +344,6 @@ namespace Tins {
          */
         void tos(uint8_t new_tos);
 
-        /**
-         * \brief Setter for the total length field.
-         *
-         * \param new_tot_len The new total length.
-         */
-        void tot_len(uint16_t new_tot_len);
-
         /**
          * \brief Setter for the id field.
          *
@@ -360,17 +368,21 @@ namespace Tins {
         /**
          * \brief Setter for the protocol field.
          *
+         * Note that this protocol will be overwritten using the 
+         * inner_pdu's protocol type during serialization unless the IP 
+         * datagram is fragmented. 
+         * 
+         * If the packet is fragmented and was originally sniffed, the
+         * original protocol type will be kept when serialized.
+         * 
+         * If this packet has been crafted manually and the inner_pdu
+         * is, for example, a RawPDU, then setting the protocol yourself
+         * is necessary.
+         * 
          * \param new_protocol The new protocol.
          */
         void protocol(uint8_t new_protocol);
 
-        /**
-         * \brief Setter for the checksum field.
-         *
-         * \param new_check The new checksum.
-         */
-        void check(uint16_t new_check);
-
         /**
          * \brief Setter for the source address field.
          *
@@ -398,15 +410,48 @@ namespace Tins {
          * The option is added after the last option in the option 
          * fields.
          * 
-         * \param option The option to be added
+         * \param opt The option to be added
          */
-        void add_option(const ip_option &option);
+        void add_option(const option &opt);
+        
+        #if TINS_IS_CXX11
+            /**
+             * \brief Adds an IP option.
+             * 
+             * The option is move-constructed.
+             * 
+             * \param opt The option to be added.
+             */
+            void add_option(option &&opt) {
+                internal_add_option(opt);
+                _ip_options.push_back(std::move(opt));
+            }
+
+            /**
+             * \brief Adds an IP option.
+             * 
+             * The option is constructed from the provided parameters.
+             * 
+             * \param args The arguments to be used in the option's 
+             * constructor.
+             */
+            template<typename... Args>
+            void add_option(Args&&... args) {
+                _ip_options.emplace_back(std::forward<Args>(args)...);
+                internal_add_option(_ip_options.back());
+            }
+        #endif
 
         /**
          * \brief Searchs for an option that matchs the given flag.
+         * 
+         * If the option is not found, a null pointer is returned. 
+         * Deleting the returned pointer will result in <b>undefined 
+         * behaviour</b>.
+         * 
          * \param id The option identifier to be searched.
          */
-        const ip_option *search_option(option_identifier id) const;
+        const option *search_option(option_identifier id) const;
 
         // Option setters
         
@@ -533,7 +578,7 @@ namespace Tins {
         /**
          * \sa PDU::send()
          */
-        void send(PacketSender &sender);
+        void send(PacketSender &sender, const NetworkInterface &);
 
         /**
          * \brief Check wether ptr points to a valid response for this PDU.
@@ -542,7 +587,7 @@ namespace Tins {
          * \param ptr The pointer to the buffer.
          * \param total_sz The size of the buffer.
          */
-        bool matches_response(uint8_t *ptr, uint32_t total_sz);
+        bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
 
         /**
          * \brief Receives a matching response for this packet.
@@ -550,7 +595,14 @@ namespace Tins {
          * \sa PDU::recv_response
          * \param sender The packet sender which will receive the packet.
          */
-        PDU *recv_response(PacketSender &sender);
+        PDU *recv_response(PacketSender &sender, const NetworkInterface &);
+
+        /**
+         * Indicates whether this PDU is fragmented.
+         *
+         * \return true if this PDU is fragmented, false otherwise.
+         */
+        bool is_fragmented() const;
 
         /**
          * \brief Getter for the PDU's type.
@@ -558,17 +610,6 @@ namespace Tins {
          */
         PDUType pdu_type() const { return PDU::IP; }
 
-        /**
-         * \brief Clones this pdu, filling the corresponding header with data
-         * extracted from a buffer.
-         *
-         * \param ptr The pointer to the from from which the data will be extracted.
-         * \param total_sz The size of the buffer.
-         * \return The cloned PDU.
-         * \sa PDU::clone_packet
-         */
-        PDU *clone_packet(const uint8_t *ptr, uint32_t total_sz);
-
         /**
          * \sa PDU::clone
          */
@@ -578,15 +619,14 @@ namespace Tins {
     private:
         static const uint8_t DEFAULT_TTL;
 
+        TINS_BEGIN_PACK
         struct iphdr {
         #if TINS_IS_LITTLE_ENDIAN
-            unsigned int ihl:4;
-            unsigned int version:4;
-        #elif TINS_IS_BIG_ENDIAN
-            unsigned int version:4;
-            unsigned int ihl:4;
+            uint8_t ihl:4,
+                    version:4;
         #else
-        # error "Endian is not LE nor BE..."
+            uint8_t version:4,
+                    ihl:4;
         #endif
             uint8_t tos;
             uint16_t tot_len;
@@ -598,18 +638,25 @@ namespace Tins {
             uint32_t saddr;
             uint32_t daddr;
             /*The options start here. */
-        } __attribute__((__packed__));
+        } TINS_END_PACK;
 
+
+        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 init_ip_fields();
         void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
-        uint8_t* write_option(const ip_option &opt, uint8_t* buffer);
+        uint8_t* write_option(const option &opt, uint8_t* buffer);
         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);
 
         iphdr _ip;
-        std::list<ip_option> _ip_options;
-        uint32_t _options_size, _padded_options_size;
+        uint16_t _options_size, _padded_options_size;
+        options_type _ip_options;
     };
-};
+}
 
 #endif // TINS_IP_H

include/ip_address.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -33,110 +33,167 @@
 #include <string>
 #include <iostream>
 #include <stdint.h>
+#include "cxxstd.h"
 
 namespace Tins {
+/**
+ * \class IPv4Address
+ * \brief Abstraction of an IPv4 address.
+ */
+class IPv4Address {
+public:
     /**
-     * \class IPv4Address
-     * \brief Abstraction of an IPv4 address.
+     * The address size.
      */
-    class IPv4Address {
-    public:
-        /**
-         * The address size.
-         */
-        static const size_t address_size = sizeof(uint32_t);
-        
-        /**
-         * \brief Constructor taking a const char*.
-         * 
-         * Constructs an IPv4Address from a dotted-notation address 
-         * cstring. If the pointer provided is null, then a default 
-         * IPv4Address object is constructed, which corresponds to 
-         * the 0.0.0.0 address.
-         * 
-         * \param ip const char* containing the dotted-notation address.
-         */
-        IPv4Address(const char *ip = 0);
-        
-        /**
-         * \brief Constructor taking a std::string.
-         * 
-         * Constructs an IPv4Address from a dotted-notation std::strings
-         * 
-         * \param ip std::string containing the dotted-notation address.
-         */
-        IPv4Address(const std::string &ip);
-        
-        /**
-         * \brief Constructor taking a IP address represented as a
-         * big endian integer.
-         * 
-         * This constructor should be used internally by PDUs that
-         * handle IP addresses. The provided integer <b>must</b> be
-         * be in big endian.
-         */
-        explicit IPv4Address(uint32_t ip);
-        
-        /**
-         * \brief User defined conversion to big endian integral value.
-         */
-        operator uint32_t() const;
-        
-        /**
-         * \brief Retrieve the string representation of this address.
-         * 
-         * \return std::string containing the representation of this address.
-         */
-        std::string to_string() const;
-        
-        /**
-         * \brief Compare this IPv4Address for equality.
-         * 
-         * \param rhs The address to be compared.
-         * \return bool indicating whether this address equals rhs.
-         */
-        bool operator==(const IPv4Address &rhs) const {
-            return ip_addr == rhs.ip_addr;
-        }
-        
-        /**
-         * \brief Compare this IPv4Address for inequality.
-         * 
-         * \param rhs The address to be compared.
-         * \return bool indicating whether this address is distinct 
-         * from rhs.
-         */
-        bool operator!=(const IPv4Address &rhs) const {
-            return !(*this == rhs);
-        }
-        
-        /**
-         * \brief Compare this IPv4Address for less-than inequality.
-         * 
-         * \param rhs The address to be compared.
-         * \return bool indicating whether this address is less-than rhs.
-         */
-        bool operator< (const IPv4Address &rhs) const {
-            return ip_addr < rhs.ip_addr;
-        }
-        
-        /**
-         * \brief Writes this address to a std::ostream.
-         * 
-         * This method writes addr in a dotted-string notation address
-         * to the std::ostream argument.
-         * 
-         * \param output The std::ostream in which to write the address.
-         * \param addr The IPv4Address to be written.
-         * \return std::stream& pointing to output.
-         */
-        friend std::ostream &operator<<(std::ostream &output, const IPv4Address &addr);
-    private:
-        uint32_t ip_to_int(const std::string &ip);
+    static const size_t address_size = sizeof(uint32_t);
+
+    /**
+     * The broadcast address.
+     */
+    static const IPv4Address broadcast;
+
+    /**
+     * \brief Constructor taking a const char*.
+     * 
+     * Constructs an IPv4Address from a dotted-notation address 
+     * cstring. If the pointer provided is null, then a default 
+     * IPv4Address object is constructed, which corresponds to 
+     * the 0.0.0.0 address.
+     * 
+     * \param ip const char* containing the dotted-notation address.
+     */
+    IPv4Address(const char *ip = 0);
     
-        uint32_t ip_addr;
-    };
+    /**
+     * \brief Constructor taking a std::string.
+     * 
+     * Constructs an IPv4Address from a dotted-notation std::strings
+     * 
+     * \param ip std::string containing the dotted-notation address.
+     */
+    IPv4Address(const std::string &ip);
+    
+    /**
+     * \brief Constructor taking a IP address represented as a
+     * big endian integer.
+     * 
+     * This constructor should be used internally by PDUs that
+     * handle IP addresses. The provided integer <b>must</b> be
+     * be in big endian.
+     */
+    explicit IPv4Address(uint32_t ip);
+    
+    /**
+     * \brief User defined conversion to big endian integral value.
+     */
+    operator uint32_t() const;
+    
+    /**
+     * \brief Retrieve the string representation of this address.
+     * 
+     * \return std::string containing the representation of this address.
+     */
+    std::string to_string() const;
+    
+    /**
+     * \brief Compare this IPv4Address for equality.
+     * 
+     * \param rhs The address to be compared.
+     * \return bool indicating whether this address equals rhs.
+     */
+    bool operator==(const IPv4Address &rhs) const {
+        return ip_addr == rhs.ip_addr;
+    }
+    
+    /**
+     * \brief Compare this IPv4Address for inequality.
+     * 
+     * \param rhs The address to be compared.
+     * \return bool indicating whether this address is distinct 
+     * from rhs.
+     */
+    bool operator!=(const IPv4Address &rhs) const {
+        return !(*this == rhs);
+    }
+    
+    /**
+     * \brief Compare this IPv4Address for less-than inequality.
+     * 
+     * \param rhs The address to be compared.
+     * \return bool indicating whether this address is less-than rhs.
+     */
+    bool operator< (const IPv4Address &rhs) const {
+        return ip_addr < rhs.ip_addr;
+    }
+    
+    /**
+     * \brief Returns true if this is a private IPv4 address.
+     * 
+     * This takes into account the private network ranges defined in
+     * RFC 1918. Therefore, this method returns true if this address
+     * is in any of the following network ranges, false otherwise:
+     * 
+     * - 192.168.0.0/16
+     * - 10.0.0.0/8
+     * - 172.16.0.0/12
+     */
+    bool is_private() const;
+    
+    /**
+     * \brief Returns true if this is a loopback IPv4 address.
+     * 
+     * This method returns true if this address is in the address range
+     * 127.0.0.0/8, false otherwise.
+     */
+    bool is_loopback() const;
+
+    /**
+     * \brief Returns true if this is a multicast IPv4 address.
+     * 
+     * This method returns true if this address is in the address range
+     * 224.0.0.0/4, false otherwise.
+     */
+    bool is_multicast() const;
+
+    /**
+     * \brief Returns true if this is an unicast IPv4 address.
+     */
+    bool is_unicast() const;
+
+    /**
+     * \brief Returns true if this is a broadcast IPv4 address.
+     */
+    bool is_broadcast() const;
+    
+    /**
+     * \brief Writes this address to a std::ostream.
+     * 
+     * This method writes addr in a dotted-string notation address
+     * to the std::ostream argument.
+     * 
+     * \param output The std::ostream in which to write the address.
+     * \param addr The IPv4Address to be written.
+     * \return std::stream& pointing to output.
+     */
+    friend std::ostream &operator<<(std::ostream &output, const IPv4Address &addr);
+private:
+    uint32_t ip_to_int(const std::string &ip);
+
+    uint32_t ip_addr;
 };
+} //namespace Tins
+
+#if TINS_IS_CXX11
+namespace std
+{
+template<>
+struct hash<Tins::IPv4Address> {
+    size_t operator()(const Tins::IPv4Address &addr) const {
+        return std::hash<uint32_t>()(addr);
+    }
+};
+} // namespace std
+#endif
 
 
 #endif // TINS_IPADDRESS_H

include/ip_reassembler.h

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

include/ipsec.h

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

include/ipv6.h

@@ -0,0 +1,330 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_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"
+
+namespace Tins {
+class PacketSender;
+    
+/**
+ * Represents an IPv6 PDU.
+ */
+class IPv6 : public PDU {
+public:
+    /**
+     * This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::IPv6;
+    
+    /**
+     * The type used to store addresses.
+     */
+    typedef IPv6Address address_type;
+    
+    /**
+     * The type used to represent IPv6 extension headers.
+     */
+    typedef PDUOption<uint8_t, IPv6> ext_header;
+    
+    /**
+     * The type used to store the extension headers.
+     */
+    typedef std::list<ext_header> headers_type;
+
+    /**
+     * The values used to identify extension headers.
+     */
+    enum ExtensionHeader {
+        HOP_BY_HOP = 0,
+        DESTINATION_ROUTING_OPTIONS = 60,
+        ROUTING = 43,
+        FRAGMENT = 44,
+        AUTHENTICATION = 51,
+        SECURITY_ENCAPSULATION = 50,
+        DESTINATION_OPTIONS = 60,
+        MOBILITY = 135,
+        NO_NEXT_HEADER = 59
+    };
+
+    /**
+     * \brief Constructs an IPv6 object.
+     * 
+     * \param ip_dst The destination ip address(optional).
+     * \param ip_src The source ip address(optional).
+     * \param child pointer to a PDU which will be set as the inner_pdu 
+     * for the packet being constructed(optional).
+     */
+    IPv6(address_type ip_dst = address_type(), 
+        address_type ip_src = address_type(), 
+        PDU *child = 0);
+
+    /**
+     * \brief Constructs an IPv6 object from a buffer and adds all 
+     * identifiable PDUs found in the buffer as children of this one.
+     * 
+     * If there is not enough size for an IPv6 header, a malformed_packet
+     * exception is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    IPv6(const uint8_t *buffer, uint32_t total_sz);
+
+    // Getters
+
+    /**
+     * \brief Getter for the version field.
+     *  \return The stored version field value.
+     */
+    small_uint<4> version() const {
+        return _header.version;
+    }
+
+    /**
+     * \brief Getter for the traffic_class field.
+     *  \return The stored traffic_class field value.
+     */
+    uint8_t traffic_class() const {
+        #if TINS_IS_LITTLE_ENDIAN
+        return ((_header.traffic_class << 4) & 0xf0) | 
+                ((_header.flow_label[0] >> 4) & 0x0f);
+        #else
+        return _header.traffic_class;
+        #endif
+    }
+
+    /**
+     * \brief Getter for the flow_label field.
+     *  \return The stored flow_label field value.
+     */
+    small_uint<20> flow_label() const {
+        #if TINS_IS_LITTLE_ENDIAN
+        return ((_header.flow_label[0] & 0x0f) << 16)
+                | (_header.flow_label[1] << 8)
+                | (_header.flow_label[2]);
+        #else
+        return _header.flow_label;
+        #endif
+    }
+
+    /**
+     * \brief Getter for the payload_length field.
+     *  \return The stored payload_length field value.
+     */
+    uint16_t payload_length() const {
+        return Endian::be_to_host(_header.payload_length);
+    }
+
+    /**
+     * \brief Getter for the next_header field.
+     *  \return The stored next_header field value.
+     */
+    uint8_t next_header() const {
+        return _header.next_header;
+    }
+
+    /**
+     * \brief Getter for the hop_limit field.
+     *  \return The stored hop_limit field value.
+     */
+    uint8_t hop_limit() const {
+        return _header.hop_limit;
+    }
+
+    /**
+     * \brief Getter for the src_addr field.
+     *  \return The stored src_addr field value.
+     */
+    address_type src_addr() const {
+        return _header.src_addr;
+    }
+
+    /**
+     * \brief Getter for the dst_addr field.
+     *  \return The stored dst_addr field value.
+     */
+    address_type dst_addr() const {
+        return _header.dst_addr;
+    }
+
+    /**
+     * \brief Getter for the IPv6 extension headers.
+     *  \return The stored headers.
+     */
+    const headers_type& headers() const {
+        return ext_headers;
+    }
+
+    // Setters
+
+    /**
+     * \brief Setter for the version field.
+     * \param new_version The new version field value.
+     */
+    void version(small_uint<4> new_version);
+
+    /**
+     * \brief Setter for the traffic_class field.
+     * \param new_traffic_class The new traffic_class field value.
+     */
+    void traffic_class(uint8_t new_traffic_class);
+
+    /**
+     * \brief Setter for the flow_label field.
+     * \param new_flow_label The new flow_label field value.
+     */
+    void flow_label(small_uint<20> new_flow_label);
+
+    /**
+     * \brief Setter for the payload_length field.
+     * \param new_payload_length The new payload_length field value.
+     */
+    void payload_length(uint16_t new_payload_length);
+
+    /**
+     * \brief Setter for the next_header field.
+     * \param new_next_header The new next_header field value.
+     */
+    void next_header(uint8_t new_next_header);
+
+    /**
+     * \brief Setter for the hop_limit field.
+     * \param new_hop_limit The new hop_limit field value.
+     */
+    void hop_limit(uint8_t new_hop_limit);
+
+    /**
+     * \brief Setter for the src_addr field.
+     * \param new_src_addr The new src_addr field value.
+     */
+    void src_addr(const address_type &new_src_addr);
+
+    /**
+     * \brief Setter for the dst_addr field.
+     * \param new_dst_addr The new dst_addr field value.
+     */
+    void dst_addr(const address_type &new_dst_addr);
+    
+    /**
+     * \brief Returns the header size.
+     *
+     * This metod overrides PDU::header_size. \sa PDU::header_size
+     */
+    uint32_t header_size() const;
+    
+    /** 
+     * \brief Check wether ptr points to a valid response for this PDU.
+     *
+     * \sa PDU::matches_response
+     * \param ptr The pointer to the buffer.
+     * \param total_sz The size of the buffer.
+     */
+    bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
+    
+    /**
+     * \sa PDU::clone
+     */
+    IPv6 *clone() const {
+        return new IPv6(*this);
+    }
+    
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+    
+    #ifndef BSD
+    /**
+     * \sa PDU::send()
+     */
+    void send(PacketSender &sender, const NetworkInterface &);
+    #endif
+    
+    /**
+     * Adds an extension header.
+     * 
+     * \param header The extension header to be added.
+     */
+    void add_ext_header(const ext_header &header);
+    
+    /**
+     * \brief Searchs for an extension header that matchs the given 
+     * flag.
+     * 
+     * If the header is not found, a null pointer is returned. 
+     * Deleting the returned pointer will result in <b>undefined 
+     * behaviour</b>.
+     * 
+     * \param id The header identifier to be searched.
+     */
+    const ext_header *search_header(ExtensionHeader id) const;
+private:
+    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
+    void set_last_next_header(uint8_t value);
+    static uint8_t *write_header(const ext_header &header, uint8_t *buffer);
+    static bool is_extension_header(uint8_t header_id);
+
+    TINS_BEGIN_PACK
+    struct ipv6_header {
+        #if TINS_IS_BIG_ENDIAN
+        uint32_t version:4,
+                traffic_class:8,
+                flow_label:20;
+        uint32_t payload_length:16,
+                next_header:8,
+                hop_limit:8;
+        #else
+        uint8_t traffic_class:4,
+                version:4;
+        uint8_t flow_label[3];
+        uint16_t payload_length;
+        uint8_t next_header;
+        uint8_t hop_limit;
+        #endif
+        uint8_t src_addr[16], dst_addr[16];
+    } TINS_END_PACK;
+
+    ipv6_header _header;
+    headers_type ext_headers;
+    uint32_t headers_size;
+};
+}
+
+#endif // TINS_IPV6_h

include/ipv6_address.h

@@ -0,0 +1,230 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_IPV6_ADDRESS
+#define TINS_IPV6_ADDRESS
+
+#include <string>
+#include <stdexcept>
+#include <stdint.h>
+#include "cxxstd.h"
+
+namespace Tins {
+
+/**
+ * Represents an IPv6 address.
+ */
+class IPv6Address {
+public:
+    /**
+     * The exception thrown when a malformed address is parsed.
+     */
+    class malformed_address : public std::exception {
+    public:
+        const char *what() const throw() {
+            return "Malformed address";
+        }
+    };
+    
+    static const size_t address_size = 16;
+    
+    /**
+     * The iterator type.
+     */
+    typedef uint8_t* iterator;
+    
+    /**
+     * The const iterator type.
+     */
+    typedef const uint8_t* const_iterator;
+
+    /**
+     * \brief Default constructor.
+     * Initializes this IPv6 address to "::"
+     */
+    IPv6Address();
+    
+    /**
+     * \brief Constructor from a text representation char*.
+     * \param addr The text representation from which to construct this
+     * object.
+     */
+    IPv6Address(const char *addr);
+    
+    /**
+     * \brief Constructor from a text representation std::string.
+     * \param addr The text representation from which to construct this
+     * object.
+     */
+    IPv6Address(const std::string &addr);
+    
+    /**
+     * \brief Constructor from a buffer.
+     * 
+     * The ptr parameter must be at least address_size bytes long.
+     * 
+     * \param ptr The buffer from which to construct this object.
+     */
+    IPv6Address(const_iterator ptr);
+    
+    /**
+     * \brief Retrieve the string representation of this address.
+     * 
+     * \return std::string containing the representation of this address.
+     */
+    std::string to_string() const;
+    
+    /**
+     * Returns an iterator to the beginning of this address.
+     */
+    iterator begin() {
+        return address;
+    }
+    
+    /**
+     * Returns a const iterator to the beginning of this address.
+     */
+    const_iterator begin() const {
+        return address;
+    }
+    
+    /**
+     * Returns an iterator to the one-past-the-end element of this address.
+     */
+    iterator end() {
+        return address + address_size;
+    }
+    
+    /**
+     * Returns a const iterator to the one-past-the-end element of this 
+     * address.
+     */
+    const_iterator end() const {
+        return address + address_size;
+    }
+    
+    /**
+     * \brief Compares this address for equality.
+     * 
+     * \param rhs The address to be compared to.
+     * 
+     * \return bool indicating whether addresses are equal.
+     */
+    bool operator==(const IPv6Address &rhs) const {
+        return std::equal(begin(), end(), rhs.begin());
+    }
+    
+    /**
+     * \brief Compares this address for inequality.
+     * 
+     * \param rhs The address to be compared to.
+     * 
+     * \return bool indicating whether addresses are distinct.
+     */
+    bool operator!=(const IPv6Address &rhs) const {
+        return !(*this == rhs);
+    }
+    
+    /**
+     * \brief Compares this address for less-than inequality.
+     * 
+     * \param rhs The address to be compared to.
+     * 
+     * \return bool indicating whether this address is less-than rhs.
+     */
+    bool operator<(const IPv6Address &rhs) const {
+        return std::lexicographical_compare(begin(), end(), rhs.begin(), rhs.end());
+    }
+    
+    /**
+     * \brief Helper function which copies the address into an output
+     * iterator.
+     * 
+     * This is the same as:
+     * 
+     * std::copy(begin(), end(), iter);
+     * 
+     * But since some PDUs return a IPv6Address by value, this function
+     * can be used to avoid temporaries. 
+     * 
+     * \param iter The output iterator in which to store this address.
+     * \return OutputIterator pointing to one-past the last position
+     * written.
+     */
+    template<typename OutputIterator>
+    OutputIterator copy(OutputIterator iter) const {
+        return std::copy(begin(), end(), iter);
+    }
+    
+    /**
+     * \brief Returns true if this is a loopback IPv6 address.
+     * 
+     * This method returns true if this address is the ::1/128 address,
+     * false otherwise.
+     */
+    bool is_loopback() const;
+
+    /**
+     * \brief Returns true if this is a multicast IPv6 address.
+     * 
+     * This method returns true if this address is in the address range
+     * ff00::/8, false otherwise.
+     */
+    bool is_multicast() const;
+    
+    /**
+     * \brief Writes this address in hex-notation to a std::ostream.
+     * 
+     * \param os The stream in which to write the address.
+     * \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();
+    }
+private:
+    void init(const char *addr);
+
+    uint8_t address[address_size];
+};
+} //namespace Tins
+
+#if TINS_IS_CXX11
+namespace std
+{
+template<>
+struct hash<Tins::IPv6Address> {
+    size_t operator()(const Tins::IPv6Address &addr) const {
+        return std::hash<std::string>()(addr.to_string());
+    }
+};
+} // namespace std
+#endif
+
+#endif // TINS_IPV6_ADDRESS

include/llc.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -33,6 +33,7 @@
 #include <list>
 #include <vector>
 #include <stdint.h>
+#include "macros.h"
 #include "pdu.h"
 #include "endianness.h"
 
@@ -54,6 +55,10 @@ namespace Tins {
          * \brief Represents the LLC global DSAP address.
          */
         static const uint8_t GLOBAL_DSAP_ADDR;
+        
+        /**
+         * \brief Represents the LLC NULL address.
+         */
         static const uint8_t NULL_ADDR;
 
         /**
@@ -89,22 +94,25 @@ namespace Tins {
         };
 
         /**
-         * \brief Creates an instance of LLC
-         * \param child The child PDU.(optional)
+         * \brief Default constructor.
          */
-    	LLC(PDU *child = 0);
+    	LLC();
 
     	/**
-    	 * \brief Creates an instance of LLC, setting the dsap and ssap.
-    	 * The control field is set all to 0.
-    	 * @param dsap The dsap value to be set.
-    	 * @param ssap The ssap value to be set.
+    	 * \brief Constructs an instance of LLC, setting the dsap and ssap.
+    	 * The control field is set to 0.
+    	 * \param dsap The dsap value to be set.
+    	 * \param ssap The ssap value to be set.
     	 */
-    	LLC(uint8_t dsap, uint8_t ssap, PDU* child = 0);
+    	LLC(uint8_t dsap, uint8_t ssap);
 
         /**
-         * \brief Constructor which creates a LLC object from a buffer and adds all identifiable
-         * PDUs found in the buffer as children of this one.
+         * \brief Constructs a LLC object from a buffer and adds all 
+         * identifiable PDUs found in the buffer as children of this one.
+         * 
+         * If there is not enough size for a LLC header, a malformed_packet
+         * exception is thrown.
+         * 
          * \param buffer The buffer from which this PDU will be constructed.
          * \param total_sz The total size of the buffer.
          */
@@ -298,7 +306,7 @@ namespace Tins {
          * \brief Getter for the PDU's type.
          * \sa PDU::pdu_type
          */
-        PDUType pdu_type() const { return PDU::LLC; }
+        PDUType pdu_type() const { return pdu_flag; }
 
         /**
 		 * \brief Delete all the information fields added.
@@ -314,62 +322,67 @@ namespace Tins {
             return new LLC(*this);
         }
     private:
+        TINS_BEGIN_PACK
         struct llchdr {
             uint8_t dsap;
             uint8_t ssap;
-        } __attribute__((__packed__));
+        } TINS_END_PACK;
 
         #if TINS_IS_LITTLE_ENDIAN
+            TINS_BEGIN_PACK
             struct info_control_field {
                 uint16_t
                             type_bit:1,
                             send_seq_num:7,
                             poll_final_bit:1,
                             recv_seq_num:7;
-            } __attribute__((__packed__));
+            } TINS_END_PACK;
 
+            TINS_BEGIN_PACK
             struct super_control_field {
                 uint16_t	type_bit:2,
                             supervisory_func:2,
                             unused:4,
                             poll_final_bit:1,
                             recv_seq_num:7;
-            } __attribute__((__packed__));
+            } TINS_END_PACK;
 
+            TINS_BEGIN_PACK
             struct un_control_field {
                 uint8_t		type_bits:2,
                             mod_func1:2,
                             poll_final_bit:1,
                             mod_func2:3;
-            } __attribute__((__packed__));
+            } TINS_END_PACK;
         #elif TINS_IS_BIG_ENDIAN
+            TINS_BEGIN_PACK
             struct info_control_field {
                 uint16_t    send_seq_num:7,
                             type_bit:1,
                             recv_seq_num:7,
                             poll_final_bit:1;
-            } __attribute__((__packed__));
+            } TINS_END_PACK;
 
+            TINS_BEGIN_PACK
             struct super_control_field {
                 uint16_t	unused:4,
                             supervisory_func:2,
                             type_bit:2,
                             recv_seq_num:7,
                             poll_final_bit:1;
-            } __attribute__((__packed__));
+            } TINS_END_PACK;
 
+            TINS_BEGIN_PACK
             struct un_control_field {
                 uint8_t		mod_func2:3,
                             poll_final_bit:1,
                             mod_func1:2,
                             type_bits:2;
-            } __attribute__((__packed__));
-
+            } TINS_END_PACK;
         #endif
         
         typedef std::vector<uint8_t> field_type;
 
-        void copy_fields(const LLC *other);
         void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
 
         llchdr _header;
@@ -384,6 +397,6 @@ namespace Tins {
         std::list<field_type> information_fields;
     };
 
-};
+}
 
 #endif // TINS_IEEE8022_H

include/loopback.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,6 +31,7 @@
 #define TINS_LOOPBACK_H
 
 #include "pdu.h"
+#include "macros.h"
 
 namespace Tins {
 class Loopback : public PDU {
@@ -46,17 +47,16 @@ public:
      * The family identifier is left as zero.
      */
     Loopback();
-
-    /**
-     * \brief Construct a Loopback object.
-     * 
-     * \param family_id The family id to be used.
-     * \param inner_pdu The inner pdu to be set.
-     */
-    Loopback(uint32_t family_id, PDU *inner_pdu = 0);
     
     /**
-     * \brief Construct a Loopback object from a buffer.
+     * \brief Construct a Loopback object from a buffer and adds 
+     * all identifiable PDUs found in the buffer as children of 
+     * this one. 
+     * 
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for a Loopback header, a 
+     * malformed_packet exception is thrown.
      * 
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
@@ -84,7 +84,7 @@ public:
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return PDU::IP; }
+    PDUType pdu_type() const { return pdu_flag; }
     
     /**
      * \sa PDU::clone
@@ -92,6 +92,13 @@ public:
     Loopback *clone() const {
         return new Loopback(*this);
     }
+    // Null/Loopback can only be sent in *BSD
+    #ifdef BSD
+    /**
+     * \sa PDU::send()
+     */
+    void send(PacketSender &sender, const NetworkInterface &iface);
+    #endif // BSD
 private:
     void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
 

include/macros.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_MACROS_H
+#define TINS_MACROS_H
+
+#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
+    #include <sys/param.h>
+#endif
+
+// Packing directives....
+#ifdef _MSC_VER
+    #define TINS_BEGIN_PACK __pragma( pack(push, 1) )
+    #define TINS_END_PACK __pragma( pack(pop) )
+    #define TINS_PACKED(DECLARATION) __pragma( pack(push, 1) ) DECLARATION __pragma( pack(pop) )
+    #define TINS_DEPRECATED(func) __declspec(deprecated) func
+    #define NOEXCEPT
+#else
+    #define TINS_BEGIN_PACK 
+    #define TINS_END_PACK __attribute__((packed))
+    #define TINS_PACKED(DECLARATION) DECLARATION __attribute__((packed))
+    #define TINS_DEPRECATED(func) func __attribute__ ((deprecated))
+    #define NOEXCEPT noexcept
+#endif
+
+#endif

include/network_interface.h

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

include/packet.h

@@ -0,0 +1,310 @@
+/*
+ * Copyright (c) 2014, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_PACKET_H
+#define TINS_PACKET_H
+
+#include <algorithm>
+#include "cxxstd.h"
+#include "pdu.h"
+#include "timestamp.h"
+
+/**
+ * \namespace Tins
+ */
+namespace Tins {
+template<typename WrappedType, typename TimestampType>
+class PacketWrapper;
+
+
+/**
+ * \brief Thin wrapper over a PDU and Timestamp reference.
+ */
+typedef PacketWrapper<PDU&, const Timestamp&> RefPacket;
+
+/**
+ * \brief Thin wrapper over a PDU pointer and a Timestamp.
+ */
+typedef PacketWrapper<PDU*, Timestamp> PtrPacket;
+
+/**
+ * \brief Represents a sniffed packet.
+ * 
+ * RefPackets contain a PDU reference and a timestamp. The difference between
+ * this class and the Packet class is that this one contains a reference
+ * to a PDU, and not a pointer to one. 
+ * 
+ * This class is only used in some BaseSniffer methods as a thin wrapper 
+ * to a PDU pointer/reference. Only BaseSniffer and derived objects can
+ * create instances of it.
+ */
+template<typename PDUType, typename TimestampType>
+class PacketWrapper {
+public:
+    typedef PDUType pdu_type;
+    typedef TimestampType timestamp_type;
+    
+    /**
+     * \brief User defined conversion to wrapped_type.
+     * 
+     * This conversion is defined so that BaseSniffer::sniff_loop callback 
+     * or code that calls BaseSniffer::next_packet can still receive a 
+     * PDU pointer/reference without modifying the code at all.
+     */
+    operator pdu_type() {
+        return pdu_;
+    }
+    
+    /**
+     * \brief Returns the wrapped_type.
+     */
+    pdu_type pdu() {
+        return pdu_;
+    }
+    
+    /**
+     * \brief Returns the PDU const reference.
+     */
+    const pdu_type pdu() const {
+        return pdu_;
+    }
+    
+    /**
+     * \brief Returns the packet timestamp.
+     * 
+     * This is the timestamp in which the packet was taken out of the
+     * network interface/pcap file.
+     */
+    const Timestamp &timestamp() const {
+        return ts_;
+    }
+private:
+    friend class BaseSniffer;
+    
+    PacketWrapper(pdu_type pdu, const Timestamp &ts) 
+    : pdu_(pdu), ts_(ts) {}
+    
+    PacketWrapper(const PacketWrapper&);
+    PacketWrapper& operator=(const PacketWrapper&);
+    void* operator new (size_t size);
+    void operator delete (void *p);
+
+    pdu_type pdu_;
+    timestamp_type ts_;
+};
+
+/**
+ * \class Represents a sniffed packet.
+ * 
+ * A Packet contains a PDU pointer and a Timestamp object. Packets
+ * <b>will delete</b> the stored PDU* unless you call release_pdu at 
+ * some point before destruction. 
+ */
+class Packet {
+public:
+    /**
+     * Tag used to specify that a Packet should own a PDU pointer.
+     */
+    struct own_pdu {
+
+    };
+
+    /**
+     * \brief Default constructs a Packet.
+     * 
+     * The PDU* will be set to a null pointer.
+     */
+    Packet() 
+    : pdu_(0) { }
+    
+    /**
+     * \brief Constructs a Packet from a PDU* and a Timestamp.
+     * 
+     * The PDU* is cloned using PDU::clone.
+     */
+    Packet(const PDU *apdu, const Timestamp &tstamp) 
+    : pdu_(apdu->clone()), ts(tstamp) { }
+
+    /**
+     * \brief Constructs a Packet from a PDU* and a Timestamp.
+     * 
+     * The PDU* will be owned by the Packet. This means you
+     * <b>do not</b> have to explicitly delete the pointer, that
+     * will be done automatically by the Packet when it goes out
+     * of scope.
+     */
+    Packet(PDU *apdu, const Timestamp &tstamp, own_pdu) 
+    : pdu_(apdu), ts(tstamp) { }
+    
+    /**
+     * \brief Constructs a Packet from a const PDU&.
+     * 
+     * The timestamp will be set to the current time.
+     * 
+     * This calls PDU::clone on the PDU parameter.
+     * 
+     */
+    Packet(const PDU &rhs) 
+    : pdu_(rhs.clone()), ts(Timestamp::current_time()) { }
+    
+    /**
+     * \brief Constructs a Packet from a RefPacket.
+     * 
+     * This calls PDU::clone on the RefPacket's PDU.
+     * 
+     */
+    Packet(const RefPacket &pck) 
+    : pdu_(pck.pdu().clone()), ts(pck.timestamp()) { }
+
+    /**
+     * \brief Constructs a Packet from a PtrPacket object.
+     */
+    Packet(const PtrPacket &pck)
+    : pdu_(pck.pdu()), ts(pck.timestamp()) { }
+    
+    /**
+     * \brief Copy constructor.
+     * 
+     * This calls PDU::clone on the rhs's PDU* member.
+     */
+    Packet(const Packet &rhs) : ts(rhs.timestamp()) {
+        pdu_ = rhs.pdu() ? rhs.pdu()->clone() : 0;
+    }
+    
+    /**
+     * \brief Copy assignment operator.
+     * 
+     * This calls PDU::clone on the rhs's PDU* member.
+     */
+    Packet& operator=(const Packet &rhs) {
+        if(this != &rhs) {
+            delete pdu_;
+            ts = rhs.timestamp();
+            pdu_ = rhs.pdu() ? rhs.pdu()->clone() : 0;
+        }
+        return *this;
+    }
+    
+    #if TINS_IS_CXX11
+    /**
+     * Move constructor.
+     */
+    Packet(Packet &&rhs) NOEXCEPT : pdu_(rhs.pdu()), ts(rhs.timestamp()) {
+        rhs.pdu_ = nullptr;
+    }
+    
+    /**
+     * Move assignment operator.
+     */
+    Packet& operator=(Packet &&rhs) NOEXCEPT { 
+        if(this != &rhs) {
+            std::swap(pdu_, rhs.pdu_);
+            ts = rhs.timestamp();
+        }
+        return *this;
+    }
+    #endif
+    
+    /**
+     * \brief Packet destructor.
+     * 
+     * This calls operator delete on the stored PDU*.
+     */
+    ~Packet() {
+        delete pdu_;
+    }
+    
+    /**
+     * Returns this Packet's timestamp.
+     */
+    const Timestamp &timestamp() const {
+        return ts;
+    }
+    
+    /**
+     * \brief Returns the stored PDU*. 
+     * 
+     * Caller <b>must not</b> delete the pointer. \sa Packet::release_pdu
+     */
+    PDU *pdu() {
+        return pdu_;
+    }
+    
+    /**
+     * \brief Returns the stored PDU*. 
+     * 
+     * Caller <b>must not</b> delete the pointer. \sa Packet::release_pdu
+     */
+    const PDU *pdu() const {
+        return pdu_;
+    }
+    
+    /**
+     * \brief Releases ownership of the stored PDU*.
+     * 
+     * This method returns the stored PDU* and sets the stored PDU* to
+     * a null pointer, so the destructor will be well behaved. Use this
+     * method if you want to keep the internal PDU* somewhere. Otherwise,
+     * when Packet's destructor is called, the stored pointer will be 
+     * deleted.
+     */
+    PDU *release_pdu() {
+        PDU *some_pdu = pdu_;
+        pdu_ = 0;
+        return some_pdu;
+    }
+    
+    /**
+     * \brief Tests whether this is Packet contains a valid PDU.
+     * 
+     * \return true if pdu() == nullptr, false otherwise.
+     */
+    operator bool() const {
+        return pdu_ ? true : false;
+    }
+    
+    /**
+     * 
+     * \brief Concatenation operator.
+     * 
+     * Adds the PDU at the end of the PDU stack. 
+     * 
+     * \param rhs The PDU to be appended.
+     */
+    Packet &operator/=(const PDU &rhs) {
+        pdu_ /= rhs;
+        return *this;
+    }
+private:
+    PDU *pdu_;
+    Timestamp ts;
+};
+}
+
+#endif // TINS_PACKET_H

include/packet_sender.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2014, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -36,12 +36,16 @@
 #include <vector>
 #include <stdint.h>
 #include <map>
+#include "network_interface.h"
+#include "macros.h"
+#include "cxxstd.h"
 
 struct timeval;
+struct sockaddr;
 
 namespace Tins {
     class PDU;
-
+    
     /**
      * \brief Class that enables sending the created PDUs
      *
@@ -60,18 +64,55 @@ namespace Tins {
          */
         enum SocketType {
             ETHER_SOCKET,
-            IP_SOCKET,
+            IP_TCP_SOCKET,
+            IP_UDP_SOCKET,
+            IP_RAW_SOCKET,
             ARP_SOCKET,
             ICMP_SOCKET,
+            IPV6_SOCKET,
             SOCKETS_END
         };
 
         /**
          * \brief Constructor for PacketSender objects.
          * 
+         * \param iface The default interface in which to send the packets.
          * \param recv_timeout The timeout which will be used when receiving responses.
          */
-        PacketSender(uint32_t recv_timeout = DEFAULT_TIMEOUT, uint32_t usec = 0);
+        PacketSender(const NetworkInterface &iface = NetworkInterface(), 
+          uint32_t recv_timeout = DEFAULT_TIMEOUT, uint32_t usec = 0);
+        
+        #if TINS_IS_CXX11
+            /**
+             * \brief Move constructor.
+             * \param rhs The sender to be moved.
+             */
+            PacketSender(PacketSender &&rhs) NOEXCEPT {
+                *this = std::move(rhs);
+            }
+            
+            /**
+             * \brief Move assignment operator.
+             * \param rhs The sender to be moved.
+             */
+            PacketSender& operator=(PacketSender &&rhs) NOEXCEPT {
+                _sockets = std::move(rhs._sockets);
+                rhs._sockets = std::vector<int>(SOCKETS_END, INVALID_RAW_SOCKET);
+                #ifndef WIN32
+                    #if defined(BSD) || defined(__FreeBSD_kernel__)
+                    _ether_socket = std::move(rhs._ether_socket);
+                    #else
+                    _ether_socket = rhs._ether_socket;
+                    rhs._ether_socket = INVALID_RAW_SOCKET;
+                    #endif
+                #endif
+                _types = rhs._types; // no move
+                _timeout = rhs._timeout;
+                _timeout_usec = rhs._timeout_usec;
+                default_iface = rhs.default_iface;
+                return *this;
+            }
+        #endif
         
         /** 
          * \brief PacketSender destructor.
@@ -84,18 +125,18 @@ namespace Tins {
         /** 
          * \brief Opens a layer 2 socket.
          * 
-         * If this operation fails, then a SocketOpenError will be thrown.
+         * If this operation fails, then a socket_open_error will be thrown.
          */
-        void open_l2_socket();
+        void open_l2_socket(const NetworkInterface& iface = NetworkInterface());
         #endif // WIN32
 
         /** 
          * \brief Opens a layer 3 socket, using the corresponding protocol
          * for the given flag.
          * 
-         * If this operation fails, then a SocketOpenError will be thrown.
-         * If the provided socket type is not valid, a InvalidSocketTypeError
-         * will be throw.
+         * If this operation fails, then a socket_open_error will be thrown.
+         * If the provided socket type is not valid, an invalid_socket_type
+         * exception will be throw.
          * 
          * \param type The type of socket which will be used to pick the protocol flag
          * for this socket.
@@ -106,14 +147,29 @@ namespace Tins {
          * \brief Closes the socket associated with the given flag.
          * 
          * If the provided type is invalid, meaning no such open socket
-         * exists, a InvalidSocketTypeError is thrown.
+         * exists, an invalid_socket_type exception is thrown.
          * 
-         * If any socket close errors are encountered, a SocketCloseError
+         * If any socket close errors are encountered, a socket_close_error
          * is thrown.
          * 
          * \param type The type of the socket to be closed.
          */
-        void close_socket(SocketType type);
+        void close_socket(SocketType type, const NetworkInterface &iface = NetworkInterface());
+
+        /**
+         * \brief Sets the default interface.
+         * 
+         * The interface will be used whenever PacketSender::send(PDU&) 
+         * is called.
+         */
+        void default_interface(const NetworkInterface &iface);
+        
+        /**
+         * \brief Gets the default interface.
+         * 
+         * \sa PacketSender::default_interface
+         */
+        const NetworkInterface& default_interface() const;
 
         /** 
          * \brief Sends a PDU. 
@@ -121,11 +177,33 @@ namespace Tins {
          * This method opens the appropriate socket, if it's not open yet, 
          * and sends the PDU on the open socket.
          * 
-         * If any send error occurs, then a SocketWriteError is thrown.
+         * If any send error occurs, then a socket_write_error is thrown.
+         * 
+         * If the PDU contains a link layer protocol, then default_interface
+         * is used.
+         * 
+         * \sa PacketSender::default_interface
          * 
          * \param pdu The PDU to be sent.
          */
         void send(PDU &pdu);
+        
+        /** 
+         * \brief Sends a PDU. 
+         * 
+         * \sa PacketSender::send
+         * 
+         * This overload takes a NetworkInterface. The packet is sent
+         * through that interface if a link-layer PDU is present, 
+         * otherwise this call is equivalent to send(PDU&).
+         * 
+         * The interface stored in the link layer PDU(if any), is restored
+         * after this method ends.
+         * 
+         * \param pdu The PDU to be sent.
+         * \param iface The network interface to use.
+         */
+        void send(PDU &pdu, const NetworkInterface &iface);
 
         /** 
          * \brief Sends a PDU and waits for its response. 
@@ -139,6 +217,20 @@ namespace Tins {
          * \return Returns the response PDU, 0 if not response was received.
          */
         PDU *send_recv(PDU &pdu);
+        
+        /** 
+         * \brief Sends a PDU and waits for its response. 
+         * 
+         * This method is used to send PDUs and receive their response. 
+         * It opens the required socket(if it's not open yet). This can be used
+         * to expect responses for ICMP, ARP, and such packets that are normally
+         * answered by the host that receives the packet.
+         * 
+         * \param pdu The PDU to send.
+         * \param iface The network interface in which to send and receive.
+         * \return Returns the response PDU, 0 if not response was received.
+         */
+        PDU *send_recv(PDU &pdu, const NetworkInterface &iface);
 
         #ifndef WIN32
         /** 
@@ -152,7 +244,8 @@ namespace Tins {
          * \param len_addr The sockaddr struct length.
          * \return Returns the response PDU. If no response is received, then 0 is returned.
          */
-        PDU *recv_l2(PDU &pdu, struct sockaddr *link_addr, uint32_t len_addr);
+        PDU *recv_l2(PDU &pdu, struct sockaddr *link_addr, uint32_t len_addr,
+          const NetworkInterface &iface = NetworkInterface());
 
         /** 
          * \brief Sends a level 2 PDU.
@@ -161,13 +254,14 @@ namespace Tins {
          * using the corresponding flag, according to the given type of 
          * protocol. 
          * 
-         * If any socket write error occurs, a SocketWriteError is thrown.
+         * If any socket write error occurs, a socket_write_error is thrown.
          * 
          * \param pdu The PDU to send.
          * \param link_addr The sockaddr struct which will be used to send the PDU.
          * \param len_addr The sockaddr struct length.
          */
-        void send_l2(PDU &pdu, struct sockaddr* link_addr, uint32_t len_addr);
+        void send_l2(PDU &pdu, struct sockaddr* link_addr, uint32_t len_addr, 
+          const NetworkInterface &iface = NetworkInterface());
         #endif // WIN32
 
         /** 
@@ -190,7 +284,7 @@ namespace Tins {
          * This method sends a layer 3 PDU, using a raw socket, open using the corresponding flag,
          * according to the given type of protocol.
          * 
-         * If any socket write error occurs, a SocketWriteError is thrown.
+         * If any socket write error occurs, a socket_write_error is thrown.
          * 
          * \param pdu The PDU to send.
          * \param link_addr The sockaddr struct which will be used to send the PDU.
@@ -203,41 +297,39 @@ namespace Tins {
 
         typedef std::map<SocketType, int> SocketTypeMap;
 
+        PacketSender(const PacketSender&);
+        PacketSender& operator=(const PacketSender&);
         int find_type(SocketType type);
         int timeval_subtract (struct timeval *result, struct timeval *x, struct timeval *y);
+        #ifndef WIN32
+            bool ether_socket_initialized(const NetworkInterface& iface = NetworkInterface()) const;
+            int get_ether_socket(const NetworkInterface& iface = NetworkInterface());
+        #endif
+        template<typename T>
+        void send(PDU &pdu, const NetworkInterface &iface) {
+            static_cast<T&>(pdu).send(*this, iface);
+        }
         
-        PDU *recv_match_loop(int sock, PDU &pdu, struct sockaddr* link_addr, uint32_t addrlen);
+        PDU *recv_match_loop(const std::vector<int>& sockets, PDU &pdu, struct sockaddr* link_addr, 
+            uint32_t addrlen);
 
         std::vector<int> _sockets;
+        #ifndef WIN32
+            #if defined(BSD) || defined(__FreeBSD_kernel__)
+            typedef std::map<uint32_t, int> BSDEtherSockets;
+            BSDEtherSockets _ether_socket;
+            #else
+            int _ether_socket;
+            #endif
+        #endif
         SocketTypeMap _types;
         uint32_t _timeout, _timeout_usec;
+        NetworkInterface default_iface;
+        // In BSD we need to store the buffer size, retrieved using BIOCGBLEN
+        #if defined(BSD) || defined(__FreeBSD_kernel__)
+        int buffer_size;
+        #endif
     };
-    
-    
-    class SocketOpenError : public std::runtime_error {
-    public:
-        SocketOpenError(const std::string &msg) 
-        : std::runtime_error(msg) { }
-    };
-    
-    class SocketCloseError : public std::runtime_error {
-    public:
-        SocketCloseError(const std::string &msg) 
-        : std::runtime_error(msg) { }
-    };
-    
-    class SocketWriteError : public std::runtime_error {
-    public:
-        SocketWriteError(const std::string &msg) 
-        : std::runtime_error(msg) { }
-    };
-    
-    class InvalidSocketTypeError : public std::exception {
-    public:
-        const char *what() const throw() {
-            return "The provided socket type is invalid";
-        }
-    };
-};
+}
 
 #endif // TINS_PACKET_SENDER_H