Updated the CHANGES file.

The Ethernet II protocol forces a minimum length of 60 bytes. It is necessary to add a trailer for padding of null-bytes when the inner_pdu's size does not meet the requirement.

Also EthernetII packets received were being incorrectly parsed due to the existance of this padding.

The issue has been solved and several tests were added. All tests successfully pass.

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,133 @@
+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.

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

Makefile.am

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

README

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

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.

configure.ac

@@ -1,16 +1,75 @@
-AC_INIT(myconfig, 0.2)
+AC_INIT([libtins], [1.2], [matias.fontanini@gmail.com], [libtins], [http://libtins.sourceforge.net])
+AC_CANONICAL_SYSTEM
+AC_CONFIG_HEADER(include/config.h)
+AM_INIT_AUTOMAKE([-Wall -Werror -Wno-extra-portability foreign])
+LT_INIT([disable-static])
+AC_CONFIG_MACRO_DIR([m4])
+AM_MAINTAINER_MODE([enable])
 
-AC_PROG_CXX()
+AC_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(
+    wpa2, 
+    [  --disable-wpa2          disable WPA2 decryption features], 
+    [],
+    [
+        AC_CHECK_HEADERS(
+            [openssl/evp.h openssl/hmac.h openssl/aes.h], 
+            [], 
+            [AC_MSG_ERROR([openssl headers are missing! $wpa2_msg ])]
+            AC_DEFINE([HAVE_WPA2_DECRYPTION], 0, Have WPA2 decryption library)
+        )
+        AC_CHECK_LIB(
+            crypto, 
+            PKCS5_PBKDF2_HMAC_SHA1, 
+            [], 
+            [AC_MSG_ERROR([openssl library is missing! $wpa2_msg ])]
+        )
+        AC_DEFINE([HAVE_WPA2_DECRYPTION], 1, Have WPA2 decryption library)
+    ]
+)
+
+# Substitute options
+
+AC_SUBST(CXXFLAGS)
+AC_SUBST(LIBS)
+AC_SUBST(LIBTINS_INCLUDE_DIR)
+AC_SUBST([LIBTINS_VERSION], [1:1:0])
+AC_CONFIG_FILES([Makefile libtins.pc])
+AC_OUTPUT

depcomp

@@ -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/arpspoofing.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, 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) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -53,11 +53,11 @@ void BeaconSniffer::run(const std::string &iface) {
  
 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/portscan.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, 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) 2012, 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;
     }

include/address_range.h

@@ -0,0 +1,331 @@
+/*
+ * Copyright (c) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_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) 2012, 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) 2012, 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,86 @@
+/* include/config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* define if the compiler supports basic C++11 syntax */
+#undef HAVE_CXX11
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#undef HAVE_DLFCN_H
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#undef HAVE_INTTYPES_H
+
+/* Define to 1 if you have the `crypto' library (-lcrypto). */
+#undef HAVE_LIBCRYPTO
+
+/* Define to 1 if you have the `pcap' library (-lpcap). */
+#undef HAVE_LIBPCAP
+
+/* Define to 1 if you have the <memory.h> header file. */
+#undef HAVE_MEMORY_H
+
+/* Define to 1 if you have the <openssl/aes.h> header file. */
+#undef HAVE_OPENSSL_AES_H
+
+/* Define to 1 if you have the <openssl/evp.h> header file. */
+#undef HAVE_OPENSSL_EVP_H
+
+/* Define to 1 if you have the <openssl/hmac.h> header file. */
+#undef HAVE_OPENSSL_HMAC_H
+
+/* Define to 1 if you have the <pcap.h> header file. */
+#undef HAVE_PCAP_H
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#undef HAVE_STDINT_H
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#undef HAVE_STDLIB_H
+
+/* Define to 1 if you have the <strings.h> header file. */
+#undef HAVE_STRINGS_H
+
+/* Define to 1 if you have the <string.h> header file. */
+#undef HAVE_STRING_H
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#undef HAVE_SYS_STAT_H
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#undef HAVE_SYS_TYPES_H
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#undef HAVE_UNISTD_H
+
+/* Have WPA2 decryption library */
+#undef HAVE_WPA2_DECRYPTION
+
+/* Define to the sub-directory in which libtool stores uninstalled libraries.
+   */
+#undef LT_OBJDIR
+
+/* Name of package */
+#undef PACKAGE
+
+/* Define to the address where bug reports for this package should be sent. */
+#undef PACKAGE_BUGREPORT
+
+/* Define to the full name of this package. */
+#undef PACKAGE_NAME
+
+/* Define to the full name and version of this package. */
+#undef PACKAGE_STRING
+
+/* Define to the one symbol short name of this package. */
+#undef PACKAGE_TARNAME
+
+/* Define to the home page for this package. */
+#undef PACKAGE_URL
+
+/* Define to the version of this package. */
+#undef PACKAGE_VERSION
+
+/* Define to 1 if you have the ANSI C header files. */
+#undef STDC_HEADERS
+
+/* Version number of package */
+#undef VERSION

include/constants.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, 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) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -34,15 +34,64 @@
 #include <string>
 #include <algorithm>
 #include <vector>
-#include "dot11.h"
 #include "utils.h"
 #include "snap.h"
 #include "rawpdu.h"
+#include "handshake_capturer.h"
+#include "config.h"
 
 namespace Tins {
 class PDU;
+class Dot11;
+class Dot11Data;
 
 namespace Crypto {
+    /**
+     * \cond
+     */
+    class 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 +114,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 +142,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 +165,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 +321,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 +329,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 +381,7 @@ namespace Crypto {
     {
         return DecrypterProxy<Functor, WEPDecrypter>(functor);
     }
-    
+
     // RC4 stuff
     
     template<typename ForwardIterator>

include/cxxstd.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_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__
+
+#define TINS_IS_CXX11 (__cplusplus > 199711L || TINS_CXXSTD_GCC_FIX == 1)
+
+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) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -35,12 +35,15 @@
 #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 +69,7 @@ namespace Tins {
         /** 
          * \brief DHCP options enum.
          */
-        enum Options {
+        enum OptionTypes {
             PAD,
             SUBNET_MASK,
             TIME_OFFSET,
@@ -142,12 +145,12 @@ namespace Tins {
         /**
          * The DHCP option type.
          */
-        typedef PDUOption<uint8_t> dhcp_option;
+        typedef PDUOption<uint8_t> 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 +161,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,60 +221,90 @@ 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);
         
         /** 
          * \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);
         
         /** 
          * \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);
@@ -259,7 +314,7 @@ namespace Tins {
         /**
          * \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 +324,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 +334,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 +344,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 +354,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 +364,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,7 +374,7 @@ 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 
@@ -330,7 +385,7 @@ namespace Tins {
         /**
          * \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
@@ -341,7 +396,7 @@ namespace Tins {
         /**
          * \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 +406,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 +416,15 @@ 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 Getter for the options list.
+        /** 
+         * \brief Getter for the options list.
          * \return The option list.
          */
         const options_type options() const { return _options; }
@@ -377,7 +433,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.
@@ -401,23 +457,24 @@ namespace Tins {
         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);
+        T generic_search(OptionTypes opt, type2type<T>) const {
+            const option *option = search_option(opt);
             if(option && option->data_size() == sizeof(T))
                 return *(const T*)option->data_ptr();
             else
                 throw option_not_found();
         }
         
-        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;
+        void internal_add_option(const option &opt);
+        std::list<ipaddress_type> generic_search(OptionTypes opt, type2type<std::list<ipaddress_type> >) const;
+        std::string generic_search(OptionTypes opt, type2type<std::string>) const;
+        ipaddress_type generic_search(OptionTypes opt, type2type<ipaddress_type>) const;
         
         serialization_type serialize_list(const std::list<ipaddress_type> &ip_list);
         
         options_type _options;
         uint32_t _size;
     };
-};
+}
 
 #endif // TINS_DHCP_H

include/dhcpv6.h

@@ -0,0 +1,888 @@
+/*
+ * Copyright (c) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_DHCPV6_H
+#define TINS_DHCPV6_H
+
+#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> 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) {}
+    };
+    
+    /**
+     * 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) {}
+    };
+
+    /**
+     * 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) {}
+    };
+    
+    /**
+     * 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) {}
+    };
+    
+    /**
+     * 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) { }
+    };
+    
+    /**
+     * 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) { }
+    };
+    
+    
+    /**
+     * 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;
+    
+    /**
+     * 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) { }
+    };
+    
+    /**
+     * 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()) {}
+    };
+        
+    /**
+     * The type used to store the Option Request option.
+     */
+    typedef std::vector<OptionTypes> 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 InputIterator>
+    void class_option_data2option(InputIterator start, InputIterator end, 
+      std::vector<uint8_t>& buffer, size_t start_index = 0) 
+    {
+        size_t index = start_index;
+        while(start != end) {
+            buffer.resize(buffer.size() + sizeof(uint16_t) + start->size());
+            *(uint16_t*)&buffer[index] = Endian::host_to_be<uint16_t>(start->size());
+            index += sizeof(uint16_t);
+            std::copy(start->begin(), start->end(), buffer.begin() + index);
+            index += start->size();
+            
+            start++;
+        }
+    }
+    
+    template<typename OutputType>
+    OutputType option2class_option_data(const uint8_t *ptr, uint32_t total_sz) const
+    {
+        typedef typename OutputType::value_type value_type;
+        OutputType output;
+        size_t index = 0;
+        while(index + 2 < total_sz) {
+            uint16_t size = Endian::be_to_host(
+                *(const uint16_t*)(ptr + index)
+            );
+            index += sizeof(uint16_t);
+            if(index + size > total_sz)
+                throw option_not_found();
+            output.push_back(
+                value_type(ptr + index, ptr + index + size)
+            );
+            index += size;
+        }
+        if(index != total_sz)
+            throw option_not_found();
+        return output;
+    }
+    
+
+    uint8_t header_data[4];
+    uint32_t options_size;
+    ipaddress_type link_addr, peer_addr;
+    options_type options_;
+};    
+}
+
+#endif // TINS_DHCPV6_H

include/dns.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -36,12 +36,14 @@
 #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
@@ -240,6 +242,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 +252,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.
@@ -485,6 +492,18 @@ namespace Tins {
          */
         void add_answer(const std::string &name, 
           const DNSResourceRecord::info &info, address_type ip);
+          
+        /**
+         * \brief Add a query response.
+         * 
+         * \param name The resolved name.
+         * \param type The type of this answer.
+         * \param qclass The class of this answer.
+         * \param ttl The time-to-live of this answer.
+         * \param ip The ip address of the resolved name.
+         */
+        void add_answer(const std::string &name, 
+          const DNSResourceRecord::info &info, address_v6_type ip);
                         
         /**
          * \brief Add a query response.
@@ -539,6 +558,9 @@ namespace Tins {
         
         /**
          * \brief Getter for this PDU's DNS queries.
+         * 
+         * This method is <b>not thread safe</b>.
+         * 
          * \return std::list<Query> containing the queries in this
          * record.
          */
@@ -546,11 +568,23 @@ namespace Tins {
         
         /**
          * \brief Getter for this PDU's DNS answers
+         * 
+         * This method is <b>not thread safe</b>.
+         * 
          * \return std::list<Resource> containing the answers in this
          * record.
          */
         resources_type answers() 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
          */
@@ -559,7 +593,7 @@ namespace Tins {
         }
         
         /**
-         * Helper function to create a resource record information
+         * Helper function to create a resource record information.
          * 
          * \param type The type of the query.
          * \param qclass The class of the query.
@@ -569,6 +603,7 @@ namespace Tins {
             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,7 +633,7 @@ 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;
@@ -630,7 +665,7 @@ namespace Tins {
         mutable SuffixMap suffixes;
         mutable SuffixIndices suffix_indices;
     };
-};
+}
 
 #endif // TINS_DNS_H
 

include/dns_record.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -33,9 +33,21 @@
 #include <string>
 #include <vector>
 #include <stdint.h>
+#include "cxxstd.h"
+#include "macros.h"
 
 namespace Tins {
-class DNSRRImpl;
+/** 
+ * \cond
+ */
+class DNSRRImpl {
+public:
+    virtual ~DNSRRImpl() {}
+    virtual uint32_t size() const = 0;
+    virtual uint32_t do_write(uint8_t *buffer) const = 0;
+    virtual bool matches(const std::string &dname) const { return false; }
+    virtual DNSRRImpl *clone() const = 0;
+};
 
 /**
  * \brief Abstracts a DNS resource record.
@@ -45,6 +57,7 @@ public:
     /**
      * \brief The type used to store resource records' information.
      */
+    TINS_BEGIN_PACK
     struct info {
         uint16_t type, qclass;
         uint32_t ttl;
@@ -53,7 +66,7 @@ public:
           : type(tp), qclass(qc), ttl(tm) { }
         
         info() : type(), qclass(), ttl() {}
-    } __attribute__((packed));
+    } TINS_END_PACK;
     
     /**
      * \brief Constructs a record.
@@ -65,6 +78,10 @@ public:
     
     /**
      * \brief Constructs a record.
+     * 
+     * If the input data is malformed, a malformed_packet exception
+     * is thrown.
+     * 
      * \param buffer A pointer to the start of the data buffer.
      * \param len The length of the data.
      */
@@ -97,6 +114,29 @@ public:
      */
     DNSResourceRecord& operator=(const DNSResourceRecord &rhs);
     
+    #if TINS_IS_CXX11
+        /**
+         * Move constructor.
+         */
+        DNSResourceRecord(DNSResourceRecord &&rhs) noexcept 
+        : info_(rhs.info_), data(std::move(rhs.data)), impl(0) {
+            std::swap(impl, rhs.impl);
+        }
+        
+        /**
+         * Move assignment operator.
+         */
+        DNSResourceRecord& operator=(DNSResourceRecord &&rhs) noexcept 
+        {
+            info_ = rhs.info_;
+            data = std::move(rhs.data);
+            delete impl;
+            impl = 0;
+            std::swap(impl, rhs.impl);
+            return *this;
+        }
+    #endif // TINS_IS_CXX11
+    
     /**
      * \brief Destructor.
      * 
@@ -183,18 +223,6 @@ private:
     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);

include/dot11/dot11_assoc.h

@@ -0,0 +1,620 @@
+/*
+ * Copyright (c) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_DOT11_DOT11_ASSOC_H
+#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,258 @@
+/*
+ * Copyright (c) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_DOT11_DOT11_AUTH_H
+#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,515 @@
+/*
+ * Copyright (c) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */ 
+
+#ifndef TINS_DOT11_DOT11_H
+#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> 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;
+
+    /**
+     * \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,164 @@
+/*
+ * Copyright (c) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */    
+
+#ifndef TINS_DOT11_DOT11_BEACON_H
+#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,743 @@
+/*
+ * Copyright (c) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_DOT11_DOT11_CONTROL_H
+#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,343 @@
+/*
+ * Copyright (c) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_DOT11_DOT11_DATA_H
+#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,230 @@
+/*
+ * Copyright (c) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_DOT11_DOT11_PROBE_H
+#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) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_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) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_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) 2012, 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) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,12 +31,27 @@
 #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 {
@@ -45,7 +60,7 @@ namespace Endian {
      *
      * \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 +69,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 +79,56 @@ 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(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) 2012, 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,150 @@
+/*
+ * Copyright (c) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_EXCEPTIONS_H
+#define TINS_EXCEPTIONS_H
+
+#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";
+    }
+};
+}
+
+#endif // TINS_EXCEPTIONS_H

include/handshake_capturer.h

@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_HANDSHAKE_CAPTURER_H
+#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) 2012, 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) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,7 +30,7 @@
 #ifndef TINS_ICMP_H
 #define TINS_ICMP_H
 
-
+#include "macros.h"
 #include "pdu.h"
 #include "endianness.h"
 
@@ -71,8 +71,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 +96,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.
          *
@@ -141,14 +139,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 +147,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.
          *
@@ -238,7 +220,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 check() const { return Endian::be_to_host(_icmp.check); }
 
         /**
          * \brief Getter for the echo id.
@@ -259,7 +241,7 @@ namespace Tins {
          *
          * \return Returns the gateways in an unit32_t.
          */
-         uint32_t gateway() const { return Endian::be_to_host(this->_icmp.un.gateway); }
+         uint32_t gateway() const { return Endian::be_to_host(_icmp.un.gateway); }
 
          /**
           * \brief Getter for the pointer field.
@@ -273,7 +255,7 @@ namespace Tins {
           *
           * \return Returns the mtu value in an uint16_t.
           */
-        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 Returns the header size.
@@ -290,7 +272,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 +280,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 +288,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 +300,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 check(uint16_t new_check);
         
         /** \brief Serialices this ICMP PDU.
          * \param buffer The buffer in which the PDU will be serialized.
@@ -346,6 +318,6 @@ namespace Tins {
 
         icmphdr _icmp;
     };
-};
+}
 
 #endif // TINS_ICMP_H

include/ieee802_3.h

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

include/ip.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, 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> option;
 
         /**
          * The type of the security option.
@@ -212,6 +215,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 +229,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 +267,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 +304,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 +325,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 +340,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.
          *
@@ -364,13 +368,6 @@ namespace Tins {
          */
         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 +395,34 @@ 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));
+            }
+        #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 +549,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 +558,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 +566,7 @@ 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 &);
 
         /**
          * \brief Getter for the PDU's type.
@@ -558,17 +574,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 +583,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 +602,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) 2012, 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/ipv6.h

@@ -0,0 +1,330 @@
+/*
+ * Copyright (c) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_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> 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) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_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) 2012, 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) 2012, 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,50 @@
+/*
+ * Copyright (c) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_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
+#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))
+#endif
+
+#endif

include/network_interface.h

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

include/packet.h

@@ -0,0 +1,292 @@
+/*
+ * Copyright (c) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_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:
+    /**
+     * \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 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 bool(pdu_);
+    }
+    
+    /**
+     * 
+     * \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) 2012, 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,34 @@ 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);
 
         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;
     };
-    
-    
-    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

include/packet_writer.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -34,6 +34,7 @@
 #include <iterator>
 #include <pcap.h>
 #include "utils.h"
+#include "cxxstd.h"
 
 namespace Tins {
 class PDU;
@@ -53,7 +54,9 @@ public:
     enum LinkType {
         RADIOTAP = DLT_IEEE802_11_RADIO,
         DOT11 = DLT_IEEE802_11,
-        ETH2 = DLT_EN10MB
+        ETH2 = DLT_EN10MB,
+        DOT3 = DLT_EN10MB,
+        SLL = DLT_LINUX_SLL
     };
     
     /**
@@ -64,6 +67,36 @@ public:
      */
     PacketWriter(const std::string &file_name, LinkType lt);
     
+    #if TINS_IS_CXX11
+        /**
+         * \brief Move constructor.
+         * 
+         * Note that calling PacketWriter::write on an previously moved
+         * object will lead to undefined behaviour.
+         * 
+         * \param rhs The PacketWriter to be moved.
+         */
+        PacketWriter(PacketWriter &&rhs) noexcept {
+            *this = std::move(rhs);
+        }
+        
+        /**
+         * \brief Move assignment operator.
+         * 
+         * Note that calling PacketWriter::write on an previously moved
+         * object will lead to undefined behaviour.
+         * 
+         * \param rhs The PacketWriter to be moved.
+         */
+        PacketWriter& operator=(PacketWriter &&rhs) noexcept {
+            handle = 0;
+            dumper = 0;
+            std::swap(handle, rhs.handle);
+            std::swap(dumper, rhs.dumper);
+            return *this;
+        }
+    #endif
+    
     /**
      * Destructor.
      */
@@ -74,6 +107,18 @@ public:
      */
     void write(PDU &pdu);
     
+    /**
+     * \brief Writes a PDU to this file. 
+     * 
+     * The template parameter T must at some point yield a PDU& after
+     * applying operator* one or more than one time. This accepts both
+     * raw and smart pointers.
+     */
+    template<typename T>
+    void write(T &pdu) {
+        write(Utils::dereference_until_pdu(pdu));
+    }
+    
     /**
      * \brief Writes all the PDUs in the range [start, end)
      * \param start A forward iterator pointing to the first PDU

include/pdu.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -33,12 +33,21 @@
 
 #include <stdint.h>
 #include <vector>
+#include "macros.h"
+#include "cxxstd.h"
+#include "exceptions.h"
 
 /** \brief The Tins namespace.
  */
 namespace Tins {
 
     class PacketSender;
+    class NetworkInterface;
+    
+    /**
+     * The type used to store several PDU option values.
+     */
+    typedef std::vector<uint8_t> byte_array;
 
     /** \brief Base class for protocol data units.
      *
@@ -54,7 +63,7 @@ namespace Tins {
         /**
          * The type that will be returned when serializing PDUs.
          */
-        typedef std::vector<uint8_t> serialization_type;
+        typedef byte_array serialization_type;
 
         /**
          * \brief Enum which identifies each type of PDU.
@@ -101,18 +110,48 @@ namespace Tins {
             RC4EAPOL,
             RSNEAPOL,
             DNS,
-            LOOPBACK
+            LOOPBACK,
+            IPv6,
+            ICMPv6,
+            SLL,
+            DHCPv6,
+            DOT1Q,
+            PPPOE,
+            STP,
+            PPI,
+            USER_DEFINED_PDU = 1000
         };
 
-        /** \brief PDU constructor
-         *
-         * Must be called by subclasses in their constructors.
-         * \param flag The flag identifier for the subclass' PDU.
-         * \param next_pdu The child PDU. Can be obviated.
+        /** 
+         * \brief Default constructor.
          */
-        PDU(PDU *next_pdu = 0);
+        PDU();
+        
+        #if TINS_IS_CXX11
+            /**
+             * \brief Move constructor.
+             * 
+             * \param rhs The PDU to be moved.
+             */
+            PDU(PDU &&rhs) noexcept 
+            : _inner_pdu(0)
+            {
+                std::swap(_inner_pdu, rhs._inner_pdu);
+            }
+            
+            /**
+             * \brief Move assignment operator.
+             * 
+             * \param rhs The PDU to be moved.
+             */
+            PDU& operator=(PDU &&rhs) noexcept {
+                std::swap(_inner_pdu, rhs._inner_pdu);
+                return *this;
+            }
+        #endif
 
-        /** \brief PDU destructor.
+        /** 
+         * \brief PDU destructor.
          *
          * Deletes the inner pdu, as a consequence every child pdu is
          * deleted.
@@ -159,11 +198,21 @@ namespace Tins {
         /**
          * \brief Sets the child PDU.
          *
-         * \param next_pdu The new child PDU.
          * When setting a new inner_pdu, the instance takesownership of
          * the object, therefore deleting it when it's no longer required.
+         * 
+         * \param next_pdu The new child PDU.
          */
         void inner_pdu(PDU *next_pdu);
+        
+        /**
+         * \brief Sets the child PDU.
+         *
+         * The PDU parameter is cloned using PDU::clone.
+         * 
+         * \param next_pdu The new child PDU.
+         */
+        void inner_pdu(const PDU &next_pdu);
 
 
         /** 
@@ -178,14 +227,14 @@ namespace Tins {
         serialization_type serialize();
 
         /**
-         * \brief Find and returns the first PDU that matches the given flag.
+         * \brief Finds and returns the first PDU that matches the given flag.
          *
          * This method searches for the first PDU which has the same type flag as
          * the given one. If the first PDU matches that flag, it is returned.
          * If no PDU matches, 0 is returned.
          * \param flag The flag which being searched.
          */
-        template<class T> 
+        template<typename T> 
         T *find_pdu(PDUType type = T::pdu_flag) {
             PDU *pdu = this;
             while(pdu) {
@@ -195,6 +244,43 @@ namespace Tins {
             }
             return 0;
         }
+        
+        /**
+         * \brief Finds and returns the first PDU that matches the given flag.
+         *
+         * \param flag The flag which being searched.
+         */
+        template<typename T> 
+        const T *find_pdu(PDUType type = T::pdu_flag) const {
+            return const_cast<PDU*>(this)->find_pdu<T>();
+        }
+
+        /**
+         * \brief Finds and returns the first PDU that matches the given flag.
+         * 
+         * If the PDU is not found, a pdu_not_found exception is thrown.
+         * 
+         * \sa PDU::find_pdu
+         * 
+         * \param flag The flag which being searched.
+         */
+        template<typename T>
+        T &rfind_pdu(PDUType type = T::pdu_flag) {
+            T *ptr = find_pdu<T>(type);
+            if(!ptr)
+                throw pdu_not_found();
+            return *ptr;
+        }
+
+        /**
+         * \brief Finds and returns the first PDU that matches the given flag.
+         *
+         * \param flag The flag which being searched.
+         */
+        template<typename T> 
+        const T &rfind_pdu(PDUType type = T::pdu_flag) const {
+            return const_cast<PDU*>(this)->rfind_pdu<T>();
+        }
 
         /**
          * \brief Clones this packet.
@@ -206,25 +292,37 @@ namespace Tins {
          */
         virtual PDU *clone() const = 0;
 
-        /** \brief Send the stack of PDUs through a PacketSender.
+        /** 
+         * \brief Send the stack of PDUs through a PacketSender.
          *
          * This method will be called only for the PDU on the bottom of the stack,
          * therefore it should only implement this method if it can be sent.
+         * 
          * PacketSender implements specific methods to send packets which start
          * on every valid TCP/IP stack layer; this should only be a proxy for
          * those methods.
+         * 
+         * If this PDU does not represent a link layer protocol, then
+         * the interface argument will be ignored.
+         * 
          * \param sender The PacketSender which will send the packet.
+         * \param iface The network interface in which this packet will 
+         * be sent.
          */
-        virtual void send(PacketSender &sender);
+        virtual void send(PacketSender &sender, const NetworkInterface &iface);
 
-        /** \brief Receives a matching response for this packet.
+        /** 
+         * \brief Receives a matching response for this packet.
          *
          * This method should act as a proxy for PacketSender::recv_lX methods.
+         * 
          * \param sender The packet sender which will receive the packet.
+         * \param iface The interface in which to expect the response.
          */
-        virtual PDU *recv_response(PacketSender &sender);
+        virtual PDU *recv_response(PacketSender &sender, const NetworkInterface &iface);
 
-        /** \brief Check wether ptr points to a valid response for this PDU.
+        /** 
+         * \brief Check wether ptr points to a valid response for this PDU.
          *
          * This method must check wether the buffer pointed by ptr is a valid
          * response for this PDU. If it is valid, then it might want to propagate
@@ -233,7 +331,9 @@ namespace Tins {
          * \param ptr The pointer to the buffer.
          * \param total_sz The size of the buffer.
          */
-        virtual bool matches_response(uint8_t *ptr, uint32_t total_sz) { return false; }
+        virtual bool matches_response(const uint8_t *ptr, uint32_t total_sz) const { 
+            return false; 
+        }
 
         /**
          * \brief Check wether this PDU matches the specified flag.
@@ -243,7 +343,7 @@ namespace Tins {
          * classes' flag.
          * \param flag The flag to match.
          */
-        virtual bool matches_flag(PDUType flag) {
+        virtual bool matches_flag(PDUType flag) const {
            return flag == pdu_type();
         }
 
@@ -253,15 +353,6 @@ namespace Tins {
          * \return Returns the PDUType corresponding to the PDU.
          */
         virtual PDUType pdu_type() const = 0;
-
-        /** \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.
-         */
-        virtual PDU *clone_packet(const uint8_t *ptr, uint32_t total_sz) { return 0; }
     protected:
         /**
          * \brief Copy constructor.
@@ -279,6 +370,20 @@ namespace Tins {
          */
         void copy_inner_pdu(const PDU &pdu);
 
+        /**
+         * \brief Prepares this PDU for serialization.
+         * 
+         * This method is called before the inner PDUs are serialized.
+         * It's useful in situations such as when serializing IP PDUs,
+         * which don't contain any link layer encapsulation, and therefore
+         * require to set the source IP address before the TCP/UDP checksum
+         * is calculated.
+         * 
+         * By default, this method does nothing
+         * 
+         * \param parent The parent PDU.
+         */
+        virtual void prepare_for_serialize(const PDU *parent) { }
 
         /** 
          * \brief Serializes this PDU and propagates this action to child PDUs.
@@ -289,16 +394,6 @@ namespace Tins {
          */
         void serialize(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
 
-        /** 
-         * \brief Clones the inner pdu(if any).
-         *
-         * This method clones the inner pdu using data from a buffer.
-         * \param ptr The pointer from which the child PDU must be cloned.
-         * \param total_sz The total size of the buffer.
-         * \return Returns the cloned PDU. Will be 0 if cloning failed.
-         */
-        PDU *clone_inner_pdu(const uint8_t *ptr, uint32_t total_sz);
-
         /** 
          * \brief Serializes this TCP PDU.
          *
@@ -350,6 +445,17 @@ namespace Tins {
         lop /= rop;
         return lop;
     }
-};
+    
+    /**
+     * \brief Concatenation operator on PDU pointers.
+     * 
+     * \sa operator/=
+     */
+    template<typename T>
+    T *operator/= (T* lop, const PDU &rop) {
+        *lop /= rop;
+        return lop;
+    }
+}
 
 #endif // TINS_PDU_H

include/pdu_allocator.h

@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_PDU_ALLOCATOR_H
+#define TINS_PDU_ALLOCATOR_H
+
+#include <map>
+#include "pdu.h"
+
+namespace Tins {
+/**
+ * \cond
+ */
+class EthernetII;
+class SNAP;
+class Dot1Q;
+class SLL;
+class IP;
+class IPv6;
+
+namespace Internals {
+template<typename PDUType>
+PDU *default_allocator(const uint8_t *buffer, uint32_t size)
+{
+    return new PDUType(buffer, size);
+}
+
+template<typename Tag>
+class PDUAllocator {
+public:
+    typedef typename Tag::identifier_type id_type;
+    typedef PDU *(*allocator_type)(const uint8_t *, uint32_t);
+
+    template<typename PDUType>
+    static void register_allocator(id_type identifier)
+    {
+        allocators[identifier] = &default_allocator<PDUType>;
+        pdu_types[PDUType::pdu_flag] = identifier;
+    }
+
+    static PDU *allocate(id_type identifier, const uint8_t *buffer, uint32_t size) 
+    {
+        typename allocators_type::const_iterator it = allocators.find(identifier);
+        return (it == allocators.end()) ? 0 : (*it->second)(buffer, size);
+    }
+
+    static bool pdu_type_registered(PDU::PDUType type)
+    {
+        return pdu_types.count(type) != 0;
+    }
+
+    static id_type pdu_type_to_id(PDU::PDUType type) 
+    {
+        typename pdu_map_types::const_iterator it = pdu_types.find(type);
+        return it->second;
+    }
+private:
+    typedef std::map<id_type, allocator_type> allocators_type;
+    typedef std::map<PDU::PDUType, id_type> pdu_map_types;
+
+    static allocators_type allocators;
+    static pdu_map_types pdu_types;
+};
+
+template<typename Tag>
+typename PDUAllocator<Tag>::allocators_type PDUAllocator<Tag>::allocators;
+
+template<typename Tag>
+typename PDUAllocator<Tag>::pdu_map_types PDUAllocator<Tag>::pdu_types;
+
+template<typename IDType>
+struct pdu_tag {
+    typedef IDType identifier_type;
+};
+
+template<typename PDUType>
+struct pdu_tag_mapper;
+
+#define TINS_GENERATE_TAG_MAPPER(pdu, id_type) \
+template<> \
+struct pdu_tag_mapper<pdu> { \
+    typedef pdu_tag<id_type> type; \
+}; 
+
+TINS_GENERATE_TAG_MAPPER(EthernetII, uint16_t)
+TINS_GENERATE_TAG_MAPPER(SNAP, uint16_t)
+TINS_GENERATE_TAG_MAPPER(SLL, uint16_t)
+TINS_GENERATE_TAG_MAPPER(Dot1Q, uint16_t)
+TINS_GENERATE_TAG_MAPPER(IP, uint8_t)
+TINS_GENERATE_TAG_MAPPER(IPv6, uint8_t)
+
+#undef TINS_GENERATE_TAG_MAPPER
+
+template<typename PDUType>
+PDU* allocate(
+    typename pdu_tag_mapper<PDUType>::type::identifier_type id, 
+    const uint8_t *buffer, 
+    uint32_t size)
+{
+    return PDUAllocator<typename pdu_tag_mapper<PDUType>::type>::allocate(id, buffer, size);
+}
+
+template<typename PDUType>
+bool pdu_type_registered(PDU::PDUType type)
+{
+    return PDUAllocator<typename pdu_tag_mapper<PDUType>::type>::pdu_type_registered(type);
+}
+
+template<typename PDUType>
+typename pdu_tag_mapper<PDUType>::type::identifier_type pdu_type_to_id(PDU::PDUType type) 
+{
+    return PDUAllocator<typename pdu_tag_mapper<PDUType>::type>::pdu_type_to_id(type);
+}
+} // namespace Interals
+/**
+ * \endcond
+ */
+
+/**
+ * \brief Defines inner PDU allocators.
+ */
+namespace Allocators {
+/**
+ * \brief Registers an allocator for the provided PDU type.
+ *
+ * Registering a certain allocator for a PDU type is useful for 
+ * extending the library. Once an allocator is registered, it will
+ * be taken into account while constructing a PDU from a buffer.
+ * 
+ * If PDU finds that it cannot define which is the protocol
+ * that should be allocated based on its protocol identifier, it
+ * will try using the registered allocators if any.
+ *
+ * \code
+ * // Register the 0x666 identifer. Now if EthernetII finds a
+ * // network layer identifier field whose value is 0x666, it will
+ * // use SomePDUType as its inner PDU type.
+ * Allocators::register_allocator<EthernetII, SomePDUType>(0x666);
+ * \endcode
+ *
+ * Note that some PDU types are grouped together. For example, 
+ * registering an allocator for EthernetII will make it work for 
+ * the rest of the link layer protocols, sine they should all work 
+ * the same way.
+ */
+template<typename PDUType, typename AllocatedType>
+void register_allocator(typename Internals::pdu_tag_mapper<PDUType>::type::identifier_type id)
+{
+    Internals::PDUAllocator<
+        typename Internals::pdu_tag_mapper<PDUType>::type
+    >::template register_allocator<AllocatedType>(id);
+}
+} // namespace Allocators
+} // namespace Tins
+
+#endif // TINS_PDU_ALLOCATOR_H

include/pdu_cacher.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -32,6 +32,7 @@
 
 #include <algorithm>
 #include "pdu.h"
+#include "macros.h"
 
 namespace Tins {
 /**
@@ -94,28 +95,28 @@ public:
     /**
      * Forwards the call to the cached PDU. \sa PDU::send.
      */
-    void send(PacketSender &sender) {
-        cached.send(sender);
+    void send(PacketSender &sender, const NetworkInterface &iface) {
+        cached.send(sender, iface);
     }
     
     /**
      * Forwards the call to the cached PDU. \sa PDU::recv_responde.
      */
-    PDU *recv_response(PacketSender &sender) {
-        return cached.recv_response(sender);
+    PDU *recv_response(PacketSender &sender, const NetworkInterface &iface) {
+        return cached.recv_response(sender, iface);
     }
     
     /**
      * Forwards the call to the cached PDU. \sa PDU::matches_response.
      */
-    bool matches_response(uint8_t *ptr, uint32_t total_sz) {
+    bool matches_response(const uint8_t *ptr, uint32_t total_sz) const {
         return cached.matches_response(ptr, total_sz);
     }
     
     /**
      * Forwards the call to the cached PDU. \sa PDU::matches_flag.
      */
-    bool matches_flag(PDUType flag) {
+    bool matches_flag(PDUType flag) const {
         return cached.matches_flag(flag);
     }
     
@@ -125,13 +126,6 @@ public:
     PDUType pdu_type() const {
         return cached.pdu_type();
     }
-    
-    /**
-     * Forwards the call to the cached PDU. \sa PDU::clone_packet.
-     */
-    PDU *clone_packet(const uint8_t *ptr, uint32_t total_sz) {
-        return cached.clone_packet(ptr, total_sz);
-    }
 private:
     void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
         if(cached_serialization.size() != total_sz) {

include/pdu_option.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -33,18 +33,9 @@
 #include <vector>
 #include <iterator>
 #include <stdint.h>
+#include "exceptions.h"
 
 namespace Tins {
-/**
- * \brief Exception thrown when an option is not found.
- */
-class option_not_found : public std::exception {
-public:
-    const char* what() const throw() {
-        return "Option not found";
-    }
-};
-    
 /**
  * \class PDUOption
  * \brief Represents a PDU option field.
@@ -75,10 +66,8 @@ public:
      * \param data The option's data(if any).
      */
     PDUOption(option_type opt = option_type(), size_t length = 0, const data_type *data = 0) 
-    : option_(opt) {
-        value_.push_back(length);
-        if(data)
-            value_.insert(value_.end(), data, data + length);
+    : option_(opt), size_(length), value_(data, data + (data ? length : 0)) {
+        
     }
     
     /**
@@ -91,9 +80,29 @@ public:
      */
     template<typename ForwardIterator>
     PDUOption(option_type opt, ForwardIterator start, ForwardIterator end) 
-    : option_(opt) {
-        value_.push_back(std::distance(start, end));
-        value_.insert(value_.end(), start, end);
+    : option_(opt), size_(std::distance(start, end)), value_(start, end) {
+        
+    }
+    
+    /**
+     * \brief Constructs a PDUOption from iterators, which 
+     * indicate the data to be stored in it.
+     * 
+     * The length parameter indicates the contents of the length field
+     * when this option is serialized. Note that this can be different
+     * to std::distance(start, end).
+     * 
+     * \sa length_field
+     * 
+     * \param opt The option type.
+     * \param length The length of this option.
+     * \param start The beginning of the option data.
+     * \param end The end of the option data.
+     */
+    template<typename ForwardIterator>
+    PDUOption(option_type opt, size_t length, ForwardIterator start, ForwardIterator end) 
+    : option_(opt), size_(length), value_(start, end) {
+        
     }
     
     /**
@@ -104,6 +113,14 @@ public:
         return option_;
     }
     
+    /**
+     * Sets this option's type
+     * \param opt The option type to be set.
+     */
+    void option(option_type opt) {
+        option_ = opt;
+    }
+    
     /**
      * Retrieves this option's data.
      * 
@@ -111,20 +128,39 @@ public:
      * dereferencing the returned pointer will result in undefined
      * behaviour.
      * 
-     * \return const value_type& containing this option's value.
+     * \return const data_type& containing this option's value.
      */
     const data_type *data_ptr() const {
-        return &*(++value_.begin());
+        return &*value_.begin();
     }
     
     /**
-     * Retrieves the length of this option's data.
+     * \brief Retrieves the length of this option's data.
+     * 
+     * This is the actual size of the data.
      */
     size_t data_size() const {
-        return value_.empty() ? 0 : (value_.size() - 1);
+        return value_.size();
+    }
+    
+    /**
+     * \brief Retrieves the data length field.
+     * 
+     * This is what the size field will contain when this option is 
+     * serialized. It can differ from the actual data size. 
+     * 
+     * This will be equal to data_size unless the constructor that takes
+     * both a data length and two iterators is used.
+
+     * 
+     * \sa data_size.
+     */
+    size_t length_field() const {
+        return size_;
     }
 private:
     option_type option_;
+    uint16_t size_;
     container_type value_;
 };
 } // namespace Tins

include/ppi.h

@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_PPI_H
+#define TINS_PPI_H
+
+#include "pdu.h"
+#include "endianness.h"
+#include "small_uint.h"
+
+namespace Tins {
+/**
+ * \brief Represents a Per-Packet Information PDU.
+ *
+ * This PDU can only be constructed from a buffer, and
+ * cannot be serialized. Therefore, it is only useful while
+ * sniffing packets.
+ */
+class PPI : public PDU {
+public:
+    /**
+     * This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::PPI;
+
+    /**
+     * \brief Constructs an PPI 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 PPI 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.
+     */
+    PPI(const uint8_t *buffer, uint32_t total_sz);
+
+    // Getters
+
+    /**
+     *  \brief Getter for the version field.
+     *  \return The stored version field value.
+     */
+    uint8_t version() const {
+        return _header.version;
+    }
+
+    /**
+     *  \brief Getter for the flags field.
+     *  \return The stored flags field value.
+     */
+    uint8_t flags() const {
+        return _header.flags;
+    }
+
+    /**
+     *  \brief Getter for the length field.
+     *  \return The stored length field value.
+     */
+    uint16_t length() const {
+        return _header.length;
+    }
+
+    /**
+     *  \brief Getter for the Data Link Type field.
+     *  \return The stored Data Link Type field value.
+     */
+    uint32_t dlt() const {
+        return _header.dlt;
+    }
+
+    /**
+     * \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; }
+
+    /**
+     * \brief Clones this PDU.
+     *
+     * \sa PDU::clone
+     */
+    PPI *clone() const {
+        return new PPI(*this);
+    }
+private:
+    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *);
+
+    struct header {
+        uint8_t version, flags;
+        uint16_t length;
+        uint32_t dlt;
+    };
+
+    header _header;
+    byte_array _data;
+};
+}
+
+#endif // TINS_PPI_H

include/pppoe.h

@@ -0,0 +1,436 @@
+/*
+ * Copyright (c) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_PPPoE_H
+#define TINS_PPPoE_H
+
+#include <list>
+#include <string>
+#include <vector>
+#include "pdu.h"
+#include "endianness.h"
+#include "small_uint.h"
+#include "pdu_option.h"
+#include "cxxstd.h"
+
+namespace Tins {
+class PPPoE : public PDU {
+public:
+    /**
+     * The tag types enum.
+     */
+    enum TagTypes {
+        END_OF_LIST = 0,
+        SERVICE_NAME = 0x101,
+        #if TINS_IS_LITTLE_ENDIAN
+            AC_NAME = 0x201,
+            HOST_UNIQ = 0x301,
+            AC_COOKIE = 0x401,
+            VENDOR_SPECIFIC = 0x501,
+            RELAY_SESSION_ID = 0x101,
+            SERVICE_NAME_ERROR = 0x201,
+            AC_SYSTEM_ERROR = 0x202,
+            GENERIC_ERROR = 0x302
+        #else
+            AC_NAME = 0x102,
+            HOST_UNIQ = 0x103,
+            AC_COOKIE = 0x104,
+            VENDOR_SPECIFIC = 0x105,
+            RELAY_SESSION_ID = 0x110,
+            SERVICE_NAME_ERROR = 0x201,
+            AC_SYSTEM_ERROR = 0x202,
+            GENERIC_ERROR = 0x203
+        #endif        
+    };
+
+    /**
+     * The type used to store a TLV option.
+     */
+    typedef PDUOption<TagTypes> tag;
+    
+    /**
+     * The type used to store the options.
+     */
+    typedef std::list<tag> tags_type;
+    
+    /**
+     * The type used to store the Vendor-Specific tag's value.
+     */
+    struct vendor_spec_type {
+        typedef std::vector<uint8_t> data_type;
+        
+        uint32_t vendor_id;
+        data_type data;
+        
+        vendor_spec_type(uint32_t vendor_id = 0, const data_type &data = data_type())
+        : vendor_id(vendor_id), data(data) { }
+    };
+    
+    /**
+     * This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::PPPOE;
+
+    /**
+     * \brief Default constructor.
+     * 
+     * This sets the version and type fields to 0x1.
+     */
+    PPPoE();
+    
+    /**
+     * \brief Constructor which creates an PPPoE object from a buffer.
+     * 
+     * If there is not enough size for a PPPoE 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.
+     */
+    PPPoE(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 type field.
+     *  \return The stored type field value.
+     */
+    small_uint<4> type() const {
+        return _header.type;
+    }
+
+    /**
+     *  \brief Getter for the code field.
+     *  \return The stored code field value.
+     */
+    uint8_t code() const {
+        return _header.code;
+    }
+
+    /**
+     *  \brief Getter for the session_id field.
+     *  \return The stored session_id field value.
+     */
+    uint16_t session_id() const {
+        return Endian::be_to_host(_header.session_id);
+    }
+
+    /**
+     *  \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 Returns the header size.
+     *
+     * This metod overrides PDU::header_size. \sa PDU::header_size
+     */
+    uint32_t header_size() const;
+
+    /**
+     * \brief Returns the list of tags.
+     */
+    const tags_type &tags() const {
+        return _tags;
+    }
+
+    /**
+     * \sa PDU::clone
+     */
+    PPPoE *clone() const {
+        return new PPPoE(*this);
+    }
+    
+    const tag *search_tag(TagTypes identifier) const;
+    
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+
+    // 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 type field.
+     *  \param new_type The new type field value.
+     */
+    void type(small_uint<4> new_type);
+
+    /**
+     *  \brief Setter for the code field.
+     *  \param new_code The new code field value.
+     */
+    void code(uint8_t new_code);
+
+    /**
+     *  \brief Setter for the session_id field.
+     *  \param new_session_id The new session_id field value.
+     */
+    void session_id(uint16_t new_session_id);
+
+    /**
+     *  \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 Adds a PPPoE tag.
+     *
+     * \param option The option to be added.
+     */
+    void add_tag(const tag &option);
+    
+    #if TINS_IS_CXX11
+        /**
+         * \brief Adds a PPPoE tag.
+         *
+         * This move-constructs the option.
+         * 
+         * \param option The option to be added.
+         */
+        void add_tag(tag &&option) {
+            _tags_size += option.data_size() + sizeof(uint16_t) * 2;
+            _tags.push_back(std::move(option));
+        }
+    #endif
+    
+    // Option setters
+    
+    /**
+     * \brief Adds an end-of-list tag.
+     */
+    void end_of_list();
+    
+    /**
+     * \brief Adds a service-name tag.
+     * 
+     * \param value The service name.
+     */
+    void service_name(const std::string &value);
+    
+    /**
+     * \brief Adds a AC-name tag.
+     * 
+     * \param value The AC name.
+     */
+    void ac_name(const std::string &value);
+    
+    /**
+     * \brief Adds a host-uniq tag.
+     * 
+     * \param value The tag's value.
+     */
+    void host_uniq(const byte_array &value);
+    
+    /**
+     * \brief Adds a AC-Cookie tag.
+     * 
+     * \param value The tag's value.
+     */
+    void ac_cookie(const byte_array &value);
+    
+    /**
+     * \brief Adds a Vendor-Specific tag.
+     * 
+     * \param value The tag's value.
+     */
+    void vendor_specific(const vendor_spec_type &value);
+    
+    /**
+     * \brief Adds a Relay-Session-Id tag.
+     * 
+     * \param value The tag's value.
+     */
+    void relay_session_id(const byte_array &value);
+    
+    /**
+     * \brief Adds a Service-Name-Error tag.
+     * 
+     * \param value The tag's value.
+     */
+    void service_name_error(const std::string &value);
+    
+    /**
+     * \brief Adds a AC-System-Error tag.
+     * 
+     * \param value The tag's value.
+     */
+    void ac_system_error(const std::string &value);
+    
+    /**
+     * \brief Adds a Generic-Error tag.
+     * 
+     * \param value The tag's value.
+     */
+    void generic_error(const std::string &value);
+    
+    // Option getters
+    
+    /**
+     * \brief Getter for the service-name tag.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    std::string service_name() const;
+    
+    /**
+     * \brief Getter for the AC-name tag.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    std::string ac_name() const;
+    
+    /**
+     * \brief Getter for the host-uniq tag.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    byte_array host_uniq() const;
+
+    /**
+     * \brief Getter for the AC-Cookie tag.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    byte_array ac_cookie() const;
+    
+    /**
+     * \brief Getter for the Vendor-Specific tag.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    vendor_spec_type vendor_specific() const;
+    
+    /**
+     * \brief Getter for the Vendor-Specific tag.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    byte_array relay_session_id() const;
+    
+    /**
+     * \brief Getter for the Service-Name-Error tag.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    std::string service_name_error() const;
+    
+    /**
+     * \brief Getter for the AC-System-Error tag.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    std::string ac_system_error() const;
+    
+    /**
+     * \brief Getter for the Generic-Error tag.
+     * 
+     * This method will throw an option_not_found exception if the
+     * option is not found.
+     */
+    std::string generic_error() const;
+private:
+    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *);
+    
+    template<typename T>
+    void add_tag_iterable(TagTypes id, const T &data) {
+        add_tag(
+            tag(
+                id,
+                data.begin(),
+                data.end()
+            )
+        );
+    }
+    
+    template<typename T>
+    T retrieve_tag_iterable(TagTypes id) const {
+        const tag *tag = search_tag(id);
+        if(!tag)
+            throw option_not_found();
+        return T(tag->data_ptr(), tag->data_ptr() + tag->data_size());
+    }
+
+    template<template <typename> class Functor>
+    const tag *safe_search_tag(TagTypes opt, uint32_t size) const {
+        const tag *option = search_tag(opt);
+        if(!option || Functor<uint32_t>()(option->data_size(), size))
+            throw option_not_found();
+        return option;
+    }
+
+    TINS_BEGIN_PACK
+    struct pppoe_hdr {
+        #if TINS_IS_LITTLE_ENDIAN
+            uint8_t version:4,  
+                    type:4;
+            uint8_t code;
+        #else
+            uint16_t version:4,
+                    type:4,
+                    code:8;
+        #endif
+        uint16_t session_id;
+        uint16_t payload_length;
+    } TINS_END_PACK;
+
+    pppoe_hdr _header;
+    tags_type _tags;
+    uint16_t _tags_size;
+};
+}
+
+#endif // TINS_PPPoE_H

include/radiotap.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,9 +30,9 @@
 #ifndef TINS_RADIOTAP_H
 #define TINS_RADIOTAP_H
 
+#include "macros.h"
 #include "pdu.h"
 #include "endianness.h"
-#include "network_interface.h"
 
 namespace Tins {
     class PacketSender;
@@ -89,7 +89,8 @@ namespace Tins {
             ANTENNA             = 2048,
             DB_SIGNAL           = 4096,
             DB_NOISE            = 8192,
-            RX_FLAGS            = 16382
+            RX_FLAGS            = 16382,
+            CHANNEL_PLUS        = 262144
         };
         
         /**
@@ -107,16 +108,17 @@ namespace Tins {
         };
         
         /**
-         * \brief Creates an instance of RadioTap.
-         * \param iface The interface in which to send this PDU.
-         * \param child The child PDU.(optional)
+         * \brief Default constructor.
          */
-        RadioTap(const NetworkInterface &iface = NetworkInterface(), 
-          PDU *child = 0);
+        RadioTap();
         
         /**
-         * \brief Constructor which creates a RadioTap object from a buffer and adds all
+         * \brief Constructs a RadioTap 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 RadioTap 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.
          */
@@ -124,10 +126,12 @@ namespace Tins {
         
         /* Setters */
         
+        #ifndef WIN32
         /**
          * \sa PDU::send()
          */
-        void send(PacketSender &sender);
+        void send(PacketSender &sender, const NetworkInterface &iface);
+        #endif
         
         /**
          * \brief Setter for the version field.
@@ -184,12 +188,24 @@ namespace Tins {
          */
         void dbm_noise(uint8_t new_dbm_noise);
         
+        /**
+         * \brief Setter for the signal quality field.
+         * \param new_antenna The signal quality signal.
+         */
+        void signal_quality(uint8_t new_signal_quality);
+
         /**
          * \brief Setter for the antenna field.
          * \param new_antenna The antenna signal.
          */
         void antenna(uint8_t new_antenna);
         
+        /**
+         * \brief Setter for the db signal field.
+         * \param new_antenna The db signal signal.
+         */
+        void db_signal(uint8_t new_db_signal);
+
         /**
          * \brief Setter for the rx flag field.
          * \param new_rx_flag The antenna signal.
@@ -258,17 +274,29 @@ namespace Tins {
          */
         uint8_t dbm_noise() const { return _dbm_noise; }
         
+        /**
+         * \brief Getter for the signal quality field.
+         * \return The signal quality field.
+         */
+        uint16_t signal_quality() const { return _signal_quality; }
+
         /**
          * \brief Getter for the antenna field.
          * \return The antenna field.
          */
         uint8_t antenna() const { return _antenna; }
+
+        /**
+         * \brief Getter for the db signal field.
+         * \return The db signal field.
+         */
+        uint8_t db_signal() const { return _db_signal; }
         
         /**
          * \brief Getter for the channel+ field.
          * \return The channel+ field.
          */
-        uint32_t channel_plus() const { return Endian::le_to_host(_channel_type); }
+        uint32_t channel_plus() const { return Endian::le_to_host<uint32_t>(_channel_type); }
         
         /**
          * \brief Getter for the rx flags field.
@@ -286,9 +314,18 @@ namespace Tins {
          * if its corresponding bit flag is set in the present field.
          */
         PresentFlags present() const { 
-            return (PresentFlags)*(uint32_t*)(&_radio.it_len + 1); 
+            //return (PresentFlags)*(uint32_t*)(&_radio.it_len + 1); 
+            return (PresentFlags)Endian::le_to_host(_radio.flags_32);
         }
         
+        /** \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 Returns the RadioTap frame's header length.
          *
@@ -316,70 +353,79 @@ namespace Tins {
          */
         PDUType pdu_type() const { return PDU::RADIOTAP; }
     private:
+        TINS_BEGIN_PACK
         struct radiotap_hdr {
         #if TINS_IS_LITTLE_ENDIAN
             uint8_t it_version;	
             uint8_t it_pad;
             uint16_t it_len;
-            uint32_t tsft:1,
-                flags:1,
-                rate:1,
-                channel:1,
-                fhss:1,
-                dbm_signal:1,
-                dbm_noise:1,
-                lock_quality:1,
-                tx_attenuation:1,
-                db_tx_attenuation:1,
-                dbm_tx_attenuation:1,
-                antenna:1,
-                db_signal:1,
-                db_noise:1,
-                rx_flags:1,
-                reserved1:3,
-                channel_plus:1,
-                reserved2:12,
-                ext:1;
+            union {
+                struct {
+                    uint32_t tsft:1,
+                        flags:1,
+                        rate:1,
+                        channel:1,
+                        fhss:1,
+                        dbm_signal:1,
+                        dbm_noise:1,
+                        lock_quality:1,
+                        tx_attenuation:1,
+                        db_tx_attenuation:1,
+                        dbm_tx_attenuation:1,
+                        antenna:1,
+                        db_signal:1,
+                        db_noise:1,
+                        rx_flags:1,
+                        reserved1:3,
+                        channel_plus:1,
+                        reserved2:12,
+                        ext:1;
+                } flags;
+                uint32_t flags_32;
+            };
         #else
             uint8_t it_pad;
             uint8_t it_version;	
             uint16_t it_len;
-            uint32_t lock_quality:1,
-                dbm_noise:1,
-                dbm_signal:1,
-                fhss:1,
-                channel:1,
-                rate:1,
-                flags:1,
-                tsft:1,
-                reserved3:1,
-                tx_attenuation:1,
-                db_tx_attenuation:1,
-                dbm_tx_attenuation:1,
-                antenna:1,
-                db_signal:1,
-                db_noise:1,
-                rx_flags:1,
-                reserved2:5,
-                channel_plus:1,
-                reserved1:2,
-                reserved4:7,
-                ext:1;
+            union {
+                struct {
+                    uint32_t lock_quality:1,
+                        dbm_noise:1,
+                        dbm_signal:1,
+                        fhss:1,
+                        channel:1,
+                        rate:1,
+                        flags:1,
+                        tsft:1,
+                        reserved3:1,
+                        rx_flags:1,
+                        db_tx_attenuation:1,
+                        dbm_tx_attenuation:1,
+                        antenna:1,
+                        db_signal:1,
+                        db_noise:1,
+                        tx_attenuation:1,
+                        reserved2:5,
+                        channel_plus:1,
+                        reserved1:2,
+                        reserved4:7,
+                        ext:1;
+                } flags;
+                uint32_t flags_32;
+            };
         #endif
-        } __attribute__((__packed__));
+        } TINS_END_PACK;
         
         void init();
         void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
         
         
         radiotap_hdr _radio;
-        NetworkInterface _iface;
         // present fields...
         uint64_t _tsft;
-        uint32_t _channel_type;
-        uint16_t _channel_freq, _rx_flags;
-        uint8_t _antenna, _flags, _rate, _dbm_signal, _dbm_noise, _channel, _max_power;
+        uint16_t _channel_type, _channel_freq, _rx_flags, _signal_quality;
+        uint8_t _antenna, _flags, _rate, _dbm_signal, _dbm_noise, _channel, _max_power, _db_signal;
     };
-};
+}
 
 #endif // TINS_RADIOTAP_H

include/rawpdu.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -116,12 +116,33 @@ namespace Tins {
             return _payload.size();
         }
 
+        /**
+         * \brief Check wether ptr points to a valid response for this PDU.
+         *
+         * This always returns true, since we don't know what this 
+         * RawPDU is holding.
+         * 
+         * \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::RAW; }
         
+        /**
+         * \brief Constructs the given PDU type from the raw data stored
+         * in this RawPDU.
+         */
+        template<typename T>
+        T to() const {
+            return T(&_payload[0], _payload.size());
+        }
+        
         /**
          * \sa PDU::clone
          */
@@ -133,7 +154,7 @@ namespace Tins {
 
         payload_type _payload;
     };
-};
+}
 
 
 #endif // TINS_RAWPDU_H

include/rsn_information.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -74,14 +74,14 @@ namespace Tins{
         typedef std::vector<uint8_t> serialization_type;
 
         /**
-         * \brief Creates an instance of RSNInformation.
+         * \brief Constructs an RSNInformation object.
          *
          * By default, the version is set to 1.
          */
         RSNInformation();
         
         /**
-         * \brief Creates an instance of RSNInformation from a 
+         * \brief Constructs an RSNInformation object from a 
          * serialization_type object.
          * 
          * \param buffer The buffer from which to construct this object.
@@ -89,7 +89,10 @@ namespace Tins{
         RSNInformation(const serialization_type &buffer);
         
         /**
-         * \brief Constructor from buffer.
+         * \brief Constructs a RSNInformation from a buffer.
+         * 
+         * If the input is malformed, a malformed_packet exception is
+         * thrown.
          * 
          * \param buffer The buffer from which this object will be constructed.
          * \param total_sz The total size of the buffer.
@@ -110,7 +113,7 @@ namespace Tins{
         void add_pairwise_cypher(CypherSuites cypher);
 
         /**
-         * \brief Adds a akm suite.
+         * \brief Adds an akm suite.
          * \param akm The akm suite to be added.
          */
         void add_akm_cypher(AKMSuites akm);

include/sll.h

@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_SLL_H
+#define TINS_SLL_H
+
+#include <vector>
+#include "pdu.h"
+#include "endianness.h"
+#include "hw_address.h"
+
+namespace Tins {
+class SLL : public PDU {
+public:
+    /**
+     * This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::SLL;
+
+    /**
+     *  The type of the address type
+     */
+    typedef HWAddress<8> address_type;
+    
+    /**
+     * Default constructor
+     */
+    SLL();
+    
+    /**
+     * \brief Constructs a SLL 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 SLL 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.
+     */
+    SLL(const uint8_t *buffer, uint32_t total_sz);
+    
+    // Getters
+
+    /**
+     *  \brief Getter for the Packet Type field.
+     *  \return The stored Packet Type field value.
+     */
+    uint16_t packet_type() const {
+        return Endian::be_to_host(_header.packet_type);
+    }
+
+    /**
+     *  \brief Getter for the LLADDR Type field.
+     *  \return The stored LLADDR Type field value.
+     */
+    uint16_t lladdr_type() const {
+        return Endian::be_to_host(_header.lladdr_type);
+    }
+
+    /**
+     *  \brief Getter for the LLADDR Length field.
+     *  \return The stored LLADDR Length field value.
+     */
+    uint16_t lladdr_len() const {
+        return Endian::be_to_host(_header.lladdr_len);
+    }
+
+    /**
+     *  \brief Getter for the Address field.
+     *  \return The stored Address field value.
+     */
+    address_type address() const {
+        return _header.address;
+    }
+
+    /**
+     *  \brief Getter for the Protocol field.
+     *  \return The stored Protocol field value.
+     */
+    uint16_t protocol() const {
+        return Endian::be_to_host(_header.protocol);
+    }
+    
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+    
+    // Setters
+
+    /**
+     *  \brief Setter for the Packet Type field.
+     *  \param new_packet_type The new Packet Type field value.
+     */
+    void packet_type(uint16_t new_packet_type);
+
+    /**
+     *  \brief Setter for the LLADDR Type field.
+     *  \param new_lladdr_type The new LLADDR Type field value.
+     */
+    void lladdr_type(uint16_t new_lladdr_type);
+
+    /**
+     *  \brief Setter for the LLADDR Length field.
+     *  \param new_lladdr_len The new LLADDR Length field value.
+     */
+    void lladdr_len(uint16_t new_lladdr_len);
+
+    /**
+     *  \brief Setter for the Address field.
+     *  \param new_address The new Address field value.
+     */
+    void address(const address_type &new_address);
+
+    /**
+     *  \brief Setter for the Protocol field.
+     *  \param new_protocol The new Protocol field value.
+     */
+    void protocol(uint16_t new_protocol);
+    
+    /**
+     * \brief Returns the header size.
+     *
+     * This metod overrides PDU::header_size. \sa PDU::header_size
+     */
+    uint32_t header_size() const;
+    
+    /**
+     * \sa PDU::clone
+     */
+    SLL *clone() const {
+        return new SLL(*this);
+    }
+private:
+    TINS_BEGIN_PACK
+    struct sllhdr {
+        uint16_t packet_type, lladdr_type, lladdr_len;
+        uint8_t address[8];
+        uint16_t protocol;
+    } TINS_END_PACK;
+    
+    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *);
+    
+    sllhdr _header;
+};
+}
+
+#endif // TINS_SLL_H

include/small_uint.h

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

include/snap.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -33,6 +33,7 @@
 
 #include <stdint.h>
 #include "pdu.h"
+#include "macros.h"
 #include "endianness.h"
 #include "small_uint.h"
 
@@ -55,13 +56,18 @@ namespace Tins {
          * \brief Creates an instance of SNAP
          * This constructor sets the dsap and ssap fields to 0xaa, and
          * the id field to 3.
-         * \param child The child PDU.(optional)
          */
-        SNAP(PDU *child = 0);
+        SNAP();
         
         /**
-         * \brief Constructor which creates a SNAP object from a buffer and adds all identifiable
-         * PDUs found in the buffer as children of this one.
+         * \brief Constructs a SNAP 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 SNAP 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.
          */
@@ -70,40 +76,40 @@ namespace Tins {
         /* Setters */
         
         /**
-         * \brief Setter for the control field.
-         * \param new_id The new control to be set.
+         * \brief Setter for the Control field.
+         * \param new_id The new Control to be set.
          */
         void control(uint8_t new_control);
         
         /**
-         * \brief Setter for the org code field.
-         * \param new_org The new org code to be set.
+         * \brief Setter for the Organization Code field.
+         * \param new_org The new Organization Code to be set.
          */
         void org_code(small_uint<24> new_org);
         
         /**
-         * \brief Setter for the eth type field.
-         * \param new_eth The new eth type to be set.
+         * \brief Setter for the Ethernet Type field.
+         * \param new_eth The new Ethernet Type to be set.
          */
         void eth_type(uint16_t new_eth);
         
         /* Getters */
         
         /**
-         * \brief Getter for the dsap field.
-         * \return The dsap field.
+         * \brief Getter for the DSAP field.
+         * \return The DSAP field.
          */
         uint8_t dsap() const { return _snap.dsap; }
         
         /**
-         * \brief Getter for the ssap field.
-         * \return The ssap field.
+         * \brief Getter for the SSAP field.
+         * \return The SSAP field.
          */
         uint8_t ssap() const { return _snap.ssap; }
         
         /**
-         * \brief Getter for the control field.
-         * \return The control field.
+         * \brief Getter for the Control field.
+         * \return The Control field.
          */
         uint8_t control() const { 
             #if TINS_IS_LITTLE_ENDIAN
@@ -114,8 +120,8 @@ namespace Tins {
         }
         
         /**
-         * \brief Getter for the org code field.
-         * \return The org code field.
+         * \brief Getter for the Organization Code field.
+         * \return The Organization Code field.
          */        
         small_uint<24> org_code() const { 
             #if TINS_IS_LITTLE_ENDIAN
@@ -126,8 +132,8 @@ namespace Tins {
         }
         
         /**
-         * \brief Getter for the eth type field.
-         * \return The eth field.
+         * \brief Getter for the Ethernet Type field.
+         * \return The Ethernet Type field.
          */
         uint16_t eth_type() const { return Endian::be_to_host(_snap.eth_type); } 
         
@@ -143,7 +149,7 @@ namespace Tins {
          * \brief Getter for the PDU's type.
          * \sa PDU::pdu_type
          */
-        PDUType pdu_type() const { return PDU::SNAP; }
+        PDUType pdu_type() const { return pdu_flag; }
         
         /**
          * \brief Clones this PDU.
@@ -154,25 +160,18 @@ namespace Tins {
             return new SNAP(*this);
         }    
     private:
+        TINS_BEGIN_PACK
         struct snaphdr {
             uint8_t dsap;
             uint8_t ssap;
-            /*#if TINS_IS_LITTLE_ENDIAN
-                uint32_t control:8,
-                        org_code:24;
-            #elif TINS_IS_BIG_ENDIAN
-                uint32_t org_code:24,
-                        control:8;
-            #endif*/
             uint32_t control_org;
             uint16_t eth_type;
-        } __attribute__((__packed__));
+        } TINS_END_PACK;
         
         void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
         
         snaphdr _snap;
     };
-    
-};
+}
 
 #endif // TINS_SNAP_H

include/sniffer.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -36,13 +36,23 @@
 #include <string>
 #include <memory>
 #include <stdexcept>
+#include <iterator>
 #include "pdu.h"
 #include "ethernetII.h"
 #include "radiotap.h"
+#include "packet.h"
 #include "loopback.h"
-#include "dot11.h"
+#include "dot11/dot11_base.h"
+#include "dot3.h"
+#include "sll.h"
+#include "cxxstd.h"
+#include "exceptions.h"
+#include "internals.h"
+#include "ppi.h"
 
 namespace Tins {
+    class SnifferIterator;
+
     /**
      * \class BaseSniffer
      * \brief Base class for sniffers.
@@ -55,6 +65,35 @@ namespace Tins {
      */
     class BaseSniffer {
     public:
+        /**
+         * The iterator type.
+         */
+        typedef SnifferIterator iterator;
+
+        #if TINS_IS_CXX11
+            /**
+             * \brief Move constructor.
+             * This constructor is available only in C++11.
+             */
+            BaseSniffer(BaseSniffer &&rhs) noexcept 
+            : handle(nullptr), mask()
+            {
+                *this = std::move(rhs);
+            }
+            
+            /**
+             * \brief Move assignment operator.
+             * This operator is available only in C++11.
+             */
+            BaseSniffer& operator=(BaseSniffer &&rhs) noexcept 
+            {
+                using std::swap;
+                swap(handle, rhs.handle);
+                swap(mask, rhs.mask);
+                return *this;
+            }
+        #endif
+    
         /**
          * \brief Sniffer destructor.
          * This frees all memory used by the pcap handle.
@@ -64,33 +103,77 @@ namespace Tins {
         /**
          * \brief Compiles a filter and uses it to capture one packet.
          * 
-         * This method returns the first sniffed packet that matches the 
+         * This method returns the first valid sniffed packet that matches the 
          * sniffer's filter, or the first sniffed packet if no filter has
          * been set.
-         * \return The captured packet, matching the given filter, 0 if an
-         * error occured(probably compiling the filter).
+         * 
+         * The return type is a thin wrapper over a PDU* and a Timestamp
+         * object. This wrapper can be both implicitly converted to a 
+         * PDU* and a Packet object. So doing this:
+         * 
+         * \code
+         * Sniffer s(...);
+         * std::unique_ptr<PDU> pdu(s.next_packet());
+         * // Packet takes care of the PDU*. 
+         * Packet packet(s.next_packet());
+         * \endcode
+         * 
+         * Is fine, but this:
+         * 
+         * \code
+         * // bad!!
+         * PtrPacket p = s.next_packet();
+         * \endcode
+         * 
+         * Is not, since PtrPacket can't be copy constructed. 
+         * 
+         * \sa Packet::release_pdu
+         * 
+         * \return A captured packet. If an error occured, PtrPacket::pdu 
+         * will return 0. Caller takes ownership of the PDU pointer stored in 
+         * the PtrPacket.
          */
-        PDU *next_packet();
+        PtrPacket next_packet();
         
         /**
-         * \brief Starts a sniffing loop, using a callback object for every
+         * \brief Starts a sniffing loop, using a callback functor for every
          * sniffed packet.
          * 
-         * The callback object must implement an operator with the 
-         * following(or compatible) signature:
+         * The functor must implement an operator with one of the 
+         * following signatures:
          * 
-         * bool operator()(PDU&);
+         * \code
+         * bool(PDU&);
+         * bool(const PDU&);
+         * \endcode
          * 
-         * This operator will be called using the sniffed packets 
-         * as arguments. You can modify the PDU argument as you wish. 
-         * Calling PDU methods like PDU::release_inner_pdu is perfectly 
-         * valid.
+         * This functor will be called using the each of the sniffed packets 
+         * as its argument. Using PDU member functions that modify the PDU,
+         * such as PDU::release_inner_pdu, is perfectly valid.
          * 
-         * Note that the Functor object will be copied using its copy
-         * constructor, so that object should be some kind of proxy to
+         * Note that if you're using a functor object, it will be copied using 
+         * its copy constructor, so it should be some kind of proxy to
          * another object which will process the packets(e.g. std::bind).
+         *
+         * Sniffing will stop when either max_packets are sniffed(if it is != 0), 
+         * or when the functor returns false.
+         *
+         * This method catches both malformed_packet and pdu_not_found exceptions,
+         * which allows writing much cleaner code, since you can call PDU::rfind_pdu
+         * without worrying about catching the exception that can be thrown. This 
+         * allows writing code such as the following:
+         *
+        * \code
+         * bool callback(const PDU& pdu) {
+         *     // If either RawPDU is not found, or construction of the DNS 
+         *     // object fails, the BaseSniffer object will trap the exceptions, 
+         *     // so we don't need to worry about it.
+         *     DNS dns = pdu.rfind_pdu<RawPDU>().to<DNS>();
+         *     return true;
+         * }
+         * \endcode
          * 
-         * \param cback_handler The callback handler object which should process packets.
+         * \param function The callback handler object which should process packets.
          * \param max_packets The maximum amount of packets to sniff. 0 == infinite.
          */
         template<class Functor>
@@ -105,8 +188,34 @@ namespace Tins {
         
         /**
          * \brief Stops sniffing loops.
+         *
+         * This method must be called from the same thread from which
+         * BaseSniffer::sniff_loop was called.
          */
         void stop_sniff();
+
+        /**
+         * \brief Gets the file descriptor associated with the sniffer.
+         */
+        int get_fd();
+
+        /**
+         * \brief Retrieves this sniffer's link type.
+         *
+         * This calls pcap_datalink on the stored pcap handle and
+         * returns its result.
+         */
+        int link_type() const;
+
+        /**
+         * Retrieves an iterator to the next packet in this sniffer.
+         */
+        iterator begin();
+
+        /**
+         * Retrieves an end iterator.
+         */
+        iterator end();
     protected:
         /**
          * Default constructor.
@@ -124,43 +233,16 @@ namespace Tins {
          */
         void init(pcap_t *phandle, const std::string &filter, bpf_u_int32 if_mask);
     private:
-        template<class Functor>
-        struct LoopData {
-            pcap_t *handle;
-            Functor c_handler;
-            int iface_type;
-            
-            LoopData(pcap_t *_handle, const Functor _handler, 
-              int if_type) 
-            : handle(_handle), c_handler(_handler), iface_type(if_type) { }
-        };
-    
         BaseSniffer(const BaseSniffer&);
         BaseSniffer &operator=(const BaseSniffer&);
         
-        template<class ConcretePDU, class Functor>
-        static bool call_functor(LoopData<Functor> *data, const u_char *packet, size_t len);
-        
-        bool compile_set_filter(const std::string &filter, bpf_program &prog);
-        
-        template<class Functor>
-        static void callback_handler(u_char *args, const struct pcap_pkthdr *header, const u_char *packet);
-        
         pcap_t *handle;
         bpf_u_int32 mask;
-        bpf_program actual_filter;
-        int iface_type;
     };
     
     /** 
      * \class Sniffer
-     * \brief Sniffs packets using pcap filters.
-     * 
-     * This class uses a given filter to sniff packets and allow the user
-     * to handle them. Each time a filter is set, it's used until a new one
-     * is set. Both Sniffer::next_packet and Sniffer::sniff_loop have an
-     * optional filter parameter. If a filter is set using those parameter,
-     * the previously set filter is freed and the new one is used.
+     * \brief Sniffs packets from a network interface.
      */
     class Sniffer : public BaseSniffer {
     public:
@@ -177,7 +259,7 @@ namespace Tins {
     
     /**
      * \class FileSniffer
-     * \brief Parses pcap files and interprets the packets in it.
+     * \brief Reads pcap files and interprets the packets in it.
      * 
      * This class acts exactly in the same way that Sniffer, but reads
      * packets from a pcap file instead of an interface.
@@ -191,44 +273,6 @@ namespace Tins {
          */
         FileSniffer(const std::string &file_name, const std::string &filter = "");
     };
-        
-    template<class Functor>
-    void Tins::BaseSniffer::sniff_loop(Functor function, uint32_t max_packets) {
-        LoopData<Functor> data(handle, function, iface_type);
-        pcap_loop(handle, max_packets, &BaseSniffer::callback_handler<Functor>, (u_char*)&data);
-    }
-    
-    template<class ConcretePDU, class Functor>
-    bool Tins::BaseSniffer::call_functor(LoopData<Functor> *data, const u_char *packet, size_t len) {
-        ConcretePDU some_pdu((const uint8_t*)packet, len);
-        return data->c_handler(some_pdu);
-    }
-    
-    template<class Functor>
-    void Tins::BaseSniffer::callback_handler(u_char *args, const struct pcap_pkthdr *header, const u_char *packet) {
-        try {
-            std::auto_ptr<PDU> pdu;
-            LoopData<Functor> *data = reinterpret_cast<LoopData<Functor>*>(args);
-            bool ret_val(false);
-            if(data->iface_type == DLT_EN10MB)
-                ret_val = call_functor<Tins::EthernetII>(data, packet, header->caplen);
-            else if(data->iface_type == DLT_IEEE802_11_RADIO)
-                ret_val = call_functor<Tins::RadioTap>(data, packet, header->caplen);
-            else if(data->iface_type == DLT_IEEE802_11) {
-                std::auto_ptr<PDU> pdu(Tins::Dot11::from_bytes((const uint8_t*)packet, header->caplen));
-                if(pdu.get())
-                    ret_val = data->c_handler(*pdu);
-            }
-            else if(data->iface_type == DLT_NULL) 
-                ret_val = call_functor<Tins::Loopback>(data, packet, header->caplen);
-                
-            if(!ret_val)
-                pcap_breakloop(data->handle);
-        }
-        catch(...) {
-            
-        }
-    }
     
     template<class T>
     class HandlerProxy {
@@ -252,6 +296,96 @@ namespace Tins {
     {
         return HandlerProxy<T>(ptr, function);
     }
-};
+
+    /**
+     * \brief Iterates over packets sniffed by a BaseSniffer.
+     */
+    class SnifferIterator : public std::iterator<std::forward_iterator_tag, PDU> {
+    public:
+        /**
+         * Constructs a SnifferIterator.
+         * \param sniffer The sniffer to iterate.
+         */
+        SnifferIterator(BaseSniffer *sniffer = 0)
+        : sniffer(sniffer)
+        {
+            if(sniffer)
+                advance();
+        }
+
+        /**
+         * Advances the iterator.
+         */
+        SnifferIterator& operator++() {
+            advance();
+            return *this;
+        }
+
+        /**
+         * Advances the iterator.
+         */
+        SnifferIterator operator++(int) {
+            SnifferIterator other(*this);
+            advance();
+            return other;
+        }
+
+        /**
+         * Dereferences the iterator.
+         * \return reference to the current packet.
+         */
+        PDU &operator*() {
+            return *pkt.pdu();
+        }
+
+        /**
+         * Dereferences the iterator.
+         * \return pointer to the current packet.
+         */
+        PDU *operator->() {
+            return &(**this);
+        }
+
+        /**
+         * Compares this iterator for equality.
+         * \param rhs The iterator to be compared to.
+         */
+        bool operator==(const SnifferIterator &rhs) const {
+            return sniffer == rhs.sniffer;
+        }
+
+        /**
+         * Compares this iterator for in-equality.
+         * \param rhs The iterator to be compared to.
+         */
+        bool operator!=(const SnifferIterator &rhs) const {
+            return !(*this == rhs);
+        }
+    private:
+        void advance() {
+            pkt = sniffer->next_packet();
+            if(!pkt)
+                sniffer = 0;
+        }
+
+        BaseSniffer *sniffer;
+        Packet pkt;
+    };
+
+    template<class Functor>
+    void Tins::BaseSniffer::sniff_loop(Functor function, uint32_t max_packets) {
+        for(iterator it = begin(); it != end(); ++it) {
+            try {
+                // If the functor returns false, we're done
+                if(!function(*it))
+                    return;
+            }
+            catch(malformed_packet&) { }
+            catch(pdu_not_found&) { }
+            if(max_packets && --max_packets == 0)
+                return;
+        }
+    }
+}
     
 #endif // TINS_SNIFFER_H

include/stp.h

@@ -0,0 +1,307 @@
+/*
+ * Copyright (c) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_STP_H
+#define TINS_STP_H
+
+#include "pdu.h"
+#include "endianness.h"
+#include "hw_address.h"
+#include "small_uint.h"
+
+namespace Tins {
+class STP : public PDU {
+public:
+    /**
+     * This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::STP;
+    
+    /**
+     * The type used to store BPDU identifier addresses.
+     */
+    typedef HWAddress<6> address_type;
+    
+    /**
+     * The type used to store the BPDU identifiers.
+     */
+    struct bpdu_id_type {
+        small_uint<4> priority;
+        small_uint<12> ext_id;
+        address_type id;
+        
+        bpdu_id_type(small_uint<4> priority=0, small_uint<12> ext_id=0, 
+            const address_type& id=address_type())
+        : priority(priority), ext_id(ext_id), id(id) { }
+    };
+
+    /**
+     * \brief Default constructor.
+     */
+    STP();
+    
+    /**
+     * \brief Constructs a STP object from a buffer.
+     * 
+     * If there is not enough size for a STP 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.
+     */
+    STP(const uint8_t *buffer, uint32_t total_sz);
+
+    // Getters
+
+    /**
+     *  \brief Getter for the Protocol ID field.
+     *  \return The stored Protocol ID field value.
+     */
+    uint16_t proto_id() const {
+        return Endian::be_to_host(_header.proto_id);
+    }
+
+    /**
+     *  \brief Getter for the Protocol Version field.
+     *  \return The stored Protocol Version field value.
+     */
+    uint8_t proto_version() const {
+        return _header.proto_version;
+    }
+
+    /**
+     *  \brief Getter for the BDU Type field.
+     *  \return The stored BDU Type field value.
+     */
+    uint8_t bpdu_type() const {
+        return _header.bpdu_type;
+    }
+
+    /**
+     *  \brief Getter for the BDU Flags field.
+     *  \return The stored BDU Flags field value.
+     */
+    uint8_t bpdu_flags() const {
+        return _header.bpdu_flags;
+    }
+
+    /**
+     *  \brief Getter for the Root Path Cost field.
+     *  \return The stored Root Path Cost field value.
+     */
+    uint32_t root_path_cost() const {
+        return Endian::be_to_host(_header.root_path_cost);
+    }
+
+    /**
+     *  \brief Getter for the Port ID field.
+     *  \return The stored Port ID field value.
+     */
+    uint16_t port_id() const {
+        return Endian::be_to_host(_header.port_id);
+    }
+
+    /**
+     *  \brief Getter for the Message Age field.
+     *  \return The stored Message Age field value.
+     */
+    uint16_t msg_age() const {
+        return Endian::be_to_host(_header.msg_age) / 256;
+    }
+
+    /**
+     *  \brief Getter for the Maximum Age field.
+     *  \return The stored Maximum Age field value.
+     */
+    uint16_t max_age() const {
+        return Endian::be_to_host(_header.max_age) / 256;
+    }
+
+    /**
+     *  \brief Getter for the Hello Time field.
+     *  \return The stored Hello Time field value.
+     */
+    uint16_t hello_time() const {
+        return Endian::be_to_host(_header.hello_time) / 256;
+    }
+
+    /**
+     *  \brief Getter for the Forward Delay field.
+     *  \return The stored Forward Delay field value.
+     */
+    uint16_t fwd_delay() const {
+        return Endian::be_to_host(_header.fwd_delay) / 256;
+    }
+    
+    /**
+     *  \brief Getter for the Root ID field.
+     *  \return The stored Root ID field value.
+     */
+    bpdu_id_type root_id() const;
+    
+    /**
+     *  \brief Getter for the Bridge ID field.
+     *  \return The stored Bridge ID field value.
+     */
+    bpdu_id_type bridge_id() const;
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+
+    /**
+     * \sa PDU::clone
+     */
+    STP *clone() const {
+        return new STP(*this);
+    }
+    
+    /**
+    * \brief Returns the header size.
+    *
+    * This metod overrides PDU::header_size. \sa PDU::header_size
+    */
+    uint32_t header_size() const;
+
+    // Setters
+
+    /**
+     *  \brief Setter for the Protocol ID field.
+     *  \param new_proto_id The new Protocol ID field value.
+     */
+    void proto_id(uint16_t new_proto_id);
+
+    /**
+     *  \brief Setter for the Protocol Version field.
+     *  \param new_proto_version The new Protocol Version field value.
+     */
+    void proto_version(uint8_t new_proto_version);
+
+    /**
+     *  \brief Setter for the BPDU Type field.
+     *  \param new_bpdu_type The new BPDU Type field value.
+     */
+    void bpdu_type(uint8_t new_bpdu_type);
+
+    /**
+     *  \brief Setter for the BPDU Flags field.
+     *  \param new_bpdu_flags The new BPDU Flags field value.
+     */
+    void bpdu_flags(uint8_t new_bpdu_flags);
+
+    /**
+     *  \brief Setter for the Root Path Cost field.
+     *  \param new_root_path_cost The new Root Path Cost field value.
+     */
+    void root_path_cost(uint32_t new_root_path_cost);
+
+    /**
+     *  \brief Setter for the Port ID field.
+     *  \param new_port_id The new Port ID field value.
+     */
+    void port_id(uint16_t new_port_id);
+
+    /**
+     *  \brief Setter for the Message Age field.
+     *  \param new_msg_age The new Message Age field value.
+     */
+    void msg_age(uint16_t new_msg_age);
+
+    /**
+     *  \brief Setter for the Maximum Age field.
+     *  \param new_max_age The new Maximum Age field value.
+     */
+    void max_age(uint16_t new_max_age);
+
+    /**
+     *  \brief Setter for the Hello Time field.
+     *  \param new_hello_time The new Hello Time field value.
+     */
+    void hello_time(uint16_t new_hello_time);
+
+    /**
+     *  \brief Setter for the Forward Delay field.
+     *  \param new_fwd_delay The new Forward Delay field value.
+     */
+    void fwd_delay(uint16_t new_fwd_delay);
+    
+    /**
+     *  \brief Setter for the Root ID field.
+     *  \param new_fwd_delay The new Root ID field value.
+     */
+    void root_id(const bpdu_id_type &id);
+    
+    /**
+     *  \brief Setter for the Bridge ID field.
+     *  \param new_fwd_delay The new Bridge ID field value.
+     */
+    void bridge_id(const bpdu_id_type &id);
+private:
+    TINS_BEGIN_PACK
+    struct pvt_bpdu_id {
+        #if TINS_IS_LITTLE_ENDIAN 
+            // fixme
+            uint16_t ext_id:4,
+                    priority:4,
+                    ext_idL:8;
+        #else
+            uint16_t priority:4,
+                    ext_id:12;
+        #endif
+        uint8_t id[6];
+    } TINS_END_PACK;
+
+    TINS_BEGIN_PACK
+    struct stphdr {
+        uint16_t proto_id;
+        uint8_t proto_version;
+        uint8_t bpdu_type;
+        uint8_t bpdu_flags;
+        pvt_bpdu_id root_id;
+        uint32_t root_path_cost;
+        pvt_bpdu_id bridge_id;
+        uint16_t port_id;
+        uint16_t msg_age;
+        uint16_t max_age;
+        uint16_t hello_time;
+        uint16_t fwd_delay;
+    } TINS_END_PACK;
+    
+    static bpdu_id_type convert(const pvt_bpdu_id &id);
+    static pvt_bpdu_id convert(const bpdu_id_type &id);
+    
+    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
+    
+    stphdr _header;
+};
+}
+
+#endif // TINS_STP_H

include/tcp.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -37,9 +37,11 @@
 #include <stdexcept>
 #include <utility>
 #include "pdu.h"
+#include "macros.h"
 #include "endianness.h"
 #include "small_uint.h"
 #include "pdu_option.h"
+#include "cxxstd.h"
 
 namespace Tins {
     /**
@@ -62,14 +64,14 @@ namespace Tins {
          * These flags identify those supported by the TCP PDU.
          */
         enum Flags {
-            FIN,
-            SYN,
-            RST,
-            PSH,
-            ACK,
-            URG,
-            ECE,
-            CWR
+            FIN = 1,
+            SYN = 2,
+            RST = 4,
+            PSH = 8,
+            ACK = 16,
+            URG = 32,
+            ECE = 64,
+            CWR = 128
         };
 
         /**
@@ -77,8 +79,7 @@ namespace Tins {
          *
          * This enum identifies valid options supported by TCP PDU.
          */
-
-        enum Option {
+        enum OptionTypes {
             EOL     = 0,
             NOP     = 1,
             MSS     = 2,
@@ -98,12 +99,15 @@ namespace Tins {
             CHK_16FLETCHER
         };
         
-        typedef PDUOption<uint8_t> tcp_option;
+        /**
+         * The type used to store TCP options.
+         */
+        typedef PDUOption<uint8_t> option;
 
         /**
          * The type used to store the options.
          */
-        typedef std::list<tcp_option> options_type;
+        typedef std::list<option> options_type;
         
         /**
          * The type used to store the sack option.
@@ -121,9 +125,14 @@ namespace Tins {
         TCP(uint16_t dport = 0, uint16_t sport = 0);
 
         /**
-         * \brief Constructor which creates an TCP object from a buffer 
-         * and adds all identifiable PDUs found in the buffer as children
-         * of this one.
+         * \brief Constructs TCP object from a buffer.
+         * 
+         * If there is not enough size for a TCP header, or any of the
+         * TLV options are malformed a malformed_packet exception is 
+         * thrown.
+         * 
+         * Any extra data 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.
          */
@@ -169,7 +178,7 @@ namespace Tins {
          *
          * \return The checksum field in an uint16_t.
          */
-        uint16_t check() const { return Endian::be_to_host(_tcp.check); }
+        uint16_t checksum() const { return Endian::be_to_host(_tcp.check); }
 
         /**
          * \brief Getter for the urgent pointer field.
@@ -198,7 +207,25 @@ namespace Tins {
          * \param tcp_flag The polled flag.
          * \return The value of the flag.
          */
-        small_uint<1> get_flag(Flags tcp_flag);
+        small_uint<1> get_flag(Flags tcp_flag) const;
+
+        /**
+         * 
+         * \brief Gets the flags' values.
+         *
+         * All of the set flags will be joined together into
+         * a 12 bit value. This way, you can check for multiple
+         * flags at the same time:
+         * 
+         * \code
+         * TCP tcp = ...;
+         * if(tcp.flags() == (TCP::SYN | TCP::ACK))
+         *     // It's a SYN+ACK!
+         * \endcode
+         * 
+         * \return The value of the flags field.
+         */
+        small_uint<12> flags() const;
         
         /* Setters */
 
@@ -237,13 +264,6 @@ namespace Tins {
          */
         void window(uint16_t new_window);
 
-        /**
-         * \brief Setter for the checksum field.
-         *
-         * \param new_check The new checksum.
-         */
-        void check(uint16_t new_check);
-
         /**
          * \brief Setter for the urgent pointer field.
          *
@@ -350,15 +370,46 @@ namespace Tins {
          * \param value The new value for this flag. Must be 0 or 1.
          */
         void set_flag(Flags tcp_flag, small_uint<1> value);
+        
+        /**
+         * \brief Sets the value of the flag fields.
+         *
+         * This method can be used to set several flags at the 
+         * same time.
+         * 
+         * \code
+         * TCP tcp = ...;
+         * tcp.flags(TCP::SYN | TCP::ACK);
+         * // ...
+         * // only set the ACK, keeping the rest of the old flags.
+         * tcp.flags(tcp.flags() | TCP::ACK);
+         * \endcode
+         * 
+         * \param value The new value of the flags.
+         */
+        void flags(small_uint<12> value);
+        
 
         /**
          * \brief Adds a TCP option.
          *
-         * \param option The option type flag to be set.
-         * \param length The length of this option(optional).
-         * \param data Pointer to this option's data(optional).
+         * \param option The option to be added.
          */
-        void add_option(Option option, uint8_t length = 0, const uint8_t *data = 0);
+        void add_option(const option &opt);
+        
+        #if TINS_IS_CXX11
+            /**
+             * \brief Adds a TCP option.
+             *
+             * This move-constructs the option.
+             * 
+             * \param option The option to be added.
+             */
+            void add_option(option &&opt) {
+                internal_add_option(opt);
+                _options.push_back(std::move(opt));
+            }
+        #endif
 
         /**
          * \brief Returns the header size.
@@ -369,6 +420,15 @@ namespace Tins {
          * \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.
@@ -382,7 +442,7 @@ namespace Tins {
          * \param opt_flag The flag to be searched.
          * \return A pointer to the option, or 0 if it was not found.
          */
-        const tcp_option *search_option(Option opt) const;
+        const option *search_option(OptionTypes opt) const;
         
         /**
          * \sa PDU::clone
@@ -391,6 +451,7 @@ namespace Tins {
             return new TCP(*this);
         }
     private:
+        TINS_BEGIN_PACK
         struct tcphdr {
             uint16_t sport;
             uint16_t dport;
@@ -424,26 +485,28 @@ namespace Tins {
             uint16_t	window;
             uint16_t	check;
             uint16_t	urg_ptr;
-        } __attribute__((packed));
+        } TINS_END_PACK;
 
         static const uint16_t DEFAULT_WINDOW;
         
         template<class T> 
-        T generic_search(Option opt) const {
-            const tcp_option *option = search_option(opt);
+        T generic_search(OptionTypes opt) const {
+            const option *option = search_option(opt);
             if(option && option->data_size() == sizeof(T))
                 return *(const T*)(&option->data_ptr()[0]);
             throw option_not_found();
         }
-
-        void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
         
-        uint8_t *write_option(const tcp_option &opt, uint8_t *buffer);
+        void internal_add_option(const option &option);
+        void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
+        void checksum(uint16_t new_check);
+        
+        uint8_t *write_option(const option &opt, uint8_t *buffer);
 
         tcphdr _tcp;
+        uint16_t _options_size, _total_options_size;
         options_type _options;
-        uint32_t _options_size, _total_options_size;
     };
-};
+}
 
 #endif // TINS_TCP_H

include/tcp_stream.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -345,36 +345,34 @@ void TCPStreamFollower::follow_streams(ForwardIterator start, ForwardIterator en
 
 template<typename DataFunctor, typename EndFunctor>
 bool TCPStreamFollower::callback(PDU &pdu, const DataFunctor &data_fun, const EndFunctor &end_fun) {
-    IP *ip = pdu.find_pdu<IP>();
-    TCP *tcp = pdu.find_pdu<TCP>();
-    if(ip && tcp) {
-        TCPStream::StreamInfo info( 
-            ip->src_addr(), ip->dst_addr(),
-            tcp->sport(), tcp->dport()
-        );
-        sessions_type::iterator it = sessions.find(info);
-        if(it == sessions.end()) {
-            std::swap(info.client_addr, info.server_addr);
-            std::swap(info.client_port, info.server_port);
-            if((it = sessions.find(info)) == sessions.end()) {
-                if(tcp->get_flag(TCP::SYN) && !tcp->get_flag(TCP::ACK)) {
-                    sessions.insert(
-                        std::make_pair(
-                            info,
-                            TCPStream(ip, tcp, last_identifier++)
-                        )
-                    );
-                }
-                return true;
+    IP &ip = pdu.rfind_pdu<IP>();
+    TCP &tcp = pdu.rfind_pdu<TCP>();
+    TCPStream::StreamInfo info( 
+        ip.src_addr(), ip.dst_addr(),
+        tcp.sport(), tcp.dport()
+    );
+    sessions_type::iterator it = sessions.find(info);
+    if(it == sessions.end()) {
+        std::swap(info.client_addr, info.server_addr);
+        std::swap(info.client_port, info.server_port);
+        if((it = sessions.find(info)) == sessions.end()) {
+            if(tcp.get_flag(TCP::SYN) && !tcp.get_flag(TCP::ACK)) {
+                sessions.insert(
+                    std::make_pair(
+                        info,
+                        TCPStream(&ip, &tcp, last_identifier++)
+                    )
+                );
             }
+            return true;
         }
-        if(it->second.update(ip, tcp))
-            data_fun(it->second);
-        // We're done with this stream
-        if(it->second.is_finished()) {
-            end_fun(it->second);
-            sessions.erase(it);
-        }
+    }
+    if(it->second.update(&ip, &tcp))
+        data_fun(it->second);
+    // We're done with this stream
+    if(it->second.is_finished()) {
+        end_fun(it->second);
+        sessions.erase(it);
     }
     return true;
 }

include/timestamp.h

@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TINS_TIMESTAMP_H
+#define TINS_TIMESTAMP_H
+
+#ifdef WIN32
+    #define NOMINMAX
+    #include <winsock2.h>
+#else
+    #include <sys/time.h>
+#endif
+#include "cxxstd.h"
+#if TINS_IS_CXX11
+    #include <chrono>
+#endif
+
+namespace Tins {
+/**
+ * \brief Represents a packet timestamp.
+ */
+class Timestamp {
+public:
+    #ifdef WIN32
+        typedef long seconds_type;
+        typedef long microseconds_type;
+    #else
+        typedef time_t seconds_type;
+        typedef suseconds_t microseconds_type;
+    #endif
+    
+    /**
+     * \brief Constructs a Timestamp which will hold the current time.
+     */
+    static Timestamp current_time() {
+        #ifdef WIN32
+            //fixme
+            return Timestamp();
+        #else
+            timeval tv;
+            gettimeofday(&tv, 0);
+            return tv;
+        #endif
+    }
+    
+    /**
+     * Default constructs the timestamp.
+     */
+    Timestamp() : tv() {}
+    
+    /**
+     * Constructs a timestamp from a timeval object.
+     * \param time_val The timeval object.
+     */
+    Timestamp(const timeval &time_val) : tv(time_val) {}
+    
+    /**
+     * Returns the amount of seconds in this timestamp.
+     */
+    seconds_type seconds() const {
+        return tv.tv_sec;
+    }
+    
+    /**
+     * Returns the amount of microseconds in this timestamp.
+     */
+    microseconds_type microseconds() const {
+        return tv.tv_usec;
+    }
+    
+    #if TINS_IS_CXX11
+        /**
+         * Converts this Timestamp to a std::chrono::microseconds
+         */
+        operator std::chrono::microseconds() const {
+            return std::chrono::seconds(seconds()) +
+                std::chrono::microseconds(microseconds());
+        }
+    #endif
+private:
+    timeval tv;
+};
+}
+
+#endif // TINS_TIMESTAMP_H

include/tins.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,6 +30,7 @@
 #ifndef TINS_TINS_H
 #define TINS_TINS_H
 
+#include "dns.h"
 #include "arp.h"
 #include "bootp.h"
 #include "dhcp.h"
@@ -38,8 +39,12 @@
 #include "ieee802_3.h"
 #include "llc.h"
 #include "icmp.h"
+#include "icmpv6.h"
 #include "dot11.h"
+#include "dot1q.h"
+#include "dot3.h"
 #include "ip.h"
+#include "ipv6.h"
 #include "packet_sender.h"
 #include "packet_writer.h"
 #include "pdu.h"
@@ -50,10 +55,20 @@
 #include "tcp.h"
 #include "udp.h"
 #include "utils.h"
-#include "dns.h"
 #include "tcp_stream.h"
 #include "crypto.h"
 #include "pdu_cacher.h"
 #include "rsn_information.h"
+#include "ipv6_address.h"
+#include "ip_address.h"
+#include "packet.h"
+#include "timestamp.h"
+#include "sll.h"
+#include "dhcpv6.h"
+#include "pppoe.h"
+#include "stp.h"
+#include "handshake_capturer.h"
+#include "address_range.h"
+#include "pdu_allocator.h"
 
 #endif // TINS_TINS_H

include/udp.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,7 +30,7 @@
 #ifndef TINS_UDP_H
 #define TINS_UDP_H
 
-
+#include "macros.h"
 #include "pdu.h"
 #include "endianness.h"
 
@@ -51,17 +51,22 @@ namespace Tins {
         /** 
          * \brief UDP constructor.
          *
-         * Creates an instance of UDP. Destination and source port can
-         * be provided, otherwise both will be 0.
+         * Constructs an instance of UDP. The destination and source 
+         * port can be provided, otherwise both of them will be 0.
+         * 
          * \param dport Destination port.
          * \param sport Source port.
-         * \param child The child PDU(optional).
          * */
-        UDP(uint16_t dport = 0, uint16_t sport = 0, PDU *child = 0);
+        UDP(uint16_t dport = 0, uint16_t sport = 0);
 
         /**
-         * \brief Constructor which creates an UDP object from a buffer and adds all identifiable
-         * PDUs found in the buffer as children of this one.
+         * \brief Constructs an UDP object from a buffer.
+         * 
+         * If there is not enough size for a UDP header a malformed_packet 
+         * exception is thrown.
+         * 
+         * Any extra data 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.
          */
@@ -84,6 +89,12 @@ namespace Tins {
          * \return The length of the datagram.
          */
         uint16_t length() const { return Endian::be_to_host(_udp.len); }
+        
+        /**
+         * \brief Getter for the checksum of the datagram.
+         * \return The datagram's checksum.
+         */
+        uint16_t checksum() const { return Endian::be_to_host(_udp.check); }
 
         /** 
          * \brief Set the destination port.
@@ -91,19 +102,34 @@ namespace Tins {
          */
         void dport(uint16_t new_dport);
 
-        /** \brief Set the source port.
+        /** 
+         * \brief Set the source port.
          *
          * \param new_sport The new source port.
          */
         void sport(uint16_t new_sport);
         
-        /** \brief Getter for the length field.
+        /** 
+         * \brief Getter for the length field.
          * \param new_len The new length field.
          * \return The length field.
          */
         void length(uint16_t new_len);
 
-        /** \brief Returns the header size.
+        /**
+         * \brief Check wether ptr points to a valid response for this PDU.
+         *
+         * This compares the source and destination ports in the provided
+         * response with those stored in 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 Returns the header size.
          *
          * This metod overrides PDU::header_size. This size includes the
          * payload and options size. \sa PDU::header_size
@@ -119,22 +145,22 @@ namespace Tins {
         /**
          * \sa PDU::clone
          */
-        PDU *clone() const {
+        UDP *clone() const {
             return new UDP(*this);
         }
     private:
+        TINS_BEGIN_PACK
         struct udphdr {
             uint16_t sport;
             uint16_t dport;
             uint16_t len;
             uint16_t check;
-        } __attribute__((packed));
+        } TINS_END_PACK;
 
-        void copy_fields(const UDP *other);
         void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
 
         udphdr _udp;
     };
-};
+}
 
 #endif // TINS_UDP_H

include/utils.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -33,16 +33,30 @@
 #ifndef WIN32
     #include <ifaddrs.h>
 #else
+    #define NOMINMAX
     #include <winsock2.h>
     #include <iphlpapi.h>
     #undef interface
 #endif
+#include "macros.h"
+#if defined(BSD) || defined(__FreeBSD_kernel__)
+    #include <sys/file.h>
+    #include <sys/socket.h>
+    #include <sys/sysctl.h>
+
+    #include <net/if.h>
+    #include <net/route.h>
+    #include <netinet/in.h>
+#endif
 #include <string>
 #include <set>
 #include <fstream>
+#include <vector>
 #include <stdint.h>
 #include "ip_address.h"
+#include "ipv6_address.h"
 #include "hw_address.h"
+#include "internals.h"
 
 namespace Tins {
     class NetworkInterface;
@@ -81,7 +95,7 @@ namespace Tins {
              */
             IPv4Address mask;
         };
-
+        
         /** 
          * \brief Resolves a domain name and returns its corresponding ip address.
          *
@@ -90,20 +104,17 @@ namespace Tins {
          *
          * \param to_resolve The domain name/ip address to resolve.
          */
-        IPv4Address resolve_ip(const std::string &to_resolve);
-
+        IPv4Address resolve_domain(const std::string &to_resolve);
+        
         /** 
-         * \brief Resolves the hardware address for a given ip.
+         * \brief Resolves a domain name and returns its corresponding ip address.
          *
-         * \param iface The interface in which the packet will be sent.
-         * \param ip The ip to resolve, in integer format.
-         * \param buffer The buffer in which the host's hardware address will be stored.
-         * \param sender The sender to use to send and receive the ARP requests.
-         * \return Returns true if the hardware address was resolved successfully,
-         * false otherwise.
+         * If an ip address is given, its integer representation is returned.
+         * Otherwise, the domain name is resolved and its ip address is returned.
+         *
+         * \param to_resolve The domain name/ip address to resolve.
          */
-        bool resolve_hwaddr(const NetworkInterface &iface, IPv4Address ip, 
-          HWAddress<6> *address, PacketSender &sender);
+        IPv6Address resolve_domain6(const std::string &to_resolve);
         
         /** 
          * \brief Resolves the hardware address for a given ip.
@@ -118,6 +129,21 @@ namespace Tins {
          */
         HWAddress<6> resolve_hwaddr(const NetworkInterface &iface, 
           IPv4Address ip, PacketSender &sender);
+        
+        /** 
+         * \brief Resolves the hardware address for a given ip.
+         *
+         * If the address can't be resolved, a std::runtime_error
+         * exception is thrown.
+         * 
+         * This method sends and receives the packet through
+         * PacketSender::default_interface.
+         * 
+         * \param ip The ip to resolve, in integer format.
+         * \param sender The sender to use to send and receive the ARP requests.
+         * \return HWAddress<6> containing the resolved hardware address.
+         */
+        HWAddress<6> resolve_hwaddr(IPv4Address ip, PacketSender &sender);
 
         /** \brief List all network interfaces.
          *
@@ -190,6 +216,16 @@ namespace Tins {
          * \return The pseudo header checksum.
          */
         uint32_t pseudoheader_checksum(IPv4Address source_ip, IPv4Address dest_ip, uint32_t len, uint32_t flag);
+        
+        /** \brief Performs the pseudo header checksum used in TCP and UDP PDUs.
+         *
+         * \param source_ip The source ip address.
+         * \param dest_ip The destination ip address.
+         * \param len The length to be included in the pseudo header.
+         * \param flag The flag to use in the protocol field of the pseudo header.
+         * \return The pseudo header checksum.
+         */
+        uint32_t pseudoheader_checksum(IPv6Address source_ip, IPv6Address dest_ip, uint32_t len, uint32_t flag);
 
         /** \brief Generic function to iterate through interface and collect
          * data.
@@ -228,27 +264,6 @@ namespace Tins {
         }
         #endif // WIN32
         
-        /**
-         * \cond
-         */
-        namespace Internals {
-            void skip_line(std::istream &input);
-            bool from_hex(const std::string &str, uint32_t &result);
-            
-            template<bool, typename>
-            struct enable_if {
-                
-            };
-
-            template<typename T>
-            struct enable_if<true, T> {
-                typedef T type;
-            };
-        }
-        /**
-         * \endcond
-         */
-        
         template <typename T>
         struct is_pdu {  
             template <typename U>
@@ -280,12 +295,101 @@ namespace Tins {
         dereference_until_pdu(T &value) {
             return dereference_until_pdu(*value);
         }
+        #if defined(BSD) || defined(__FreeBSD_kernel__)
+        inline std::vector<char> query_route_table() {
+            int mib[6];
+            std::vector<char> buf;
+            size_t len;
+
+            mib[0] = CTL_NET;
+            mib[1] = AF_ROUTE;
+            mib[2] = 0;
+            mib[3] = AF_INET;
+            mib[4] = NET_RT_DUMP;
+            mib[5] = 0;	
+            if (sysctl(mib, 6, NULL, &len, NULL, 0) < 0)
+                throw std::runtime_error("sysctl failed");
+
+            buf.resize(len);
+            if (sysctl(mib, 6, &buf[0], &len, NULL, 0) < 0) {
+                throw std::runtime_error("sysctl failed");
+            }
+
+            return buf;
+        }
+
+        template<typename ForwardIterator>
+        void parse_header(struct rt_msghdr *rtm, ForwardIterator iter)
+        {
+            char *ptr = (char *)(rtm + 1);
+            sockaddr *sa = 0;
+
+            for (int i = 0; i < RTAX_MAX; i++) {
+                if (rtm->rtm_addrs & (1 << i)) {
+                    sa = (struct sockaddr *)ptr;
+                    ptr += sa->sa_len;
+                    if (sa->sa_family == 0)
+                        sa = 0;
+                } 
+                *iter++ = sa;
+            }
+        }
+        #endif
     }
 }
-
+#if defined(BSD) || defined(__FreeBSD_kernel__)
 template<class ForwardIterator>
 void Tins::Utils::route_entries(ForwardIterator output) {
-    using namespace Utils::Internals;
+    std::vector<char> buffer = query_route_table();
+    char *next = &buffer[0], *end = &buffer[buffer.size()];
+    rt_msghdr *rtm;
+    std::vector<sockaddr*> sa(RTAX_MAX);
+    char iface_name[IF_NAMESIZE];
+    while(next < end) {
+        rtm = (rt_msghdr*)next;
+        parse_header(rtm, sa.begin());
+        if (sa[RTAX_DST] && sa[RTAX_GATEWAY] && if_indextoname(rtm->rtm_index, iface_name)) {
+            RouteEntry entry;
+            entry.destination = IPv4Address(((struct sockaddr_in *)sa[RTAX_DST])->sin_addr.s_addr);
+            entry.gateway = IPv4Address(((struct sockaddr_in *)sa[RTAX_GATEWAY])->sin_addr.s_addr);
+            if(sa[RTAX_GENMASK])
+                entry.mask = IPv4Address(((struct sockaddr_in *)sa[RTAX_GENMASK])->sin_addr.s_addr);
+            else
+                entry.mask = IPv4Address(uint32_t());
+            entry.interface = iface_name;
+            *output++ = entry;
+        }
+        next += rtm->rtm_msglen;
+    }
+}
+#elif defined(WIN32)
+template<class ForwardIterator>
+void Tins::Utils::route_entries(ForwardIterator output) {
+    MIB_IPFORWARDTABLE *table;
+    ULONG size = 0;
+    char iface_name[256];
+    GetIpForwardTable(0, &size, 0);
+    std::vector<uint8_t> buffer(size);
+    table = (MIB_IPFORWARDTABLE*)&buffer[0];
+    GetIpForwardTable(table, &size, 0);
+    
+    for (DWORD i = 0; i < table->dwNumEntries; i++) {
+        MIB_IPFORWARDROW *row = &table->table[i];
+        if(row->dwForwardType == MIB_IPROUTE_TYPE_INDIRECT) {
+            if_indextoname(row->dwForwardIfIndex, iface_name);
+            RouteEntry entry;
+            entry.interface = iface_name;
+            entry.destination = IPv4Address(row->dwForwardDest);
+            entry.mask = IPv4Address(row->dwForwardMask);
+            entry.gateway = IPv4Address(row->dwForwardNextHop);
+            *output++ = entry;
+        }
+    }
+}
+#else
+template<class ForwardIterator>
+void Tins::Utils::route_entries(ForwardIterator output) {
+    using namespace Tins::Internals;
     std::ifstream input("/proc/net/route");
     std::string destination, mask, gw;
     uint32_t dummy;
@@ -305,5 +409,6 @@ void Tins::Utils::route_entries(ForwardIterator output) {
         ++output;
     }
 }
+#endif
 
 #endif // TINS_UTILS_H

install-sh

@@ -0,0 +1,527 @@
+#!/bin/sh
+# install - install a program, script, or datafile
+
+scriptversion=2011-01-19.21; # UTC
+
+# This originates from X11R5 (mit/util/scripts/install.sh), which was
+# later released in X11R6 (xc/config/util/install.sh) with the
+# following copyright and license.
+#
+# Copyright (C) 1994 X Consortium
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
+# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# Except as contained in this notice, the name of the X Consortium shall not
+# be used in advertising or otherwise to promote the sale, use or other deal-
+# ings in this Software without prior written authorization from the X Consor-
+# tium.
+#
+#
+# FSF changes to this file are in the public domain.
+#
+# Calling this script install-sh is preferred over install.sh, to prevent
+# `make' implicit rules from creating a file called install from it
+# when there is no Makefile.
+#
+# This script is compatible with the BSD install script, but was written
+# from scratch.
+
+nl='
+'
+IFS=" ""	$nl"
+
+# set DOITPROG to echo to test this script
+
+# Don't use :- since 4.3BSD and earlier shells don't like it.
+doit=${DOITPROG-}
+if test -z "$doit"; then
+  doit_exec=exec
+else
+  doit_exec=$doit
+fi
+
+# Put in absolute file names if you don't have them in your path;
+# or use environment vars.
+
+chgrpprog=${CHGRPPROG-chgrp}
+chmodprog=${CHMODPROG-chmod}
+chownprog=${CHOWNPROG-chown}
+cmpprog=${CMPPROG-cmp}
+cpprog=${CPPROG-cp}
+mkdirprog=${MKDIRPROG-mkdir}
+mvprog=${MVPROG-mv}
+rmprog=${RMPROG-rm}
+stripprog=${STRIPPROG-strip}
+
+posix_glob='?'
+initialize_posix_glob='
+  test "$posix_glob" != "?" || {
+    if (set -f) 2>/dev/null; then
+      posix_glob=
+    else
+      posix_glob=:
+    fi
+  }
+'
+
+posix_mkdir=
+
+# Desired mode of installed file.
+mode=0755
+
+chgrpcmd=
+chmodcmd=$chmodprog
+chowncmd=
+mvcmd=$mvprog
+rmcmd="$rmprog -f"
+stripcmd=
+
+src=
+dst=
+dir_arg=
+dst_arg=
+
+copy_on_change=false
+no_target_directory=
+
+usage="\
+Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
+   or: $0 [OPTION]... SRCFILES... DIRECTORY
+   or: $0 [OPTION]... -t DIRECTORY SRCFILES...
+   or: $0 [OPTION]... -d DIRECTORIES...
+
+In the 1st form, copy SRCFILE to DSTFILE.
+In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
+In the 4th, create DIRECTORIES.
+
+Options:
+     --help     display this help and exit.
+     --version  display version info and exit.
+
+  -c            (ignored)
+  -C            install only if different (preserve the last data modification time)
+  -d            create directories instead of installing files.
+  -g GROUP      $chgrpprog installed files to GROUP.
+  -m MODE       $chmodprog installed files to MODE.
+  -o USER       $chownprog installed files to USER.
+  -s            $stripprog installed files.
+  -t DIRECTORY  install into DIRECTORY.
+  -T            report an error if DSTFILE is a directory.
+
+Environment variables override the default commands:
+  CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
+  RMPROG STRIPPROG
+"
+
+while test $# -ne 0; do
+  case $1 in
+    -c) ;;
+
+    -C) copy_on_change=true;;
+
+    -d) dir_arg=true;;
+
+    -g) chgrpcmd="$chgrpprog $2"
+	shift;;
+
+    --help) echo "$usage"; exit $?;;
+
+    -m) mode=$2
+	case $mode in
+	  *' '* | *'	'* | *'
+'*	  | *'*'* | *'?'* | *'['*)
+	    echo "$0: invalid mode: $mode" >&2
+	    exit 1;;
+	esac
+	shift;;
+
+    -o) chowncmd="$chownprog $2"
+	shift;;
+
+    -s) stripcmd=$stripprog;;
+
+    -t) dst_arg=$2
+	# Protect names problematic for `test' and other utilities.
+	case $dst_arg in
+	  -* | [=\(\)!]) dst_arg=./$dst_arg;;
+	esac
+	shift;;
+
+    -T) no_target_directory=true;;
+
+    --version) echo "$0 $scriptversion"; exit $?;;
+
+    --)	shift
+	break;;
+
+    -*)	echo "$0: invalid option: $1" >&2
+	exit 1;;
+
+    *)  break;;
+  esac
+  shift
+done
+
+if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
+  # When -d is used, all remaining arguments are directories to create.
+  # When -t is used, the destination is already specified.
+  # Otherwise, the last argument is the destination.  Remove it from $@.
+  for arg
+  do
+    if test -n "$dst_arg"; then
+      # $@ is not empty: it contains at least $arg.
+      set fnord "$@" "$dst_arg"
+      shift # fnord
+    fi
+    shift # arg
+    dst_arg=$arg
+    # Protect names problematic for `test' and other utilities.
+    case $dst_arg in
+      -* | [=\(\)!]) dst_arg=./$dst_arg;;
+    esac
+  done
+fi
+
+if test $# -eq 0; then
+  if test -z "$dir_arg"; then
+    echo "$0: no input file specified." >&2
+    exit 1
+  fi
+  # It's OK to call `install-sh -d' without argument.
+  # This can happen when creating conditional directories.
+  exit 0
+fi
+
+if test -z "$dir_arg"; then
+  do_exit='(exit $ret); exit $ret'
+  trap "ret=129; $do_exit" 1
+  trap "ret=130; $do_exit" 2
+  trap "ret=141; $do_exit" 13
+  trap "ret=143; $do_exit" 15
+
+  # Set umask so as not to create temps with too-generous modes.
+  # However, 'strip' requires both read and write access to temps.
+  case $mode in
+    # Optimize common cases.
+    *644) cp_umask=133;;
+    *755) cp_umask=22;;
+
+    *[0-7])
+      if test -z "$stripcmd"; then
+	u_plus_rw=
+      else
+	u_plus_rw='% 200'
+      fi
+      cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
+    *)
+      if test -z "$stripcmd"; then
+	u_plus_rw=
+      else
+	u_plus_rw=,u+rw
+      fi
+      cp_umask=$mode$u_plus_rw;;
+  esac
+fi
+
+for src
+do
+  # Protect names problematic for `test' and other utilities.
+  case $src in
+    -* | [=\(\)!]) src=./$src;;
+  esac
+
+  if test -n "$dir_arg"; then
+    dst=$src
+    dstdir=$dst
+    test -d "$dstdir"
+    dstdir_status=$?
+  else
+
+    # Waiting for this to be detected by the "$cpprog $src $dsttmp" command
+    # might cause directories to be created, which would be especially bad
+    # if $src (and thus $dsttmp) contains '*'.
+    if test ! -f "$src" && test ! -d "$src"; then
+      echo "$0: $src does not exist." >&2
+      exit 1
+    fi
+
+    if test -z "$dst_arg"; then
+      echo "$0: no destination specified." >&2
+      exit 1
+    fi
+    dst=$dst_arg
+
+    # If destination is a directory, append the input filename; won't work
+    # if double slashes aren't ignored.
+    if test -d "$dst"; then
+      if test -n "$no_target_directory"; then
+	echo "$0: $dst_arg: Is a directory" >&2
+	exit 1
+      fi
+      dstdir=$dst
+      dst=$dstdir/`basename "$src"`
+      dstdir_status=0
+    else
+      # Prefer dirname, but fall back on a substitute if dirname fails.
+      dstdir=`
+	(dirname "$dst") 2>/dev/null ||
+	expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	     X"$dst" : 'X\(//\)[^/]' \| \
+	     X"$dst" : 'X\(//\)$' \| \
+	     X"$dst" : 'X\(/\)' \| . 2>/dev/null ||
+	echo X"$dst" |
+	    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+		   s//\1/
+		   q
+		 }
+		 /^X\(\/\/\)[^/].*/{
+		   s//\1/
+		   q
+		 }
+		 /^X\(\/\/\)$/{
+		   s//\1/
+		   q
+		 }
+		 /^X\(\/\).*/{
+		   s//\1/
+		   q
+		 }
+		 s/.*/./; q'
+      `
+
+      test -d "$dstdir"
+      dstdir_status=$?
+    fi
+  fi
+
+  obsolete_mkdir_used=false
+
+  if test $dstdir_status != 0; then
+    case $posix_mkdir in
+      '')
+	# Create intermediate dirs using mode 755 as modified by the umask.
+	# This is like FreeBSD 'install' as of 1997-10-28.
+	umask=`umask`
+	case $stripcmd.$umask in
+	  # Optimize common cases.
+	  *[2367][2367]) mkdir_umask=$umask;;
+	  .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;;
+
+	  *[0-7])
+	    mkdir_umask=`expr $umask + 22 \
+	      - $umask % 100 % 40 + $umask % 20 \
+	      - $umask % 10 % 4 + $umask % 2
+	    `;;
+	  *) mkdir_umask=$umask,go-w;;
+	esac
+
+	# With -d, create the new directory with the user-specified mode.
+	# Otherwise, rely on $mkdir_umask.
+	if test -n "$dir_arg"; then
+	  mkdir_mode=-m$mode
+	else
+	  mkdir_mode=
+	fi
+
+	posix_mkdir=false
+	case $umask in
+	  *[123567][0-7][0-7])
+	    # POSIX mkdir -p sets u+wx bits regardless of umask, which
+	    # is incompatible with FreeBSD 'install' when (umask & 300) != 0.
+	    ;;
+	  *)
+	    tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
+	    trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0
+
+	    if (umask $mkdir_umask &&
+		exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1
+	    then
+	      if test -z "$dir_arg" || {
+		   # Check for POSIX incompatibilities with -m.
+		   # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
+		   # other-writeable bit of parent directory when it shouldn't.
+		   # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
+		   ls_ld_tmpdir=`ls -ld "$tmpdir"`
+		   case $ls_ld_tmpdir in
+		     d????-?r-*) different_mode=700;;
+		     d????-?--*) different_mode=755;;
+		     *) false;;
+		   esac &&
+		   $mkdirprog -m$different_mode -p -- "$tmpdir" && {
+		     ls_ld_tmpdir_1=`ls -ld "$tmpdir"`
+		     test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
+		   }
+		 }
+	      then posix_mkdir=:
+	      fi
+	      rmdir "$tmpdir/d" "$tmpdir"
+	    else
+	      # Remove any dirs left behind by ancient mkdir implementations.
+	      rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null
+	    fi
+	    trap '' 0;;
+	esac;;
+    esac
+
+    if
+      $posix_mkdir && (
+	umask $mkdir_umask &&
+	$doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
+      )
+    then :
+    else
+
+      # The umask is ridiculous, or mkdir does not conform to POSIX,
+      # or it failed possibly due to a race condition.  Create the
+      # directory the slow way, step by step, checking for races as we go.
+
+      case $dstdir in
+	/*) prefix='/';;
+	[-=\(\)!]*) prefix='./';;
+	*)  prefix='';;
+      esac
+
+      eval "$initialize_posix_glob"
+
+      oIFS=$IFS
+      IFS=/
+      $posix_glob set -f
+      set fnord $dstdir
+      shift
+      $posix_glob set +f
+      IFS=$oIFS
+
+      prefixes=
+
+      for d
+      do
+	test X"$d" = X && continue
+
+	prefix=$prefix$d
+	if test -d "$prefix"; then
+	  prefixes=
+	else
+	  if $posix_mkdir; then
+	    (umask=$mkdir_umask &&
+	     $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
+	    # Don't fail if two instances are running concurrently.
+	    test -d "$prefix" || exit 1
+	  else
+	    case $prefix in
+	      *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
+	      *) qprefix=$prefix;;
+	    esac
+	    prefixes="$prefixes '$qprefix'"
+	  fi
+	fi
+	prefix=$prefix/
+      done
+
+      if test -n "$prefixes"; then
+	# Don't fail if two instances are running concurrently.
+	(umask $mkdir_umask &&
+	 eval "\$doit_exec \$mkdirprog $prefixes") ||
+	  test -d "$dstdir" || exit 1
+	obsolete_mkdir_used=true
+      fi
+    fi
+  fi
+
+  if test -n "$dir_arg"; then
+    { test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&
+    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&
+    { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||
+      test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1
+  else
+
+    # Make a couple of temp file names in the proper directory.
+    dsttmp=$dstdir/_inst.$$_
+    rmtmp=$dstdir/_rm.$$_
+
+    # Trap to clean up those temp files at exit.
+    trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
+
+    # Copy the file name to the temp name.
+    (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") &&
+
+    # and set any options; do chmod last to preserve setuid bits.
+    #
+    # If any of these fail, we abort the whole thing.  If we want to
+    # ignore errors from any of these, just make sure not to ignore
+    # errors from the above "$doit $cpprog $src $dsttmp" command.
+    #
+    { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&
+    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&
+    { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&
+    { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&
+
+    # If -C, don't bother to copy if it wouldn't change the file.
+    if $copy_on_change &&
+       old=`LC_ALL=C ls -dlL "$dst"	2>/dev/null` &&
+       new=`LC_ALL=C ls -dlL "$dsttmp"	2>/dev/null` &&
+
+       eval "$initialize_posix_glob" &&
+       $posix_glob set -f &&
+       set X $old && old=:$2:$4:$5:$6 &&
+       set X $new && new=:$2:$4:$5:$6 &&
+       $posix_glob set +f &&
+
+       test "$old" = "$new" &&
+       $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
+    then
+      rm -f "$dsttmp"
+    else
+      # Rename the file to the real destination.
+      $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||
+
+      # The rename failed, perhaps because mv can't rename something else
+      # to itself, or perhaps because mv is so ancient that it does not
+      # support -f.
+      {
+	# Now remove or move aside any old file at destination location.
+	# We try this two ways since rm can't unlink itself on some
+	# systems and the destination file might be busy for other
+	# reasons.  In this case, the final cleanup might fail but the new
+	# file should still install successfully.
+	{
+	  test ! -f "$dst" ||
+	  $doit $rmcmd -f "$dst" 2>/dev/null ||
+	  { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
+	    { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
+	  } ||
+	  { echo "$0: cannot unlink or rename $dst" >&2
+	    (exit 1); exit 1
+	  }
+	} &&
+
+	# Now rename the file to the real destination.
+	$doit $mvcmd "$dsttmp" "$dst"
+      }
+    fi || exit 1
+
+    trap '' 0
+  fi
+done
+
+# Local variables:
+# 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:

libtins.pc.in

@@ -0,0 +1,11 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: @PACKAGE_NAME@
+Description: C++ packet crafting, sniffing and interpretation library.
+Version: @PACKAGE_VERSION@
+URL: @PACKAGE_URL@
+Libs: -L${libdir} -ltins
+Cflags: -I${includedir}/tins

m4/ax_cxx_compile_stdcxx_11.m4

@@ -0,0 +1,134 @@
+# ============================================================================
+#  http://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx_11.html
+# ============================================================================
+#
+# SYNOPSIS
+#
+#   AX_CXX_COMPILE_STDCXX_11([ext|noext],[mandatory|optional])
+#
+# DESCRIPTION
+#
+#   Check for baseline language coverage in the compiler for the C++11
+#   standard; if necessary, add switches to CXXFLAGS to enable support.
+#
+#   The first argument, if specified, indicates whether you insist on an
+#   extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g.
+#   -std=c++11).  If neither is specified, you get whatever works, with
+#   preference for an extended mode.
+#
+#   The second argument, if specified 'mandatory' or if left unspecified,
+#   indicates that baseline C++11 support is required and that the macro
+#   should error out if no mode with that support is found.  If specified
+#   'optional', then configuration proceeds regardless, after defining
+#   HAVE_CXX11 if and only if a supporting mode is found.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>
+#   Copyright (c) 2012 Zack Weinberg <zackw@panix.com>
+#   Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 3
+
+m4_define([_AX_CXX_COMPILE_STDCXX_11_testbody], [
+  template <typename T>
+    struct check
+    {
+      static_assert(sizeof(int) <= sizeof(T), "not big enough");
+    };
+
+    typedef check<check<bool>> right_angle_brackets;
+
+    int a;
+    decltype(a) b;
+
+    typedef check<int> check_type;
+    check_type c;
+    check_type&& cr = static_cast<check_type&&>(c);
+
+    auto d = a;
+])
+
+AC_DEFUN([AX_CXX_COMPILE_STDCXX_11], [dnl
+  m4_if([$1], [], [],
+        [$1], [ext], [],
+        [$1], [noext], [],
+        [m4_fatal([invalid argument `$1' to AX_CXX_COMPILE_STDCXX_11])])dnl
+  m4_if([$2], [], [ax_cxx_compile_cxx11_required=true],
+        [$2], [mandatory], [ax_cxx_compile_cxx11_required=true],
+        [$2], [optional], [ax_cxx_compile_cxx11_required=false],
+        [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX_11])])dnl
+  AC_LANG_PUSH([C++])dnl
+  ac_success=no
+  AC_CACHE_CHECK(whether $CXX supports C++11 features by default,
+  ax_cv_cxx_compile_cxx11,
+  [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],
+    [ax_cv_cxx_compile_cxx11=yes],
+    [ax_cv_cxx_compile_cxx11=no])])
+  if test x$ax_cv_cxx_compile_cxx11 = xyes; then
+    ac_success=yes
+  fi
+
+  m4_if([$1], [noext], [], [dnl
+  if test x$ac_success = xno; then
+    for switch in -std=gnu++11 -std=gnu++0x; do
+      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx11_$switch])
+      AC_CACHE_CHECK(whether $CXX supports C++11 features with $switch,
+                     $cachevar,
+        [ac_save_CXXFLAGS="$CXXFLAGS"
+         CXXFLAGS="$CXXFLAGS $switch"
+         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],
+          [eval $cachevar=yes],
+          [eval $cachevar=no])
+         CXXFLAGS="$ac_save_CXXFLAGS"])
+      if eval test x\$$cachevar = xyes; then
+        CXXFLAGS="$CXXFLAGS $switch"
+        ac_success=yes
+        break
+      fi
+    done
+  fi])
+
+  m4_if([$1], [ext], [], [dnl
+  if test x$ac_success = xno; then
+    for switch in -std=c++11 -std=c++0x; do
+      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx11_$switch])
+      AC_CACHE_CHECK(whether $CXX supports C++11 features with $switch,
+                     $cachevar,
+        [ac_save_CXXFLAGS="$CXXFLAGS"
+         CXXFLAGS="$CXXFLAGS $switch"
+         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],
+          [eval $cachevar=yes],
+          [eval $cachevar=no])
+         CXXFLAGS="$ac_save_CXXFLAGS"])
+      if eval test x\$$cachevar = xyes; then
+        CXXFLAGS="$CXXFLAGS $switch"
+        ac_success=yes
+        break
+      fi
+    done
+  fi])
+  AC_LANG_POP([C++])
+  if test x$ax_cxx_compile_cxx11_required = xtrue; then
+    if test x$ac_success = xno; then
+      AC_MSG_ERROR([*** A compiler with support for C++11 language features is required.])
+    fi
+  else
+    if test x$ac_success = xno; then
+      HAVE_CXX11=0
+      AC_MSG_NOTICE([No compiler with C++11 support was found])
+    else
+      HAVE_CXX11=1
+      AC_DEFINE(HAVE_CXX11,1,
+                [define if the compiler supports basic C++11 syntax])
+    fi
+
+    AC_SUBST(HAVE_CXX11)
+  fi
+])
+

m4/ltoptions.m4

@@ -0,0 +1,384 @@
+# Helper functions for option handling.                    -*- Autoconf -*-
+#
+#   Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation,
+#   Inc.
+#   Written by Gary V. Vaughan, 2004
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# serial 7 ltoptions.m4
+
+# This is to help aclocal find these macros, as it can't see m4_define.
+AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])])
+
+
+# _LT_MANGLE_OPTION(MACRO-NAME, OPTION-NAME)
+# ------------------------------------------
+m4_define([_LT_MANGLE_OPTION],
+[[_LT_OPTION_]m4_bpatsubst($1__$2, [[^a-zA-Z0-9_]], [_])])
+
+
+# _LT_SET_OPTION(MACRO-NAME, OPTION-NAME)
+# ---------------------------------------
+# Set option OPTION-NAME for macro MACRO-NAME, and if there is a
+# matching handler defined, dispatch to it.  Other OPTION-NAMEs are
+# saved as a flag.
+m4_define([_LT_SET_OPTION],
+[m4_define(_LT_MANGLE_OPTION([$1], [$2]))dnl
+m4_ifdef(_LT_MANGLE_DEFUN([$1], [$2]),
+        _LT_MANGLE_DEFUN([$1], [$2]),
+    [m4_warning([Unknown $1 option `$2'])])[]dnl
+])
+
+
+# _LT_IF_OPTION(MACRO-NAME, OPTION-NAME, IF-SET, [IF-NOT-SET])
+# ------------------------------------------------------------
+# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
+m4_define([_LT_IF_OPTION],
+[m4_ifdef(_LT_MANGLE_OPTION([$1], [$2]), [$3], [$4])])
+
+
+# _LT_UNLESS_OPTIONS(MACRO-NAME, OPTION-LIST, IF-NOT-SET)
+# -------------------------------------------------------
+# Execute IF-NOT-SET unless all options in OPTION-LIST for MACRO-NAME
+# are set.
+m4_define([_LT_UNLESS_OPTIONS],
+[m4_foreach([_LT_Option], m4_split(m4_normalize([$2])),
+	    [m4_ifdef(_LT_MANGLE_OPTION([$1], _LT_Option),
+		      [m4_define([$0_found])])])[]dnl
+m4_ifdef([$0_found], [m4_undefine([$0_found])], [$3
+])[]dnl
+])
+
+
+# _LT_SET_OPTIONS(MACRO-NAME, OPTION-LIST)
+# ----------------------------------------
+# OPTION-LIST is a space-separated list of Libtool options associated
+# with MACRO-NAME.  If any OPTION has a matching handler declared with
+# LT_OPTION_DEFINE, dispatch to that macro; otherwise complain about
+# the unknown option and exit.
+m4_defun([_LT_SET_OPTIONS],
+[# Set options
+m4_foreach([_LT_Option], m4_split(m4_normalize([$2])),
+    [_LT_SET_OPTION([$1], _LT_Option)])
+
+m4_if([$1],[LT_INIT],[
+  dnl
+  dnl Simply set some default values (i.e off) if boolean options were not
+  dnl specified:
+  _LT_UNLESS_OPTIONS([LT_INIT], [dlopen], [enable_dlopen=no
+  ])
+  _LT_UNLESS_OPTIONS([LT_INIT], [win32-dll], [enable_win32_dll=no
+  ])
+  dnl
+  dnl If no reference was made to various pairs of opposing options, then
+  dnl we run the default mode handler for the pair.  For example, if neither
+  dnl `shared' nor `disable-shared' was passed, we enable building of shared
+  dnl archives by default:
+  _LT_UNLESS_OPTIONS([LT_INIT], [shared disable-shared], [_LT_ENABLE_SHARED])
+  _LT_UNLESS_OPTIONS([LT_INIT], [static disable-static], [_LT_ENABLE_STATIC])
+  _LT_UNLESS_OPTIONS([LT_INIT], [pic-only no-pic], [_LT_WITH_PIC])
+  _LT_UNLESS_OPTIONS([LT_INIT], [fast-install disable-fast-install],
+  		   [_LT_ENABLE_FAST_INSTALL])
+  ])
+])# _LT_SET_OPTIONS
+
+
+## --------------------------------- ##
+## Macros to handle LT_INIT options. ##
+## --------------------------------- ##
+
+# _LT_MANGLE_DEFUN(MACRO-NAME, OPTION-NAME)
+# -----------------------------------------
+m4_define([_LT_MANGLE_DEFUN],
+[[_LT_OPTION_DEFUN_]m4_bpatsubst(m4_toupper([$1__$2]), [[^A-Z0-9_]], [_])])
+
+
+# LT_OPTION_DEFINE(MACRO-NAME, OPTION-NAME, CODE)
+# -----------------------------------------------
+m4_define([LT_OPTION_DEFINE],
+[m4_define(_LT_MANGLE_DEFUN([$1], [$2]), [$3])[]dnl
+])# LT_OPTION_DEFINE
+
+
+# dlopen
+# ------
+LT_OPTION_DEFINE([LT_INIT], [dlopen], [enable_dlopen=yes
+])
+
+AU_DEFUN([AC_LIBTOOL_DLOPEN],
+[_LT_SET_OPTION([LT_INIT], [dlopen])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the `dlopen' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_DLOPEN], [])
+
+
+# win32-dll
+# ---------
+# Declare package support for building win32 dll's.
+LT_OPTION_DEFINE([LT_INIT], [win32-dll],
+[enable_win32_dll=yes
+
+case $host in
+*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc*)
+  AC_CHECK_TOOL(AS, as, false)
+  AC_CHECK_TOOL(DLLTOOL, dlltool, false)
+  AC_CHECK_TOOL(OBJDUMP, objdump, false)
+  ;;
+esac
+
+test -z "$AS" && AS=as
+_LT_DECL([], [AS],      [1], [Assembler program])dnl
+
+test -z "$DLLTOOL" && DLLTOOL=dlltool
+_LT_DECL([], [DLLTOOL], [1], [DLL creation program])dnl
+
+test -z "$OBJDUMP" && OBJDUMP=objdump
+_LT_DECL([], [OBJDUMP], [1], [Object dumper program])dnl
+])# win32-dll
+
+AU_DEFUN([AC_LIBTOOL_WIN32_DLL],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+_LT_SET_OPTION([LT_INIT], [win32-dll])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the `win32-dll' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_WIN32_DLL], [])
+
+
+# _LT_ENABLE_SHARED([DEFAULT])
+# ----------------------------
+# implement the --enable-shared flag, and supports the `shared' and
+# `disable-shared' LT_INIT options.
+# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
+m4_define([_LT_ENABLE_SHARED],
+[m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([shared],
+    [AS_HELP_STRING([--enable-shared@<:@=PKGS@:>@],
+	[build shared libraries @<:@default=]_LT_ENABLE_SHARED_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_shared=yes ;;
+    no) enable_shared=no ;;
+    *)
+      enable_shared=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      for pkg in $enableval; do
+	IFS="$lt_save_ifs"
+	if test "X$pkg" = "X$p"; then
+	  enable_shared=yes
+	fi
+      done
+      IFS="$lt_save_ifs"
+      ;;
+    esac],
+    [enable_shared=]_LT_ENABLE_SHARED_DEFAULT)
+
+    _LT_DECL([build_libtool_libs], [enable_shared], [0],
+	[Whether or not to build shared libraries])
+])# _LT_ENABLE_SHARED
+
+LT_OPTION_DEFINE([LT_INIT], [shared], [_LT_ENABLE_SHARED([yes])])
+LT_OPTION_DEFINE([LT_INIT], [disable-shared], [_LT_ENABLE_SHARED([no])])
+
+# Old names:
+AC_DEFUN([AC_ENABLE_SHARED],
+[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[shared])
+])
+
+AC_DEFUN([AC_DISABLE_SHARED],
+[_LT_SET_OPTION([LT_INIT], [disable-shared])
+])
+
+AU_DEFUN([AM_ENABLE_SHARED], [AC_ENABLE_SHARED($@)])
+AU_DEFUN([AM_DISABLE_SHARED], [AC_DISABLE_SHARED($@)])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AM_ENABLE_SHARED], [])
+dnl AC_DEFUN([AM_DISABLE_SHARED], [])
+
+
+
+# _LT_ENABLE_STATIC([DEFAULT])
+# ----------------------------
+# implement the --enable-static flag, and support the `static' and
+# `disable-static' LT_INIT options.
+# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
+m4_define([_LT_ENABLE_STATIC],
+[m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([static],
+    [AS_HELP_STRING([--enable-static@<:@=PKGS@:>@],
+	[build static libraries @<:@default=]_LT_ENABLE_STATIC_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_static=yes ;;
+    no) enable_static=no ;;
+    *)
+     enable_static=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      for pkg in $enableval; do
+	IFS="$lt_save_ifs"
+	if test "X$pkg" = "X$p"; then
+	  enable_static=yes
+	fi
+      done
+      IFS="$lt_save_ifs"
+      ;;
+    esac],
+    [enable_static=]_LT_ENABLE_STATIC_DEFAULT)
+
+    _LT_DECL([build_old_libs], [enable_static], [0],
+	[Whether or not to build static libraries])
+])# _LT_ENABLE_STATIC
+
+LT_OPTION_DEFINE([LT_INIT], [static], [_LT_ENABLE_STATIC([yes])])
+LT_OPTION_DEFINE([LT_INIT], [disable-static], [_LT_ENABLE_STATIC([no])])
+
+# Old names:
+AC_DEFUN([AC_ENABLE_STATIC],
+[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[static])
+])
+
+AC_DEFUN([AC_DISABLE_STATIC],
+[_LT_SET_OPTION([LT_INIT], [disable-static])
+])
+
+AU_DEFUN([AM_ENABLE_STATIC], [AC_ENABLE_STATIC($@)])
+AU_DEFUN([AM_DISABLE_STATIC], [AC_DISABLE_STATIC($@)])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AM_ENABLE_STATIC], [])
+dnl AC_DEFUN([AM_DISABLE_STATIC], [])
+
+
+
+# _LT_ENABLE_FAST_INSTALL([DEFAULT])
+# ----------------------------------
+# implement the --enable-fast-install flag, and support the `fast-install'
+# and `disable-fast-install' LT_INIT options.
+# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
+m4_define([_LT_ENABLE_FAST_INSTALL],
+[m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([fast-install],
+    [AS_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@],
+    [optimize for fast installation @<:@default=]_LT_ENABLE_FAST_INSTALL_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_fast_install=yes ;;
+    no) enable_fast_install=no ;;
+    *)
+      enable_fast_install=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      for pkg in $enableval; do
+	IFS="$lt_save_ifs"
+	if test "X$pkg" = "X$p"; then
+	  enable_fast_install=yes
+	fi
+      done
+      IFS="$lt_save_ifs"
+      ;;
+    esac],
+    [enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT)
+
+_LT_DECL([fast_install], [enable_fast_install], [0],
+	 [Whether or not to optimize for fast installation])dnl
+])# _LT_ENABLE_FAST_INSTALL
+
+LT_OPTION_DEFINE([LT_INIT], [fast-install], [_LT_ENABLE_FAST_INSTALL([yes])])
+LT_OPTION_DEFINE([LT_INIT], [disable-fast-install], [_LT_ENABLE_FAST_INSTALL([no])])
+
+# Old names:
+AU_DEFUN([AC_ENABLE_FAST_INSTALL],
+[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you put
+the `fast-install' option into LT_INIT's first parameter.])
+])
+
+AU_DEFUN([AC_DISABLE_FAST_INSTALL],
+[_LT_SET_OPTION([LT_INIT], [disable-fast-install])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you put
+the `disable-fast-install' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_ENABLE_FAST_INSTALL], [])
+dnl AC_DEFUN([AM_DISABLE_FAST_INSTALL], [])
+
+
+# _LT_WITH_PIC([MODE])
+# --------------------
+# implement the --with-pic flag, and support the `pic-only' and `no-pic'
+# LT_INIT options.
+# MODE is either `yes' or `no'.  If omitted, it defaults to `both'.
+m4_define([_LT_WITH_PIC],
+[AC_ARG_WITH([pic],
+    [AS_HELP_STRING([--with-pic@<:@=PKGS@:>@],
+	[try to use only PIC/non-PIC objects @<:@default=use both@:>@])],
+    [lt_p=${PACKAGE-default}
+    case $withval in
+    yes|no) pic_mode=$withval ;;
+    *)
+      pic_mode=default
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      for lt_pkg in $withval; do
+	IFS="$lt_save_ifs"
+	if test "X$lt_pkg" = "X$lt_p"; then
+	  pic_mode=yes
+	fi
+      done
+      IFS="$lt_save_ifs"
+      ;;
+    esac],
+    [pic_mode=default])
+
+test -z "$pic_mode" && pic_mode=m4_default([$1], [default])
+
+_LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl
+])# _LT_WITH_PIC
+
+LT_OPTION_DEFINE([LT_INIT], [pic-only], [_LT_WITH_PIC([yes])])
+LT_OPTION_DEFINE([LT_INIT], [no-pic], [_LT_WITH_PIC([no])])
+
+# Old name:
+AU_DEFUN([AC_LIBTOOL_PICMODE],
+[_LT_SET_OPTION([LT_INIT], [pic-only])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the `pic-only' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_PICMODE], [])
+
+## ----------------- ##
+## LTDL_INIT Options ##
+## ----------------- ##
+
+m4_define([_LTDL_MODE], [])
+LT_OPTION_DEFINE([LTDL_INIT], [nonrecursive],
+		 [m4_define([_LTDL_MODE], [nonrecursive])])
+LT_OPTION_DEFINE([LTDL_INIT], [recursive],
+		 [m4_define([_LTDL_MODE], [recursive])])
+LT_OPTION_DEFINE([LTDL_INIT], [subproject],
+		 [m4_define([_LTDL_MODE], [subproject])])
+
+m4_define([_LTDL_TYPE], [])
+LT_OPTION_DEFINE([LTDL_INIT], [installable],
+		 [m4_define([_LTDL_TYPE], [installable])])
+LT_OPTION_DEFINE([LTDL_INIT], [convenience],
+		 [m4_define([_LTDL_TYPE], [convenience])])

m4/ltsugar.m4

@@ -0,0 +1,123 @@
+# ltsugar.m4 -- libtool m4 base layer.                         -*-Autoconf-*-
+#
+# Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
+# Written by Gary V. Vaughan, 2004
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# serial 6 ltsugar.m4
+
+# This is to help aclocal find these macros, as it can't see m4_define.
+AC_DEFUN([LTSUGAR_VERSION], [m4_if([0.1])])
+
+
+# lt_join(SEP, ARG1, [ARG2...])
+# -----------------------------
+# Produce ARG1SEPARG2...SEPARGn, omitting [] arguments and their
+# associated separator.
+# Needed until we can rely on m4_join from Autoconf 2.62, since all earlier
+# versions in m4sugar had bugs.
+m4_define([lt_join],
+[m4_if([$#], [1], [],
+       [$#], [2], [[$2]],
+       [m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift(m4_shift($@)))])])
+m4_define([_lt_join],
+[m4_if([$#$2], [2], [],
+       [m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift(m4_shift($@)))])])
+
+
+# lt_car(LIST)
+# lt_cdr(LIST)
+# ------------
+# Manipulate m4 lists.
+# These macros are necessary as long as will still need to support
+# Autoconf-2.59 which quotes differently.
+m4_define([lt_car], [[$1]])
+m4_define([lt_cdr],
+[m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])],
+       [$#], 1, [],
+       [m4_dquote(m4_shift($@))])])
+m4_define([lt_unquote], $1)
+
+
+# lt_append(MACRO-NAME, STRING, [SEPARATOR])
+# ------------------------------------------
+# Redefine MACRO-NAME to hold its former content plus `SEPARATOR'`STRING'.
+# Note that neither SEPARATOR nor STRING are expanded; they are appended
+# to MACRO-NAME as is (leaving the expansion for when MACRO-NAME is invoked).
+# No SEPARATOR is output if MACRO-NAME was previously undefined (different
+# than defined and empty).
+#
+# This macro is needed until we can rely on Autoconf 2.62, since earlier
+# versions of m4sugar mistakenly expanded SEPARATOR but not STRING.
+m4_define([lt_append],
+[m4_define([$1],
+	   m4_ifdef([$1], [m4_defn([$1])[$3]])[$2])])
+
+
+
+# lt_combine(SEP, PREFIX-LIST, INFIX, SUFFIX1, [SUFFIX2...])
+# ----------------------------------------------------------
+# Produce a SEP delimited list of all paired combinations of elements of
+# PREFIX-LIST with SUFFIX1 through SUFFIXn.  Each element of the list
+# has the form PREFIXmINFIXSUFFIXn.
+# Needed until we can rely on m4_combine added in Autoconf 2.62.
+m4_define([lt_combine],
+[m4_if(m4_eval([$# > 3]), [1],
+       [m4_pushdef([_Lt_sep], [m4_define([_Lt_sep], m4_defn([lt_car]))])]]dnl
+[[m4_foreach([_Lt_prefix], [$2],
+	     [m4_foreach([_Lt_suffix],
+		]m4_dquote(m4_dquote(m4_shift(m4_shift(m4_shift($@)))))[,
+	[_Lt_sep([$1])[]m4_defn([_Lt_prefix])[$3]m4_defn([_Lt_suffix])])])])])
+
+
+# lt_if_append_uniq(MACRO-NAME, VARNAME, [SEPARATOR], [UNIQ], [NOT-UNIQ])
+# -----------------------------------------------------------------------
+# Iff MACRO-NAME does not yet contain VARNAME, then append it (delimited
+# by SEPARATOR if supplied) and expand UNIQ, else NOT-UNIQ.
+m4_define([lt_if_append_uniq],
+[m4_ifdef([$1],
+	  [m4_if(m4_index([$3]m4_defn([$1])[$3], [$3$2$3]), [-1],
+		 [lt_append([$1], [$2], [$3])$4],
+		 [$5])],
+	  [lt_append([$1], [$2], [$3])$4])])
+
+
+# lt_dict_add(DICT, KEY, VALUE)
+# -----------------------------
+m4_define([lt_dict_add],
+[m4_define([$1($2)], [$3])])
+
+
+# lt_dict_add_subkey(DICT, KEY, SUBKEY, VALUE)
+# --------------------------------------------
+m4_define([lt_dict_add_subkey],
+[m4_define([$1($2:$3)], [$4])])
+
+
+# lt_dict_fetch(DICT, KEY, [SUBKEY])
+# ----------------------------------
+m4_define([lt_dict_fetch],
+[m4_ifval([$3],
+	m4_ifdef([$1($2:$3)], [m4_defn([$1($2:$3)])]),
+    m4_ifdef([$1($2)], [m4_defn([$1($2)])]))])
+
+
+# lt_if_dict_fetch(DICT, KEY, [SUBKEY], VALUE, IF-TRUE, [IF-FALSE])
+# -----------------------------------------------------------------
+m4_define([lt_if_dict_fetch],
+[m4_if(lt_dict_fetch([$1], [$2], [$3]), [$4],
+	[$5],
+    [$6])])
+
+
+# lt_dict_filter(DICT, [SUBKEY], VALUE, [SEPARATOR], KEY, [...])
+# --------------------------------------------------------------
+m4_define([lt_dict_filter],
+[m4_if([$5], [], [],
+  [lt_join(m4_quote(m4_default([$4], [[, ]])),
+           lt_unquote(m4_split(m4_normalize(m4_foreach(_Lt_key, lt_car([m4_shiftn(4, $@)]),
+		      [lt_if_dict_fetch([$1], _Lt_key, [$2], [$3], [_Lt_key ])])))))])[]dnl
+])

m4/ltversion.m4

@@ -0,0 +1,23 @@
+# ltversion.m4 -- version numbers			-*- Autoconf -*-
+#
+#   Copyright (C) 2004 Free Software Foundation, Inc.
+#   Written by Scott James Remnant, 2004
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# @configure_input@
+
+# serial 3337 ltversion.m4
+# This file is part of GNU Libtool
+
+m4_define([LT_PACKAGE_VERSION], [2.4.2])
+m4_define([LT_PACKAGE_REVISION], [1.3337])
+
+AC_DEFUN([LTVERSION_VERSION],
+[macro_version='2.4.2'
+macro_revision='1.3337'
+_LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?])
+_LT_DECL(, macro_revision, 0)
+])

m4/lt~obsolete.m4

@@ -0,0 +1,98 @@
+# lt~obsolete.m4 -- aclocal satisfying obsolete definitions.    -*-Autoconf-*-
+#
+#   Copyright (C) 2004, 2005, 2007, 2009 Free Software Foundation, Inc.
+#   Written by Scott James Remnant, 2004.
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# serial 5 lt~obsolete.m4
+
+# These exist entirely to fool aclocal when bootstrapping libtool.
+#
+# In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN)
+# which have later been changed to m4_define as they aren't part of the
+# exported API, or moved to Autoconf or Automake where they belong.
+#
+# The trouble is, aclocal is a bit thick.  It'll see the old AC_DEFUN
+# in /usr/share/aclocal/libtool.m4 and remember it, then when it sees us
+# using a macro with the same name in our local m4/libtool.m4 it'll
+# pull the old libtool.m4 in (it doesn't see our shiny new m4_define
+# and doesn't know about Autoconf macros at all.)
+#
+# So we provide this file, which has a silly filename so it's always
+# included after everything else.  This provides aclocal with the
+# AC_DEFUNs it wants, but when m4 processes it, it doesn't do anything
+# because those macros already exist, or will be overwritten later.
+# We use AC_DEFUN over AU_DEFUN for compatibility with aclocal-1.6. 
+#
+# Anytime we withdraw an AC_DEFUN or AU_DEFUN, remember to add it here.
+# Yes, that means every name once taken will need to remain here until
+# we give up compatibility with versions before 1.7, at which point
+# we need to keep only those names which we still refer to.
+
+# This is to help aclocal find these macros, as it can't see m4_define.
+AC_DEFUN([LTOBSOLETE_VERSION], [m4_if([1])])
+
+m4_ifndef([AC_LIBTOOL_LINKER_OPTION],	[AC_DEFUN([AC_LIBTOOL_LINKER_OPTION])])
+m4_ifndef([AC_PROG_EGREP],		[AC_DEFUN([AC_PROG_EGREP])])
+m4_ifndef([_LT_AC_PROG_ECHO_BACKSLASH],	[AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH])])
+m4_ifndef([_LT_AC_SHELL_INIT],		[AC_DEFUN([_LT_AC_SHELL_INIT])])
+m4_ifndef([_LT_AC_SYS_LIBPATH_AIX],	[AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX])])
+m4_ifndef([_LT_PROG_LTMAIN],		[AC_DEFUN([_LT_PROG_LTMAIN])])
+m4_ifndef([_LT_AC_TAGVAR],		[AC_DEFUN([_LT_AC_TAGVAR])])
+m4_ifndef([AC_LTDL_ENABLE_INSTALL],	[AC_DEFUN([AC_LTDL_ENABLE_INSTALL])])
+m4_ifndef([AC_LTDL_PREOPEN],		[AC_DEFUN([AC_LTDL_PREOPEN])])
+m4_ifndef([_LT_AC_SYS_COMPILER],	[AC_DEFUN([_LT_AC_SYS_COMPILER])])
+m4_ifndef([_LT_AC_LOCK],		[AC_DEFUN([_LT_AC_LOCK])])
+m4_ifndef([AC_LIBTOOL_SYS_OLD_ARCHIVE],	[AC_DEFUN([AC_LIBTOOL_SYS_OLD_ARCHIVE])])
+m4_ifndef([_LT_AC_TRY_DLOPEN_SELF],	[AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF])])
+m4_ifndef([AC_LIBTOOL_PROG_CC_C_O],	[AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O])])
+m4_ifndef([AC_LIBTOOL_SYS_HARD_LINK_LOCKS], [AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS])])
+m4_ifndef([AC_LIBTOOL_OBJDIR],		[AC_DEFUN([AC_LIBTOOL_OBJDIR])])
+m4_ifndef([AC_LTDL_OBJDIR],		[AC_DEFUN([AC_LTDL_OBJDIR])])
+m4_ifndef([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH], [AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH])])
+m4_ifndef([AC_LIBTOOL_SYS_LIB_STRIP],	[AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP])])
+m4_ifndef([AC_PATH_MAGIC],		[AC_DEFUN([AC_PATH_MAGIC])])
+m4_ifndef([AC_PROG_LD_GNU],		[AC_DEFUN([AC_PROG_LD_GNU])])
+m4_ifndef([AC_PROG_LD_RELOAD_FLAG],	[AC_DEFUN([AC_PROG_LD_RELOAD_FLAG])])
+m4_ifndef([AC_DEPLIBS_CHECK_METHOD],	[AC_DEFUN([AC_DEPLIBS_CHECK_METHOD])])
+m4_ifndef([AC_LIBTOOL_PROG_COMPILER_NO_RTTI], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI])])
+m4_ifndef([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE], [AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])])
+m4_ifndef([AC_LIBTOOL_PROG_COMPILER_PIC], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC])])
+m4_ifndef([AC_LIBTOOL_PROG_LD_SHLIBS],	[AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS])])
+m4_ifndef([AC_LIBTOOL_POSTDEP_PREDEP],	[AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP])])
+m4_ifndef([LT_AC_PROG_EGREP],		[AC_DEFUN([LT_AC_PROG_EGREP])])
+m4_ifndef([LT_AC_PROG_SED],		[AC_DEFUN([LT_AC_PROG_SED])])
+m4_ifndef([_LT_CC_BASENAME],		[AC_DEFUN([_LT_CC_BASENAME])])
+m4_ifndef([_LT_COMPILER_BOILERPLATE],	[AC_DEFUN([_LT_COMPILER_BOILERPLATE])])
+m4_ifndef([_LT_LINKER_BOILERPLATE],	[AC_DEFUN([_LT_LINKER_BOILERPLATE])])
+m4_ifndef([_AC_PROG_LIBTOOL],		[AC_DEFUN([_AC_PROG_LIBTOOL])])
+m4_ifndef([AC_LIBTOOL_SETUP],		[AC_DEFUN([AC_LIBTOOL_SETUP])])
+m4_ifndef([_LT_AC_CHECK_DLFCN],		[AC_DEFUN([_LT_AC_CHECK_DLFCN])])
+m4_ifndef([AC_LIBTOOL_SYS_DYNAMIC_LINKER],	[AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER])])
+m4_ifndef([_LT_AC_TAGCONFIG],		[AC_DEFUN([_LT_AC_TAGCONFIG])])
+m4_ifndef([AC_DISABLE_FAST_INSTALL],	[AC_DEFUN([AC_DISABLE_FAST_INSTALL])])
+m4_ifndef([_LT_AC_LANG_CXX],		[AC_DEFUN([_LT_AC_LANG_CXX])])
+m4_ifndef([_LT_AC_LANG_F77],		[AC_DEFUN([_LT_AC_LANG_F77])])
+m4_ifndef([_LT_AC_LANG_GCJ],		[AC_DEFUN([_LT_AC_LANG_GCJ])])
+m4_ifndef([AC_LIBTOOL_LANG_C_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_C_CONFIG])])
+m4_ifndef([_LT_AC_LANG_C_CONFIG],	[AC_DEFUN([_LT_AC_LANG_C_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_CXX_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_CXX_CONFIG])])
+m4_ifndef([_LT_AC_LANG_CXX_CONFIG],	[AC_DEFUN([_LT_AC_LANG_CXX_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_F77_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_F77_CONFIG])])
+m4_ifndef([_LT_AC_LANG_F77_CONFIG],	[AC_DEFUN([_LT_AC_LANG_F77_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_GCJ_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_GCJ_CONFIG])])
+m4_ifndef([_LT_AC_LANG_GCJ_CONFIG],	[AC_DEFUN([_LT_AC_LANG_GCJ_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_RC_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_RC_CONFIG])])
+m4_ifndef([_LT_AC_LANG_RC_CONFIG],	[AC_DEFUN([_LT_AC_LANG_RC_CONFIG])])
+m4_ifndef([AC_LIBTOOL_CONFIG],		[AC_DEFUN([AC_LIBTOOL_CONFIG])])
+m4_ifndef([_LT_AC_FILE_LTDLL_C],	[AC_DEFUN([_LT_AC_FILE_LTDLL_C])])
+m4_ifndef([_LT_REQUIRED_DARWIN_CHECKS],	[AC_DEFUN([_LT_REQUIRED_DARWIN_CHECKS])])
+m4_ifndef([_LT_AC_PROG_CXXCPP],		[AC_DEFUN([_LT_AC_PROG_CXXCPP])])
+m4_ifndef([_LT_PREPARE_SED_QUOTE_VARS],	[AC_DEFUN([_LT_PREPARE_SED_QUOTE_VARS])])
+m4_ifndef([_LT_PROG_ECHO_BACKSLASH],	[AC_DEFUN([_LT_PROG_ECHO_BACKSLASH])])
+m4_ifndef([_LT_PROG_F77],		[AC_DEFUN([_LT_PROG_F77])])
+m4_ifndef([_LT_PROG_FC],		[AC_DEFUN([_LT_PROG_FC])])
+m4_ifndef([_LT_PROG_CXX],		[AC_DEFUN([_LT_PROG_CXX])])

missing

@@ -0,0 +1,331 @@
+#! /bin/sh
+# Common stub for a few missing GNU programs while installing.
+
+scriptversion=2012-01-06.13; # UTC
+
+# Copyright (C) 1996, 1997, 1999, 2000, 2002, 2003, 2004, 2005, 2006,
+# 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
+# Originally by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.
+
+# 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.
+
+if test $# -eq 0; then
+  echo 1>&2 "Try \`$0 --help' for more information"
+  exit 1
+fi
+
+run=:
+sed_output='s/.* --output[ =]\([^ ]*\).*/\1/p'
+sed_minuso='s/.* -o \([^ ]*\).*/\1/p'
+
+# In the cases where this matters, `missing' is being run in the
+# srcdir already.
+if test -f configure.ac; then
+  configure_ac=configure.ac
+else
+  configure_ac=configure.in
+fi
+
+msg="missing on your system"
+
+case $1 in
+--run)
+  # Try to run requested program, and just exit if it succeeds.
+  run=
+  shift
+  "$@" && exit 0
+  # Exit code 63 means version mismatch.  This often happens
+  # when the user try to use an ancient version of a tool on
+  # a file that requires a minimum version.  In this case we
+  # we should proceed has if the program had been absent, or
+  # if --run hadn't been passed.
+  if test $? = 63; then
+    run=:
+    msg="probably too old"
+  fi
+  ;;
+
+  -h|--h|--he|--hel|--help)
+    echo "\
+$0 [OPTION]... PROGRAM [ARGUMENT]...
+
+Handle \`PROGRAM [ARGUMENT]...' for when PROGRAM is missing, or return an
+error status if there is no known handling for PROGRAM.
+
+Options:
+  -h, --help      display this help and exit
+  -v, --version   output version information and exit
+  --run           try to run the given command, and emulate it if it fails
+
+Supported PROGRAM values:
+  aclocal      touch file \`aclocal.m4'
+  autoconf     touch file \`configure'
+  autoheader   touch file \`config.h.in'
+  autom4te     touch the output file, or create a stub one
+  automake     touch all \`Makefile.in' files
+  bison        create \`y.tab.[ch]', if possible, from existing .[ch]
+  flex         create \`lex.yy.c', if possible, from existing .c
+  help2man     touch the output file
+  lex          create \`lex.yy.c', if possible, from existing .c
+  makeinfo     touch the output file
+  yacc         create \`y.tab.[ch]', if possible, from existing .[ch]
+
+Version suffixes to PROGRAM as well as the prefixes \`gnu-', \`gnu', and
+\`g' are ignored when checking the name.
+
+Send bug reports to <bug-automake@gnu.org>."
+    exit $?
+    ;;
+
+  -v|--v|--ve|--ver|--vers|--versi|--versio|--version)
+    echo "missing $scriptversion (GNU Automake)"
+    exit $?
+    ;;
+
+  -*)
+    echo 1>&2 "$0: Unknown \`$1' option"
+    echo 1>&2 "Try \`$0 --help' for more information"
+    exit 1
+    ;;
+
+esac
+
+# normalize program name to check for.
+program=`echo "$1" | sed '
+  s/^gnu-//; t
+  s/^gnu//; t
+  s/^g//; t'`
+
+# Now exit if we have it, but it failed.  Also exit now if we
+# don't have it and --version was passed (most likely to detect
+# the program).  This is about non-GNU programs, so use $1 not
+# $program.
+case $1 in
+  lex*|yacc*)
+    # Not GNU programs, they don't have --version.
+    ;;
+
+  *)
+    if test -z "$run" && ($1 --version) > /dev/null 2>&1; then
+       # We have it, but it failed.
+       exit 1
+    elif test "x$2" = "x--version" || test "x$2" = "x--help"; then
+       # Could not run --version or --help.  This is probably someone
+       # running `$TOOL --version' or `$TOOL --help' to check whether
+       # $TOOL exists and not knowing $TOOL uses missing.
+       exit 1
+    fi
+    ;;
+esac
+
+# If it does not exist, or fails to run (possibly an outdated version),
+# try to emulate it.
+case $program in
+  aclocal*)
+    echo 1>&2 "\
+WARNING: \`$1' is $msg.  You should only need it if
+         you modified \`acinclude.m4' or \`${configure_ac}'.  You might want
+         to install the \`Automake' and \`Perl' packages.  Grab them from
+         any GNU archive site."
+    touch aclocal.m4
+    ;;
+
+  autoconf*)
+    echo 1>&2 "\
+WARNING: \`$1' is $msg.  You should only need it if
+         you modified \`${configure_ac}'.  You might want to install the
+         \`Autoconf' and \`GNU m4' packages.  Grab them from any GNU
+         archive site."
+    touch configure
+    ;;
+
+  autoheader*)
+    echo 1>&2 "\
+WARNING: \`$1' is $msg.  You should only need it if
+         you modified \`acconfig.h' or \`${configure_ac}'.  You might want
+         to install the \`Autoconf' and \`GNU m4' packages.  Grab them
+         from any GNU archive site."
+    files=`sed -n 's/^[ ]*A[CM]_CONFIG_HEADER(\([^)]*\)).*/\1/p' ${configure_ac}`
+    test -z "$files" && files="config.h"
+    touch_files=
+    for f in $files; do
+      case $f in
+      *:*) touch_files="$touch_files "`echo "$f" |
+				       sed -e 's/^[^:]*://' -e 's/:.*//'`;;
+      *) touch_files="$touch_files $f.in";;
+      esac
+    done
+    touch $touch_files
+    ;;
+
+  automake*)
+    echo 1>&2 "\
+WARNING: \`$1' is $msg.  You should only need it if
+         you modified \`Makefile.am', \`acinclude.m4' or \`${configure_ac}'.
+         You might want to install the \`Automake' and \`Perl' packages.
+         Grab them from any GNU archive site."
+    find . -type f -name Makefile.am -print |
+	   sed 's/\.am$/.in/' |
+	   while read f; do touch "$f"; done
+    ;;
+
+  autom4te*)
+    echo 1>&2 "\
+WARNING: \`$1' is needed, but is $msg.
+         You might have modified some files without having the
+         proper tools for further handling them.
+         You can get \`$1' as part of \`Autoconf' from any GNU
+         archive site."
+
+    file=`echo "$*" | sed -n "$sed_output"`
+    test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
+    if test -f "$file"; then
+	touch $file
+    else
+	test -z "$file" || exec >$file
+	echo "#! /bin/sh"
+	echo "# Created by GNU Automake missing as a replacement of"
+	echo "#  $ $@"
+	echo "exit 0"
+	chmod +x $file
+	exit 1
+    fi
+    ;;
+
+  bison*|yacc*)
+    echo 1>&2 "\
+WARNING: \`$1' $msg.  You should only need it if
+         you modified a \`.y' file.  You may need the \`Bison' package
+         in order for those modifications to take effect.  You can get
+         \`Bison' from any GNU archive site."
+    rm -f y.tab.c y.tab.h
+    if test $# -ne 1; then
+        eval LASTARG=\${$#}
+	case $LASTARG in
+	*.y)
+	    SRCFILE=`echo "$LASTARG" | sed 's/y$/c/'`
+	    if test -f "$SRCFILE"; then
+	         cp "$SRCFILE" y.tab.c
+	    fi
+	    SRCFILE=`echo "$LASTARG" | sed 's/y$/h/'`
+	    if test -f "$SRCFILE"; then
+	         cp "$SRCFILE" y.tab.h
+	    fi
+	  ;;
+	esac
+    fi
+    if test ! -f y.tab.h; then
+	echo >y.tab.h
+    fi
+    if test ! -f y.tab.c; then
+	echo 'main() { return 0; }' >y.tab.c
+    fi
+    ;;
+
+  lex*|flex*)
+    echo 1>&2 "\
+WARNING: \`$1' is $msg.  You should only need it if
+         you modified a \`.l' file.  You may need the \`Flex' package
+         in order for those modifications to take effect.  You can get
+         \`Flex' from any GNU archive site."
+    rm -f lex.yy.c
+    if test $# -ne 1; then
+        eval LASTARG=\${$#}
+	case $LASTARG in
+	*.l)
+	    SRCFILE=`echo "$LASTARG" | sed 's/l$/c/'`
+	    if test -f "$SRCFILE"; then
+	         cp "$SRCFILE" lex.yy.c
+	    fi
+	  ;;
+	esac
+    fi
+    if test ! -f lex.yy.c; then
+	echo 'main() { return 0; }' >lex.yy.c
+    fi
+    ;;
+
+  help2man*)
+    echo 1>&2 "\
+WARNING: \`$1' is $msg.  You should only need it if
+	 you modified a dependency of a manual page.  You may need the
+	 \`Help2man' package in order for those modifications to take
+	 effect.  You can get \`Help2man' from any GNU archive site."
+
+    file=`echo "$*" | sed -n "$sed_output"`
+    test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
+    if test -f "$file"; then
+	touch $file
+    else
+	test -z "$file" || exec >$file
+	echo ".ab help2man is required to generate this page"
+	exit $?
+    fi
+    ;;
+
+  makeinfo*)
+    echo 1>&2 "\
+WARNING: \`$1' is $msg.  You should only need it if
+         you modified a \`.texi' or \`.texinfo' file, or any other file
+         indirectly affecting the aspect of the manual.  The spurious
+         call might also be the consequence of using a buggy \`make' (AIX,
+         DU, IRIX).  You might want to install the \`Texinfo' package or
+         the \`GNU make' package.  Grab either from any GNU archive site."
+    # The file to touch is that specified with -o ...
+    file=`echo "$*" | sed -n "$sed_output"`
+    test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
+    if test -z "$file"; then
+      # ... or it is the one specified with @setfilename ...
+      infile=`echo "$*" | sed 's/.* \([^ ]*\) *$/\1/'`
+      file=`sed -n '
+	/^@setfilename/{
+	  s/.* \([^ ]*\) *$/\1/
+	  p
+	  q
+	}' $infile`
+      # ... or it is derived from the source name (dir/f.texi becomes f.info)
+      test -z "$file" && file=`echo "$infile" | sed 's,.*/,,;s,.[^.]*$,,'`.info
+    fi
+    # If the file does not exist, the user really needs makeinfo;
+    # let's fail without touching anything.
+    test -f $file || exit 1
+    touch $file
+    ;;
+
+  *)
+    echo 1>&2 "\
+WARNING: \`$1' is needed, and is $msg.
+         You might have modified some files without having the
+         proper tools for further handling them.  Check the \`README' file,
+         it often tells you about the needed prerequisites for installing
+         this package.  You may also peek at any GNU archive site, in case
+         some other package would contain this missing \`$1' program."
+    exit 1
+    ;;
+esac
+
+exit 0
+
+# Local variables:
+# 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:

src/address_range.cpp

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "address_range.h"
+#include "ip_address.h"
+#include "ipv6_address.h"
+
+namespace Tins {
+IPv4Range operator/(const IPv4Address &addr, int mask) {
+    if(mask > 32)
+        throw std::logic_error("Prefix length cannot exceed 32");
+    return IPv4Range::from_mask(
+        addr, 
+        IPv4Address(Endian::host_to_be(0xffffffff << (32 - mask)))
+    );
+}
+
+IPv6Range operator/(const IPv6Address &addr, int mask) {
+    if(mask > 128)
+        throw std::logic_error("Prefix length cannot exceed 128");
+    IPv6Address last_addr;
+    IPv6Address::iterator it = last_addr.begin();
+    while(mask > 8) {
+        *it = 0xff;
+        ++it;
+        mask -= 8;
+    }
+    *it = 0xff << (8 - mask);
+    return IPv6Range::from_mask(addr, last_addr);
+}
+}

src/arp.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -36,6 +36,7 @@
 #include "rawpdu.h"
 #include "constants.h"
 #include "network_interface.h"
+#include "exceptions.h"
 
 
 using std::runtime_error;
@@ -59,9 +60,10 @@ ARP::ARP(ipaddress_type target_ip, ipaddress_type sender_ip,
 ARP::ARP(const uint8_t *buffer, uint32_t total_sz) 
 {
     if(total_sz < sizeof(arphdr))
-        throw runtime_error("Not enough size for an ARP header in the buffer.");
+        throw malformed_packet();
     memcpy(&_arp, buffer, sizeof(arphdr));
     total_sz -= sizeof(arphdr);
+    //TODO: Check whether this should be removed or not.
     if(total_sz)
         inner_pdu(new RawPDU(buffer + sizeof(arphdr), total_sz));
 }
@@ -107,54 +109,41 @@ uint32_t ARP::header_size() const {
 }
 
 void ARP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *) {
+    #ifdef TINS_DEBUG
     assert(total_sz >= sizeof(arphdr));
+    #endif
     memcpy(buffer, &_arp, sizeof(arphdr));
 }
 
-bool ARP::matches_response(uint8_t *ptr, uint32_t total_sz) {
+bool ARP::matches_response(const uint8_t *ptr, uint32_t total_sz) const {
     if(total_sz < sizeof(arphdr))
         return false;
-    arphdr *arp_ptr = (arphdr*)ptr;
+    const arphdr *arp_ptr = (const arphdr*)ptr;
     return arp_ptr->ar_sip == _arp.ar_tip && arp_ptr->ar_tip == _arp.ar_sip;
 }
 
-PDU *ARP::clone_packet(const uint8_t *ptr, uint32_t total_sz) {
-    if(total_sz < sizeof(arphdr))
-        return 0;
-    PDU *child = 0, *cloned;
-    if(total_sz > sizeof(arphdr)) {
-        child = PDU::clone_inner_pdu(ptr + sizeof(arphdr), total_sz - sizeof(arphdr));
-        if(!child)
-            return 0;
-    }
-    cloned = new ARP(ptr, std::min(total_sz, (uint32_t)sizeof(_arp)));
-    cloned->inner_pdu(child);
-    return cloned;
-}
-
-EthernetII ARP::make_arp_request(const NetworkInterface& iface, 
-  ipaddress_type target, ipaddress_type sender, const hwaddress_type &hw_snd) 
+EthernetII ARP::make_arp_request(ipaddress_type target, ipaddress_type sender, 
+const hwaddress_type &hw_snd) 
 {
     /* Create ARP packet and set its attributes */
-    ARP* arp = new ARP();
-    arp->target_ip_addr(target);
-    arp->sender_ip_addr(sender);
-    arp->sender_hw_addr(hw_snd);
-    arp->opcode(REQUEST);
+    ARP arp;
+    arp.target_ip_addr(target);
+    arp.sender_ip_addr(sender);
+    arp.sender_hw_addr(hw_snd);
+    arp.opcode(REQUEST);
 
     /* Create the EthernetII PDU with the ARP PDU as its inner PDU */
-    return EthernetII(iface, EthernetII::BROADCAST, hw_snd, arp);
+    return EthernetII(EthernetII::BROADCAST, hw_snd) / arp;
 }
 
-EthernetII ARP::make_arp_reply(const NetworkInterface& iface, 
-  ipaddress_type target, ipaddress_type sender, const hwaddress_type &hw_tgt, 
-  const hwaddress_type &hw_snd) 
+EthernetII ARP::make_arp_reply(ipaddress_type target, ipaddress_type sender, 
+const hwaddress_type &hw_tgt, const hwaddress_type &hw_snd) 
 {
     /* Create ARP packet and set its attributes */
-    ARP* arp = new ARP(target, sender, hw_tgt, hw_snd);
-    arp->opcode(REPLY);
+    ARP arp(target, sender, hw_tgt, hw_snd);
+    arp.opcode(REPLY);
 
     /* Create the EthernetII PDU with the ARP PDU as its inner PDU */
-    return EthernetII(iface, hw_tgt, hw_snd, arp);
+    return EthernetII(hw_tgt, hw_snd) / arp;
 }
 }

src/bootp.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,6 +31,7 @@
 #include <cstring>
 #include <cassert>
 #include "bootp.h"
+#include "exceptions.h"
 
 namespace Tins{
 BootP::BootP() 
@@ -42,7 +43,7 @@ BootP::BootP(const uint8_t *buffer, uint32_t total_sz, uint32_t vend_field_size)
 : _vend(vend_field_size) 
 {
     if(total_sz < sizeof(bootphdr) + vend_field_size)
-        throw std::runtime_error("Not enough size for a BootP header in the buffer.");
+        throw malformed_packet();
     std::memcpy(&_bootp, buffer, sizeof(bootphdr));
     buffer += sizeof(bootphdr);
     total_sz -= sizeof(bootphdr);
@@ -113,8 +114,17 @@ void BootP::vend(const vend_type &new_vend) {
 }
 
 void BootP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
+    #ifdef TINS_DEBUG
     assert(total_sz >= sizeof(bootphdr) + _vend.size());
+    #endif
     std::memcpy(buffer, &_bootp, sizeof(bootphdr));
     std::copy(_vend.begin(), _vend.end(), buffer + sizeof(bootphdr));
 }
+
+bool BootP::matches_response(const uint8_t *ptr, uint32_t total_sz) const {
+    if(total_sz < sizeof(bootphdr))
+        return false;
+    const bootphdr *bootp_ptr = (const bootphdr *)ptr;
+    return bootp_ptr->xid == _bootp.xid;
+}
 }

src/crypto.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -26,8 +26,15 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  */
- 
+
 #include "crypto.h"
+#ifdef HAVE_WPA2_DECRYPTION
+    #include <openssl/evp.h>
+    #include <openssl/hmac.h>
+    #include <openssl/aes.h>
+#endif // HAVE_WPA2_DECRYPTION
+#include "dot11/dot11_data.h"
+#include "dot11/dot11_beacon.h"
 
 namespace Tins {
 namespace Crypto {
@@ -63,14 +70,16 @@ bool WEPDecrypter::decrypt(PDU &pdu) {
             passwords_type::iterator it = passwords.find(addr);
             if(it != passwords.end()) {
                 dot11->inner_pdu(decrypt(*raw, it->second));
-                dot11->wep(0);
-                // Invalid WEP packet(CRC check failed). Skip it.
-                if(!dot11->inner_pdu())
-                    return false;
+                // If its valid, then return true
+                if(dot11->inner_pdu()) {
+                    // it's no longer encrypted.
+                    dot11->wep(0);
+                    return true;
+                }
             }
         }
     }
-    return true;
+    return false;
 }
 
 PDU *WEPDecrypter::decrypt(RawPDU &raw, const std::string &password) {
@@ -98,5 +107,438 @@ PDU *WEPDecrypter::decrypt(RawPDU &raw, const std::string &password) {
         return 0;
     }
 }
+
+#ifdef HAVE_WPA2_DECRYPTION
+// WPA2Decrypter
+
+const HWAddress<6> &min(const HWAddress<6>& lhs, const HWAddress<6>& rhs) {
+    return lhs < rhs ? lhs : rhs;
 }
+
+const HWAddress<6> &max(const HWAddress<6>& lhs, const HWAddress<6>& rhs) {
+    return lhs < rhs ? rhs : lhs;
 }
+
+template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
+void xor_range(InputIterator1 src1, InputIterator2 src2, OutputIterator dst, size_t sz) {
+    for(size_t i = 0; i < sz; ++i) {
+        *dst++ = *src1++ ^ *src2++;
+    }
+}
+
+const uint16_t sbox_table[2][256]= {
+    {
+        0xC6A5, 0xF884, 0xEE99, 0xF68D, 0xFF0D, 0xD6BD, 0xDEB1, 0x9154,
+        0x6050, 0x0203, 0xCEA9, 0x567D, 0xE719, 0xB562, 0x4DE6, 0xEC9A,
+        0x8F45, 0x1F9D, 0x8940, 0xFA87, 0xEF15, 0xB2EB, 0x8EC9, 0xFB0B,
+        0x41EC, 0xB367, 0x5FFD, 0x45EA, 0x23BF, 0x53F7, 0xE496, 0x9B5B,
+        0x75C2, 0xE11C, 0x3DAE, 0x4C6A, 0x6C5A, 0x7E41, 0xF502, 0x834F,
+        0x685C, 0x51F4, 0xD134, 0xF908, 0xE293, 0xAB73, 0x6253, 0x2A3F,
+        0x080C, 0x9552, 0x4665, 0x9D5E, 0x3028, 0x37A1, 0x0A0F, 0x2FB5,
+        0x0E09, 0x2436, 0x1B9B, 0xDF3D, 0xCD26, 0x4E69, 0x7FCD, 0xEA9F,
+        0x121B, 0x1D9E, 0x5874, 0x342E, 0x362D, 0xDCB2, 0xB4EE, 0x5BFB,
+        0xA4F6, 0x764D, 0xB761, 0x7DCE, 0x527B, 0xDD3E, 0x5E71, 0x1397,
+        0xA6F5, 0xB968, 0x0000, 0xC12C, 0x4060, 0xE31F, 0x79C8, 0xB6ED,
+        0xD4BE, 0x8D46, 0x67D9, 0x724B, 0x94DE, 0x98D4, 0xB0E8, 0x854A,
+        0xBB6B, 0xC52A, 0x4FE5, 0xED16, 0x86C5, 0x9AD7, 0x6655, 0x1194,
+        0x8ACF, 0xE910, 0x0406, 0xFE81, 0xA0F0, 0x7844, 0x25BA, 0x4BE3,
+        0xA2F3, 0x5DFE, 0x80C0, 0x058A, 0x3FAD, 0x21BC, 0x7048, 0xF104,
+        0x63DF, 0x77C1, 0xAF75, 0x4263, 0x2030, 0xE51A, 0xFD0E, 0xBF6D,
+        0x814C, 0x1814, 0x2635, 0xC32F, 0xBEE1, 0x35A2, 0x88CC, 0x2E39,
+        0x9357, 0x55F2, 0xFC82, 0x7A47, 0xC8AC, 0xBAE7, 0x322B, 0xE695,
+        0xC0A0, 0x1998, 0x9ED1, 0xA37F, 0x4466, 0x547E, 0x3BAB, 0x0B83,
+        0x8CCA, 0xC729, 0x6BD3, 0x283C, 0xA779, 0xBCE2, 0x161D, 0xAD76,
+        0xDB3B, 0x6456, 0x744E, 0x141E, 0x92DB, 0x0C0A, 0x486C, 0xB8E4,
+        0x9F5D, 0xBD6E, 0x43EF, 0xC4A6, 0x39A8, 0x31A4, 0xD337, 0xF28B,
+        0xD532, 0x8B43, 0x6E59, 0xDAB7, 0x018C, 0xB164, 0x9CD2, 0x49E0,
+        0xD8B4, 0xACFA, 0xF307, 0xCF25, 0xCAAF, 0xF48E, 0x47E9, 0x1018,
+        0x6FD5, 0xF088, 0x4A6F, 0x5C72, 0x3824, 0x57F1, 0x73C7, 0x9751,
+        0xCB23, 0xA17C, 0xE89C, 0x3E21, 0x96DD, 0x61DC, 0x0D86, 0x0F85,
+        0xE090, 0x7C42, 0x71C4, 0xCCAA, 0x90D8, 0x0605, 0xF701, 0x1C12,
+        0xC2A3, 0x6A5F, 0xAEF9, 0x69D0, 0x1791, 0x9958, 0x3A27, 0x27B9,
+        0xD938, 0xEB13, 0x2BB3, 0x2233, 0xD2BB, 0xA970, 0x0789, 0x33A7,
+        0x2DB6, 0x3C22, 0x1592, 0xC920, 0x8749, 0xAAFF, 0x5078, 0xA57A,
+        0x038F, 0x59F8, 0x0980, 0x1A17, 0x65DA, 0xD731, 0x84C6, 0xD0B8,
+        0x82C3, 0x29B0, 0x5A77, 0x1E11, 0x7BCB, 0xA8FC, 0x6DD6, 0x2C3A
+    },
+    {
+        0xA5C6, 0x84F8, 0x99EE, 0x8DF6, 0x0DFF, 0xBDD6, 0xB1DE, 0x5491,
+        0x5060, 0x0302, 0xA9CE, 0x7D56, 0x19E7, 0x62B5, 0xE64D, 0x9AEC,
+        0x458F, 0x9D1F, 0x4089, 0x87FA, 0x15EF, 0xEBB2, 0xC98E, 0x0BFB,
+        0xEC41, 0x67B3, 0xFD5F, 0xEA45, 0xBF23, 0xF753, 0x96E4, 0x5B9B,
+        0xC275, 0x1CE1, 0xAE3D, 0x6A4C, 0x5A6C, 0x417E, 0x02F5, 0x4F83,
+        0x5C68, 0xF451, 0x34D1, 0x08F9, 0x93E2, 0x73AB, 0x5362, 0x3F2A,
+        0x0C08, 0x5295, 0x6546, 0x5E9D, 0x2830, 0xA137, 0x0F0A, 0xB52F,
+        0x090E, 0x3624, 0x9B1B, 0x3DDF, 0x26CD, 0x694E, 0xCD7F, 0x9FEA,
+        0x1B12, 0x9E1D, 0x7458, 0x2E34, 0x2D36, 0xB2DC, 0xEEB4, 0xFB5B,
+        0xF6A4, 0x4D76, 0x61B7, 0xCE7D, 0x7B52, 0x3EDD, 0x715E, 0x9713,
+        0xF5A6, 0x68B9, 0x0000, 0x2CC1, 0x6040, 0x1FE3, 0xC879, 0xEDB6,
+        0xBED4, 0x468D, 0xD967, 0x4B72, 0xDE94, 0xD498, 0xE8B0, 0x4A85,
+        0x6BBB, 0x2AC5, 0xE54F, 0x16ED, 0xC586, 0xD79A, 0x5566, 0x9411,
+        0xCF8A, 0x10E9, 0x0604, 0x81FE, 0xF0A0, 0x4478, 0xBA25, 0xE34B,
+        0xF3A2, 0xFE5D, 0xC080, 0x8A05, 0xAD3F, 0xBC21, 0x4870, 0x04F1,
+        0xDF63, 0xC177, 0x75AF, 0x6342, 0x3020, 0x1AE5, 0x0EFD, 0x6DBF,
+        0x4C81, 0x1418, 0x3526, 0x2FC3, 0xE1BE, 0xA235, 0xCC88, 0x392E,
+        0x5793, 0xF255, 0x82FC, 0x477A, 0xACC8, 0xE7BA, 0x2B32, 0x95E6,
+        0xA0C0, 0x9819, 0xD19E, 0x7FA3, 0x6644, 0x7E54, 0xAB3B, 0x830B,
+        0xCA8C, 0x29C7, 0xD36B, 0x3C28, 0x79A7, 0xE2BC, 0x1D16, 0x76AD,
+        0x3BDB, 0x5664, 0x4E74, 0x1E14, 0xDB92, 0x0A0C, 0x6C48, 0xE4B8,
+        0x5D9F, 0x6EBD, 0xEF43, 0xA6C4, 0xA839, 0xA431, 0x37D3, 0x8BF2,
+        0x32D5, 0x438B, 0x596E, 0xB7DA, 0x8C01, 0x64B1, 0xD29C, 0xE049,
+        0xB4D8, 0xFAAC, 0x07F3, 0x25CF, 0xAFCA, 0x8EF4, 0xE947, 0x1810,
+        0xD56F, 0x88F0, 0x6F4A, 0x725C, 0x2438, 0xF157, 0xC773, 0x5197,
+        0x23CB, 0x7CA1, 0x9CE8, 0x213E, 0xDD96, 0xDC61, 0x860D, 0x850F,
+        0x90E0, 0x427C, 0xC471, 0xAACC, 0xD890, 0x0506, 0x01F7, 0x121C,
+        0xA3C2, 0x5F6A, 0xF9AE, 0xD069, 0x9117, 0x5899, 0x273A, 0xB927,
+        0x38D9, 0x13EB, 0xB32B, 0x3322, 0xBBD2, 0x70A9, 0x8907, 0xA733,
+        0xB62D, 0x223C, 0x9215, 0x20C9, 0x4987, 0xFFAA, 0x7850, 0x7AA5,
+        0x8F03, 0xF859, 0x8009, 0x171A, 0xDA65, 0x31D7, 0xC684, 0xB8D0,
+        0xC382, 0xB029, 0x775A, 0x111E, 0xCB7B, 0xFCA8, 0xD66D, 0x3A2C
+    }
+};
+
+uint16_t sbox(uint16_t i) {
+    return sbox_table[0][i & 0xff] ^ sbox_table[1][(i >> 8)];
+}
+
+uint16_t join_bytes(uint8_t b1, uint8_t b2) {
+    return (static_cast<uint16_t>(b1) << 8) | b2;
+}
+
+uint16_t rotate(uint16_t value) {
+    return ((value >> 1) & 0x7fff) | (value << 15);
+}
+
+uint16_t upper_byte(uint16_t value) {
+    return (value >> 8) & 0xff;
+}
+
+uint16_t lower_byte(uint16_t value) {
+    return value & 0xff;
+}
+
+HWAddress<6> get_bssid(const Dot11Data &dot11) {
+    if(dot11.from_ds() && !dot11.to_ds())
+        return dot11.addr3();
+    else if(!dot11.from_ds() && dot11.to_ds())
+        return dot11.addr2();
+    else 
+        return dot11.addr2();
+}
+
+namespace WPA2 {
+
+SessionKeys::SessionKeys() {
+
+}
+
+SessionKeys::SessionKeys(const RSNHandshake &hs, const pmk_type &pmk) {
+    uint8_t PKE[100] = "Pairwise key expansion";
+    uint8_t MIC[16];
+    min(hs.client_address(), hs.supplicant_address()).copy(PKE + 23);
+    max(hs.client_address(), hs.supplicant_address()).copy(PKE + 29);
+    const uint8_t *nonce1 = hs.handshake()[1].nonce(), 
+                  *nonce2 = hs.handshake()[2].nonce();
+    if(std::lexicographical_compare(nonce1, nonce1 + 32, nonce2, nonce2 + 32)) {
+        std::copy(nonce1, nonce1 + 32, PKE + 35);
+        std::copy(nonce2, nonce2 + 32, PKE + 67);
+    }
+    else {
+        std::copy(nonce2, nonce2 + 32, PKE + 35);
+        std::copy(nonce1, nonce1 + 32, PKE + 67);
+    }
+    for(int i(0); i < 4; ++i) {
+        PKE[99] = i;
+        HMAC(EVP_sha1(), pmk.begin(), pmk.size(), PKE, 100, ptk.begin() + i * 20, 0);
+    }
+    PDU::serialization_type buffer = const_cast<RSNEAPOL&>(hs.handshake()[3]).serialize();
+    std::fill(buffer.begin() + 81, buffer.begin() + 81 + 16, 0);
+    if(hs.handshake()[3].key_descriptor() == 2)
+        HMAC(EVP_sha1(), ptk.begin(), 16, &buffer[0], buffer.size(), MIC, 0);
+    else
+        HMAC(EVP_md5(), ptk.begin(), 16, &buffer[0], buffer.size(), MIC, 0);
+    
+    if(!std::equal(MIC, MIC + sizeof(MIC), hs.handshake()[3].mic()))
+        throw invalid_handshake();
+    is_ccmp = (hs.handshake()[3].key_descriptor() == 2);
+}
+
+SNAP *SessionKeys::ccmp_decrypt_unicast(const Dot11Data &dot11, RawPDU &raw) const {
+    RawPDU::payload_type &pload = raw.payload();
+    uint8_t MIC[16] = {0};
+    uint8_t PN[6] = {
+        pload[7],
+        pload[6],
+        pload[5],
+        pload[4],
+        pload[1],
+        pload[0]
+    };
+    
+    uint8_t AAD[32] = {0};
+    AAD[0] = 0;
+    AAD[1] = 22 + 6 * int(dot11.from_ds() && dot11.to_ds());
+    if(dot11.subtype() == Dot11::QOS_DATA_DATA) 
+        AAD[1] += 2;
+    AAD[2] = dot11.protocol() | (dot11.type() << 2) | ((dot11.subtype() << 4) & 0x80);
+    AAD[3] = 0x40 | dot11.to_ds() | (dot11.from_ds() << 1) |
+            (dot11.more_frag() << 2) | (dot11.order() << 7);
+    dot11.addr1().copy(AAD + 4);
+    dot11.addr2().copy(AAD + 10);
+    dot11.addr3().copy(AAD + 16);
+    
+    AAD[22] = dot11.frag_num();
+    AAD[23] = 0;
+    
+    if(dot11.from_ds() && dot11.to_ds())
+        dot11.addr4().copy(AAD + 24);
+    
+    AES_KEY ctx;
+    AES_set_encrypt_key(ptk.begin() + 32, 128, &ctx);
+    uint8_t crypted_block[16];
+    size_t total_sz = raw.payload_size() - 16, offset = 8, blocks = (total_sz + 15) / 16;
+    
+    uint8_t counter[16];
+    counter[0] = 0x59;
+    counter[1] = 0;
+    dot11.addr2().copy(counter + 2);
+    std::copy(PN, PN + 6, counter + 8);
+    counter[14] = (total_sz >> 8) & 0xff;
+    counter[15] = total_sz & 0xff;
+    
+    AES_encrypt(counter, MIC, &ctx);
+    xor_range(MIC, AAD, MIC, 16);
+    AES_encrypt(MIC, MIC, &ctx);
+    xor_range(MIC, AAD + 16, MIC, 16);
+    AES_encrypt(MIC, MIC, &ctx);
+    
+    counter[0] = 1;
+    counter[14] = counter[15] = 0;
+    AES_encrypt(counter, crypted_block, &ctx);
+    uint8_t nice_MIC[8];
+    std::copy(pload.begin() + pload.size() - 8, pload.end(), nice_MIC);
+    xor_range(crypted_block, nice_MIC, nice_MIC, 8);
+    for(size_t i = 1; i <= blocks; ++i) {
+        size_t block_sz = (i == blocks) ? (total_sz % 16) : 16;
+        if(block_sz == 0)
+            block_sz = 16;
+        counter[14] = (i >> 8) & 0xff;
+        counter[15] = i & 0xff;
+        AES_encrypt(counter, crypted_block, &ctx );
+
+        xor_range(crypted_block, &pload[offset], &pload[(i - 1) * 16], block_sz);
+        
+        xor_range(MIC, &pload[(i - 1) * 16], MIC, block_sz);
+        AES_encrypt(MIC, MIC, &ctx);   
+        offset += block_sz;
+    }
+    return (std::equal(nice_MIC, nice_MIC + sizeof(nice_MIC), MIC)) ? 
+        new SNAP(&pload[0], total_sz) : 
+        0;
+}
+
+RC4Key SessionKeys::generate_rc4_key(const Dot11Data &dot11, const RawPDU &raw) const {
+    const RawPDU::payload_type &pload = raw.payload();
+    const uint8_t *tk = ptk.begin() + 32;
+    Internals::byte_array<16> rc4_key;
+    uint16_t ppk[6];
+    const Dot11::address_type addr = get_bssid(dot11);
+    // Phase 1
+    ppk[0] = join_bytes(pload[4], pload[5]);
+    ppk[1] = join_bytes(pload[6], pload[7]);
+    ppk[2] = join_bytes(addr[1], addr[0]);
+    ppk[3] = join_bytes(addr[3], addr[2]);
+    ppk[4] = join_bytes(addr[5], addr[4]);
+    
+    for(size_t i = 0; i < 4; ++i) {
+        ppk[0] += sbox(ppk[4] ^ join_bytes(tk[1], tk[0]));
+        ppk[1] += sbox(ppk[0] ^ join_bytes(tk[5], tk[4]));
+        ppk[2] += sbox(ppk[1] ^ join_bytes(tk[9], tk[8]));
+        ppk[3] += sbox(ppk[2] ^ join_bytes(tk[13], tk[12]));
+        ppk[4] += sbox(ppk[3] ^ join_bytes(tk[1], tk[0])) + 2*i;
+        ppk[0] += sbox(ppk[4] ^ join_bytes(tk[3], tk[2]));
+        ppk[1] += sbox(ppk[0] ^ join_bytes(tk[7], tk[6]));
+        ppk[2] += sbox(ppk[1] ^ join_bytes(tk[11], tk[10]));
+        ppk[3] += sbox(ppk[2] ^ join_bytes(tk[15], tk[14]));
+        ppk[4] += sbox(ppk[3] ^ join_bytes(tk[3], tk[2])) + 2*i + 1;
+    }
+
+    // Phase 2, step 1
+    ppk[5] = ppk[4] + join_bytes(pload[0], pload[2]);
+    
+    // Phase 2, step 2
+    ppk[0] += sbox(ppk[5] ^ join_bytes(tk[1], tk[0]));
+    ppk[1] += sbox(ppk[0] ^ join_bytes(tk[3], tk[2]));
+    ppk[2] += sbox(ppk[1] ^ join_bytes(tk[5], tk[4]));
+    ppk[3] += sbox(ppk[2] ^ join_bytes(tk[7], tk[6]));
+    ppk[4] += sbox(ppk[3] ^ join_bytes(tk[9], tk[8]));
+    ppk[5] += sbox(ppk[4] ^ join_bytes(tk[11], tk[10]));
+    
+    ppk[0] += rotate(ppk[5] ^ join_bytes(tk[13], tk[12]));
+    ppk[1] += rotate(ppk[0] ^ join_bytes(tk[15], tk[14]));
+    ppk[2] += rotate(ppk[1]);
+    ppk[3] += rotate(ppk[2]);
+    ppk[4] += rotate(ppk[3]);
+    ppk[5] += rotate(ppk[4]);
+    
+    // Phase 2, step 3
+    rc4_key[0] = upper_byte(join_bytes(pload[0], pload[2]));
+    rc4_key[1] = (rc4_key[0] | 0x20) & 0x7f;
+    rc4_key[2] = lower_byte(join_bytes(pload[0], pload[2]));
+    rc4_key[3] = lower_byte((ppk[5] ^ join_bytes(tk[1], tk[0])) >> 1);
+    rc4_key[4] = lower_byte(ppk[0]);
+    rc4_key[5] = upper_byte(ppk[0]);
+    rc4_key[6] = lower_byte(ppk[1]);
+    rc4_key[7] = upper_byte(ppk[1]);
+    rc4_key[8] = lower_byte(ppk[2]);
+    rc4_key[9] = upper_byte(ppk[2]);
+    rc4_key[10] = lower_byte(ppk[3]);
+    rc4_key[11] = upper_byte(ppk[3]);
+    rc4_key[12] = lower_byte(ppk[4]);
+    rc4_key[13] = upper_byte(ppk[4]);
+    rc4_key[14] = lower_byte(ppk[5]);
+    rc4_key[15] = upper_byte(ppk[5]);
+    return RC4Key(rc4_key.begin(), rc4_key.end());
+}
+
+SNAP *SessionKeys::tkip_decrypt_unicast(const Dot11Data &dot11, RawPDU &raw) const {
+    // at least 20 bytes for IV + crc + stuff
+    if(raw.payload_size() <= 20)
+        return 0;
+    Crypto::RC4Key key = generate_rc4_key(dot11, raw);
+    RawPDU::payload_type &pload = raw.payload();
+    rc4(pload.begin() + 8, pload.end(), key, pload.begin());
+
+    uint32_t crc = Utils::crc32(&pload[0], pload.size() - 12);
+    if(pload[pload.size() - 12] != (crc & 0xff) ||
+        pload[pload.size() - 11] != ((crc >> 8) & 0xff) ||
+        pload[pload.size() - 10] != ((crc >> 16) & 0xff) ||
+        pload[pload.size() - 9] != ((crc >> 24) & 0xff))
+        return 0;
+
+    return new SNAP(&pload[0], pload.size() - 20);
+}
+
+SNAP *SessionKeys::SessionKeys::decrypt_unicast(const Dot11Data &dot11, RawPDU &raw) const {
+    return is_ccmp ? 
+        ccmp_decrypt_unicast(dot11, raw) :
+        tkip_decrypt_unicast(dot11, raw);
+}
+
+// supplicant_data
+
+SupplicantData::SupplicantData(const std::string &psk, const std::string &ssid) {
+    PKCS5_PBKDF2_HMAC_SHA1(
+        psk.c_str(), 
+        psk.size(), 
+        (unsigned char *)ssid.c_str(), 
+        ssid.size(), 
+        4096, 
+        pmk_.size(), 
+        pmk_.begin()
+    );
+}
+
+const SupplicantData::pmk_type &SupplicantData::pmk() const {
+    return pmk_;
+}
+} // namespace WPA2
+
+void WPA2Decrypter::add_ap_data(const std::string &psk, const std::string &ssid) {
+    pmks.insert(std::make_pair(ssid, WPA2::SupplicantData(psk, ssid)));
+}
+
+void WPA2Decrypter::add_ap_data(const std::string &psk, const std::string &ssid,
+  const address_type &addr) 
+{
+    add_ap_data(psk, ssid);
+    add_access_point(ssid, addr);
+}
+
+void WPA2Decrypter::add_access_point(const std::string &ssid, const address_type &addr) {
+    pmks_map::const_iterator it = pmks.find(ssid);
+    if(it == pmks.end()) 
+        throw std::runtime_error("supplicant data not registered");
+    aps.insert(std::make_pair(addr, it->second));
+}
+
+void WPA2Decrypter::try_add_keys(const Dot11Data &dot11, const RSNHandshake &hs) {
+    bssids_map::const_iterator it = find_ap(dot11);
+    if(it != aps.end()) {
+        addr_pair addr_p = extract_addr_pair(dot11);
+        try {
+            WPA2::SessionKeys session(hs, it->second.pmk());
+            keys[addr_p] = session;
+        }
+        catch(WPA2::invalid_handshake&) { }
+    }
+}
+
+WPA2Decrypter::addr_pair WPA2Decrypter::extract_addr_pair(const Dot11Data &dot11) {
+    if(dot11.from_ds() && !dot11.to_ds())
+        return make_addr_pair(dot11.addr2(), dot11.addr3());
+    else if(!dot11.from_ds() && dot11.to_ds())
+        return make_addr_pair(dot11.addr1(), dot11.addr2());
+    else 
+        return make_addr_pair(dot11.addr2(), dot11.addr3());
+}
+
+WPA2Decrypter::addr_pair WPA2Decrypter::extract_addr_pair_dst(const Dot11Data &dot11) {
+    if(dot11.from_ds() && !dot11.to_ds())
+        return make_addr_pair(dot11.addr1(), dot11.addr2());
+    else if(!dot11.from_ds() && dot11.to_ds())
+        return make_addr_pair(dot11.addr1(), dot11.addr3());
+    else 
+        return make_addr_pair(dot11.addr1(), dot11.addr3());
+}
+
+WPA2Decrypter::bssids_map::const_iterator WPA2Decrypter::find_ap(const Dot11Data &dot11) {
+    if(dot11.from_ds() && !dot11.to_ds())
+        return aps.find(dot11.addr2());
+    else if(!dot11.from_ds() && dot11.to_ds())
+        return aps.find(dot11.addr1());
+    else 
+        return aps.find(dot11.addr3());
+}
+
+bool WPA2Decrypter::decrypt(PDU &pdu) {
+    if(capturer.process_packet(pdu)) {
+        try_add_keys(pdu.rfind_pdu<Dot11Data>(), capturer.handshakes().front());
+        capturer.clear_handshakes();
+    }
+    else if(const Dot11Beacon *beacon = pdu.find_pdu<Dot11Beacon>()) {
+        if(aps.count(beacon->addr3()) == 0) {
+            try {
+                std::string ssid = beacon->ssid();
+                if(pmks.count(ssid)) {
+                    add_access_point(ssid, beacon->addr3());
+                }
+            }
+            catch(option_not_found&) { }
+        }
+    }
+    else {
+        Dot11Data *data = pdu.find_pdu<Dot11Data>();
+        RawPDU *raw = pdu.find_pdu<RawPDU>();
+        if(data && raw && data->wep()) {
+            // search for the tuple (bssid, src_addr)
+            keys_map::const_iterator it = keys.find(extract_addr_pair(*data));
+            
+            // search for the tuple (bssid, dst_addr) if the above didn't work
+            if(it == keys.end())
+                it = keys.find(extract_addr_pair_dst(*data));
+            if(it != keys.end()) {
+                SNAP *snap = it->second.decrypt_unicast(*data, *raw);
+                if(snap) {
+                    data->inner_pdu(snap);
+                    data->wep(0);
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+} // namespace WPA2
+#endif // HAVE_WPA2_DECRYPTION
+} // namespace Crypto
+} // namespace Tins

src/dhcp.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -32,6 +32,7 @@
 #include "endianness.h"
 #include "dhcp.h"
 #include "ethernetII.h"
+#include "exceptions.h"
 
 using std::string;
 using std::list;
@@ -52,7 +53,7 @@ DHCP::DHCP(const uint8_t *buffer, uint32_t total_sz)
     total_sz -= BootP::header_size() - vend().size();
     uint8_t args[2] = {0};
     if(total_sz < sizeof(uint32_t) || *(uint32_t*)buffer != Endian::host_to_be<uint32_t>(0x63825363))
-        throw std::runtime_error("Not enough size for a DHCP header in the buffer.");
+        throw malformed_packet();
     buffer += sizeof(uint32_t);
     total_sz -= sizeof(uint32_t);
     while(total_sz) {
@@ -64,22 +65,28 @@ DHCP::DHCP(const uint8_t *buffer, uint32_t total_sz)
                 i = 2;
             }
             else if(!total_sz)
-                throw std::runtime_error("Not enough size for a DHCP header in the buffer.");
+                throw malformed_packet();
         }
         if(total_sz < args[1])
-            throw std::runtime_error("Not enough size for a DHCP header in the buffer.");
-        add_option(dhcp_option((Options)args[0], args[1], buffer));
+            throw malformed_packet();
+        add_option(
+            option((OptionTypes)args[0], args[1], buffer)
+        );
         buffer += args[1];
         total_sz -= args[1];
     }
 }
 
-void DHCP::add_option(const dhcp_option &option) {
-    _options.push_back(option);
-    _size += option.data_size() + (sizeof(uint8_t) << 1);
+void DHCP::add_option(const option &opt) {
+    internal_add_option(opt);
+    _options.push_back(opt);
 }
 
-const DHCP::dhcp_option *DHCP::search_option(Options opt) const {
+void DHCP::internal_add_option(const option &opt) {
+    _size += opt.data_size() + (sizeof(uint8_t) << 1);
+}
+
+const DHCP::option *DHCP::search_option(OptionTypes opt) const {
     for(options_type::const_iterator it = _options.begin(); it != _options.end(); ++it) {
         if(it->option() == opt)
             return &(*it);
@@ -89,11 +96,11 @@ const DHCP::dhcp_option *DHCP::search_option(Options opt) const {
 
 void DHCP::type(Flags type) {
     uint8_t int_type = type;
-    add_option(dhcp_option(DHCP_MESSAGE_TYPE, sizeof(uint8_t), &int_type));
+    add_option(option(DHCP_MESSAGE_TYPE, sizeof(uint8_t), &int_type));
 }
 
 void DHCP::end() {
-    add_option(dhcp_option(DHCP_MESSAGE_TYPE));
+    add_option(option(END));
 }
 
 uint8_t DHCP::type() const {
@@ -102,7 +109,7 @@ uint8_t DHCP::type() const {
 
 void DHCP::server_identifier(ipaddress_type ip) {
     uint32_t ip_int = ip;
-    add_option(dhcp_option(DHCP_SERVER_IDENTIFIER, sizeof(uint32_t), (const uint8_t*)&ip_int));
+    add_option(option(DHCP_SERVER_IDENTIFIER, sizeof(uint32_t), (const uint8_t*)&ip_int));
 }
 
 DHCP::ipaddress_type DHCP::server_identifier() const {
@@ -111,7 +118,7 @@ DHCP::ipaddress_type DHCP::server_identifier() const {
 
 void DHCP::lease_time(uint32_t time) {
     time = Endian::host_to_be(time);
-    add_option(dhcp_option(DHCP_LEASE_TIME, sizeof(uint32_t), (const uint8_t*)&time));
+    add_option(option(DHCP_LEASE_TIME, sizeof(uint32_t), (const uint8_t*)&time));
 }
 
 uint32_t DHCP::lease_time() const {
@@ -120,7 +127,7 @@ uint32_t DHCP::lease_time() const {
 
 void DHCP::renewal_time(uint32_t time) {
     time = Endian::host_to_be(time);
-    add_option(dhcp_option(DHCP_RENEWAL_TIME, sizeof(uint32_t), (const uint8_t*)&time));
+    add_option(option(DHCP_RENEWAL_TIME, sizeof(uint32_t), (const uint8_t*)&time));
 }
         
 uint32_t DHCP::renewal_time() const {
@@ -129,7 +136,7 @@ uint32_t DHCP::renewal_time() const {
 
 void DHCP::subnet_mask(ipaddress_type mask) {
     uint32_t mask_int = mask;
-    add_option(dhcp_option(SUBNET_MASK, sizeof(uint32_t), (const uint8_t*)&mask_int));
+    add_option(option(SUBNET_MASK, sizeof(uint32_t), (const uint8_t*)&mask_int));
 }
 
 DHCP::ipaddress_type DHCP::subnet_mask() const {
@@ -138,7 +145,7 @@ DHCP::ipaddress_type DHCP::subnet_mask() const {
 
 void DHCP::routers(const list<ipaddress_type> &routers) {
     serialization_type buffer = serialize_list(routers);
-    add_option(dhcp_option(ROUTERS, buffer.begin(), buffer.end()));
+    add_option(option(ROUTERS, buffer.begin(), buffer.end()));
 }
 
 std::list<DHCP::ipaddress_type> DHCP::routers() const {
@@ -147,7 +154,7 @@ std::list<DHCP::ipaddress_type> DHCP::routers() const {
 
 void DHCP::domain_name_servers(const list<ipaddress_type> &dns) {
     serialization_type buffer = serialize_list(dns);
-    add_option(dhcp_option(DOMAIN_NAME_SERVERS, buffer.begin(), buffer.end()));
+    add_option(option(DOMAIN_NAME_SERVERS, buffer.begin(), buffer.end()));
 }
 
 std::list<DHCP::ipaddress_type> DHCP::domain_name_servers() const {
@@ -156,7 +163,7 @@ std::list<DHCP::ipaddress_type> DHCP::domain_name_servers() const {
 
 void DHCP::broadcast(ipaddress_type addr) {
     uint32_t int_addr = addr;
-    add_option(dhcp_option(BROADCAST_ADDRESS, sizeof(uint32_t), (uint8_t*)&int_addr));
+    add_option(option(BROADCAST_ADDRESS, sizeof(uint32_t), (uint8_t*)&int_addr));
 }
 
 DHCP::ipaddress_type DHCP::broadcast() const {
@@ -165,7 +172,7 @@ DHCP::ipaddress_type DHCP::broadcast() const {
 
 void DHCP::requested_ip(ipaddress_type addr) {
     uint32_t int_addr = addr;
-    add_option(dhcp_option(DHCP_REQUESTED_ADDRESS, sizeof(uint32_t), (uint8_t*)&int_addr));
+    add_option(option(DHCP_REQUESTED_ADDRESS, sizeof(uint32_t), (uint8_t*)&int_addr));
 }
 
 DHCP::ipaddress_type DHCP::requested_ip() const {
@@ -173,7 +180,7 @@ DHCP::ipaddress_type DHCP::requested_ip() const {
 }
 
 void DHCP::domain_name(const string &name) {
-    add_option(dhcp_option(DOMAIN_NAME, name.size(), (const uint8_t*)name.c_str()));
+    add_option(option(DOMAIN_NAME, name.size(), (const uint8_t*)name.c_str()));
 }
 
 std::string DHCP::domain_name() const {
@@ -182,7 +189,7 @@ std::string DHCP::domain_name() const {
 
 void DHCP::rebind_time(uint32_t time) {
     time = Endian::host_to_be(time);
-    add_option(dhcp_option(DHCP_REBINDING_TIME, sizeof(uint32_t), (uint8_t*)&time));
+    add_option(option(DHCP_REBINDING_TIME, sizeof(uint32_t), (uint8_t*)&time));
 }
         
 uint32_t DHCP::rebind_time() const {
@@ -202,7 +209,9 @@ uint32_t DHCP::header_size() const {
 }
 
 void DHCP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
+    #ifdef TINS_DEBUG
     assert(total_sz >= header_size());
+    #endif
     if(_size) {
         vend_type &result(BootP::vend());
         result.resize(_size);
@@ -211,7 +220,7 @@ void DHCP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *pa
         *((uint32_t*)&result[0]) = Endian::host_to_be<uint32_t>(0x63825363);
         for(options_type::const_iterator it = _options.begin(); it != _options.end(); ++it) {
             *(ptr++) = it->option();
-            *(ptr++) = it->data_size();
+            *(ptr++) = it->length_field();
             std::copy(it->data_ptr(), it->data_ptr() + it->data_size(), ptr);
             ptr += it->data_size();
         }
@@ -219,12 +228,12 @@ void DHCP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *pa
     BootP::write_serialization(buffer, total_sz, parent);
 }
 
-std::list<DHCP::ipaddress_type> DHCP::generic_search(Options opt, type2type<std::list<ipaddress_type> >) const {
-    const dhcp_option *option = search_option(opt);
-    if(!option)
+std::list<DHCP::ipaddress_type> DHCP::generic_search(OptionTypes opt_type, type2type<std::list<ipaddress_type> >) const {
+    const option *opt = search_option(opt_type);
+    if(!opt)
         throw option_not_found();
-    const uint32_t *ptr = (const uint32_t*)option->data_ptr();
-    uint32_t len = option->data_size();
+    const uint32_t *ptr = (const uint32_t*)opt->data_ptr();
+    uint32_t len = opt->data_size();
     if((len % sizeof(uint32_t)) != 0)
         throw option_not_found();
     std::list<ipaddress_type> container;
@@ -235,14 +244,14 @@ std::list<DHCP::ipaddress_type> DHCP::generic_search(Options opt, type2type<std:
     return container;
 }
 
-std::string DHCP::generic_search(Options opt, type2type<std::string>) const {
-    const dhcp_option *option = search_option(opt);
-    if(!option)
+std::string DHCP::generic_search(OptionTypes opt_type, type2type<std::string>) const {
+    const option *opt = search_option(opt_type);
+    if(!opt)
         throw option_not_found();
-    return string(option->data_ptr(), option->data_ptr() + option->data_size());
+    return string(opt->data_ptr(), opt->data_ptr() + opt->data_size());
 }
 
-DHCP::ipaddress_type DHCP::generic_search(Options opt, type2type<ipaddress_type>) const {
+DHCP::ipaddress_type DHCP::generic_search(OptionTypes opt, type2type<ipaddress_type>) const {
     return ipaddress_type(generic_search(opt, type2type<uint32_t>()));
 }
 }

src/dhcpv6.cpp

@@ -0,0 +1,653 @@
+/*
+ * Copyright (c) 2012, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <vector>
+#include <algorithm>
+#include "dhcpv6.h"
+#include "exceptions.h"
+
+namespace Tins {
+DHCPv6::DHCPv6() : options_size() {
+    std::fill(header_data, header_data + sizeof(header_data), 0);
+}
+
+DHCPv6::DHCPv6(const uint8_t *buffer, uint32_t total_sz) 
+: options_size() 
+{
+    if(total_sz == 0) 
+        throw malformed_packet();
+    // Relay Agent/Server Messages
+    bool is_relay_msg = (buffer[0] == 12 || buffer[0] == 13);
+    uint32_t required_size = is_relay_msg ? 2 : 4;
+    if(total_sz < required_size)
+        throw malformed_packet();
+    std::copy(buffer, buffer + required_size, header_data);
+    buffer += required_size;
+    total_sz -= required_size;
+    if(is_relay_message()) {
+        if(total_sz < ipaddress_type::address_size * 2)
+            throw malformed_packet();
+        link_addr = buffer;
+        peer_addr = buffer + ipaddress_type::address_size;
+        buffer += ipaddress_type::address_size * 2;
+        total_sz -= ipaddress_type::address_size * 2;
+    }
+    options_size = total_sz;
+    while(total_sz) {
+        if(total_sz < sizeof(uint16_t) * 2) 
+            throw malformed_packet();
+        
+        const uint16_t opt = Endian::be_to_host(*(const uint16_t*)buffer);
+        const uint16_t data_size = Endian::be_to_host(
+            *(const uint16_t*)(buffer + sizeof(uint16_t))
+        );
+        if(total_sz - sizeof(uint16_t) * 2 < data_size)
+            throw malformed_packet();
+        buffer += sizeof(uint16_t) * 2;
+        add_option(
+            option(opt, buffer, buffer + data_size)
+        );
+        buffer += data_size;
+        total_sz -= sizeof(uint16_t) * 2 + data_size;
+    }
+}
+    
+void DHCPv6::add_option(const option &opt) {
+    options_.push_back(opt);
+}
+
+const DHCPv6::option *DHCPv6::search_option(OptionTypes id) const {
+    for(options_type::const_iterator it = options_.begin(); it != options_.end(); ++it) {
+        if(it->option() == static_cast<uint16_t>(id))
+            return &*it;
+    }
+    return 0;
+}
+
+uint8_t* DHCPv6::write_option(const option &opt, uint8_t* buffer) const {
+    *(uint16_t*)buffer = Endian::host_to_be(opt.option());
+    *(uint16_t*)&buffer[sizeof(uint16_t)] = Endian::host_to_be<uint16_t>(opt.length_field());
+    return std::copy(
+        opt.data_ptr(), 
+        opt.data_ptr() + opt.data_size(), 
+        buffer + sizeof(uint16_t) * 2
+    );
+}
+    
+void DHCPv6::msg_type(MessageType type) {
+    header_data[0] = static_cast<uint8_t>(type);
+}
+
+void DHCPv6::hop_count(uint8_t count) {
+    header_data[1] = count;
+}
+
+void DHCPv6::transaction_id(small_uint<24> id) {
+    uint32_t id_32 = id;
+    header_data[1] = id_32 >> 16;
+    header_data[2] = id_32 >> 8;
+    header_data[3] = id_32 & 0xff;
+}
+
+void DHCPv6::peer_address(const ipaddress_type &addr) {
+    peer_addr = addr;
+}
+
+void DHCPv6::link_address(const ipaddress_type &addr) {
+    link_addr = addr;
+}
+
+bool DHCPv6::is_relay_message() const {
+    return msg_type() == 12 || msg_type() == 13;
+}
+
+uint32_t DHCPv6::header_size() const {
+    return (is_relay_message() ? (2 + ipaddress_type::address_size * 2) : 4) + options_size;
+}
+
+bool DHCPv6::matches_response(const uint8_t *ptr, uint32_t total_sz) const {
+    if(!is_relay_message()) {
+        if(total_sz < 4 || (ptr[0] == 12 || ptr[0] == 13))
+            return false;
+        return std::equal(header_data + 1, header_data + 4, ptr + 1);
+    }
+    return false;
+}
+
+void DHCPv6::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *) {
+    const uint32_t required_size = is_relay_message() ? 2 : 4;
+    buffer = std::copy(header_data, header_data + required_size, buffer);
+    if(is_relay_message()) {
+        buffer = link_addr.copy(buffer);
+        buffer = peer_addr.copy(buffer);
+    }
+    for(options_type::const_iterator it = options_.begin(); it != options_.end(); ++it)
+        buffer = write_option(*it, buffer);
+}
+
+
+// ********************************************************************
+//                          Option getters
+// ********************************************************************
+
+DHCPv6::ia_na_type DHCPv6::ia_na() const {
+    const option *opt = safe_search_option<std::less>(
+        IA_NA, sizeof(uint32_t) * 3
+    );
+    const uint8_t *ptr = opt->data_ptr() + sizeof(uint32_t) * 3;
+    const uint32_t *ptr_32 = (const uint32_t*)opt->data_ptr();
+    DHCPv6::ia_na_type output;
+    output.id = Endian::be_to_host(*ptr_32++);
+    output.t1 = Endian::be_to_host(*ptr_32++);
+    output.t2 = Endian::be_to_host(*ptr_32++);
+    output.options.assign(ptr, opt->data_ptr() + opt->data_size());
+    return output;
+}
+
+DHCPv6::ia_ta_type DHCPv6::ia_ta() const {
+    const option *opt = safe_search_option<std::less>(
+        IA_TA, sizeof(uint32_t)
+    );
+    const uint8_t *ptr = opt->data_ptr() + sizeof(uint32_t);
+    const uint32_t *ptr_32 = (const uint32_t*)opt->data_ptr();
+    DHCPv6::ia_ta_type output;
+    output.id = Endian::be_to_host(*ptr_32++);
+    output.options.assign(ptr, opt->data_ptr() + opt->data_size());
+    return output;
+}
+
+DHCPv6::ia_address_type DHCPv6::ia_address() const {
+    const option *opt = safe_search_option<std::less>(
+        IA_ADDR, sizeof(uint32_t) * 2 + ipaddress_type::address_size
+    );
+    const uint8_t *ptr = opt->data_ptr() + sizeof(uint32_t) * 2 + ipaddress_type::address_size;
+    const uint32_t *ptr_32 = (const uint32_t*)(opt->data_ptr() + ipaddress_type::address_size);
+    DHCPv6::ia_address_type output;
+    output.address = opt->data_ptr();
+    output.preferred_lifetime = Endian::be_to_host(*ptr_32++);
+    output.valid_lifetime = Endian::be_to_host(*ptr_32++);
+    output.options.assign(ptr, opt->data_ptr() + opt->data_size());
+    return output;
+}
+
+DHCPv6::option_request_type DHCPv6::option_request() const {
+    const option *opt = safe_search_option<std::less>(
+        OPTION_REQUEST, 2
+    );
+    const uint16_t *ptr = (const uint16_t*)opt->data_ptr(), 
+                    *end = (const uint16_t*)(opt->data_ptr() + opt->data_size());
+    option_request_type output;
+    while(ptr < end) {
+        output.push_back(
+            static_cast<OptionTypes>(Endian::be_to_host(*ptr++))
+        );
+    }
+    return output;
+}
+
+uint8_t DHCPv6::preference() const {
+    const option *opt = safe_search_option<std::not_equal_to>(
+        PREFERENCE, 1
+    );
+    return *opt->data_ptr();
+}
+
+uint16_t DHCPv6::elapsed_time() const {
+    const option *opt = safe_search_option<std::not_equal_to>(
+        ELAPSED_TIME, 2
+    );
+    return Endian::be_to_host(
+        *(const uint16_t*)opt->data_ptr()
+    );
+}
+
+DHCPv6::relay_msg_type DHCPv6::relay_message() const {
+    const option *opt = safe_search_option<std::less>(
+        RELAY_MSG, 1
+    );
+    return relay_msg_type(
+        opt->data_ptr(), 
+        opt->data_ptr() + opt->data_size()
+    );
+}
+
+DHCPv6::authentication_type DHCPv6::authentication() const {
+    const option *opt = safe_search_option<std::less>(
+        AUTH, sizeof(uint8_t) * 3 + sizeof(uint64_t)
+    );
+    const uint8_t *ptr = opt->data_ptr();
+    authentication_type output;
+    output.protocol = *ptr++;
+    output.algorithm = *ptr++;
+    output.rdm = *ptr++;
+    output.replay_detection = Endian::be_to_host(
+        *(const uint64_t*)ptr
+    );
+    ptr += sizeof(uint64_t);
+    output.auth_info.assign(ptr, opt->data_ptr() + opt->data_size());
+    return output;
+}
+
+DHCPv6::ipaddress_type DHCPv6::server_unicast() const {
+    const option *opt = safe_search_option<std::not_equal_to>(
+        UNICAST, ipaddress_type::address_size
+    );
+    return ipaddress_type(opt->data_ptr());
+}
+
+DHCPv6::status_code_type DHCPv6::status_code() const {
+    const option *opt = safe_search_option<std::less>(
+        STATUS_CODE, sizeof(uint16_t)
+    );
+    status_code_type output;
+    output.code = Endian::be_to_host(*(const uint16_t*)opt->data_ptr());
+    output.message.assign(
+        opt->data_ptr() + sizeof(uint16_t),
+        opt->data_ptr() + opt->data_size()
+    );
+    return output;
+}
+
+bool DHCPv6::has_rapid_commit() const {
+    return search_option(RAPID_COMMIT);
+}
+
+DHCPv6::user_class_type DHCPv6::user_class() const {
+    const option *opt = safe_search_option<std::less>(
+        USER_CLASS, sizeof(uint16_t)
+    );
+    return option2class_option_data<user_class_type>(
+        opt->data_ptr(), opt->data_size()
+    );
+}
+
+DHCPv6::vendor_class_type DHCPv6::vendor_class() const {
+    const option *opt = safe_search_option<std::less>(
+        VENDOR_CLASS, sizeof(uint32_t)
+    );
+    typedef vendor_class_type::class_data_type data_type;
+    vendor_class_type output;
+    output.enterprise_number = Endian::be_to_host(
+        *(const uint32_t*)opt->data_ptr()
+    );
+    output.vendor_class_data = option2class_option_data<data_type>(
+        opt->data_ptr() + sizeof(uint32_t),
+        opt->data_size() - sizeof(uint32_t)
+    );
+    
+    return output;
+}
+
+DHCPv6::vendor_info_type DHCPv6::vendor_info() const {
+    const option *opt = safe_search_option<std::less>(
+        VENDOR_OPTS, sizeof(uint32_t)
+    );
+    vendor_info_type output;
+    output.enterprise_number = Endian::be_to_host(
+        *(const uint32_t*)opt->data_ptr()
+    );
+    output.data.assign(
+        opt->data_ptr() + sizeof(uint32_t),
+        opt->data_ptr() + opt->data_size()
+    );
+    return output;
+}
+
+DHCPv6::interface_id_type DHCPv6::interface_id() const {
+    const option *opt = safe_search_option<std::equal_to>(
+        INTERFACE_ID, 0
+    );
+    return interface_id_type(
+        opt->data_ptr(),
+        opt->data_ptr() + opt->data_size()
+    );
+}
+
+uint8_t DHCPv6::reconfigure_msg() const {
+    return *safe_search_option<std::not_equal_to>(
+        RECONF_MSG, 1
+    )->data_ptr();
+}
+
+bool DHCPv6::has_reconfigure_accept() const {
+    return search_option(RECONF_ACCEPT);
+}
+
+DHCPv6::duid_type DHCPv6::client_id() const {
+    const option *opt = safe_search_option<std::less>(
+        CLIENTID, sizeof(uint16_t) + 1
+    );
+    return duid_type(
+        Endian::be_to_host(*(const uint16_t*)opt->data_ptr()),
+        serialization_type(
+            opt->data_ptr() + sizeof(uint16_t),
+            opt->data_ptr() + opt->data_size()
+        )
+    );
+}
+
+DHCPv6::duid_type DHCPv6::server_id() const {
+    const option *opt = safe_search_option<std::less>(
+        SERVERID, sizeof(uint16_t) + 1
+    );
+    return duid_type(
+        Endian::be_to_host(*(const uint16_t*)opt->data_ptr()),
+        serialization_type(
+            opt->data_ptr() + sizeof(uint16_t),
+            opt->data_ptr() + opt->data_size()
+        )
+    );
+}
+
+// ********************************************************************
+//                          Option setters
+// ********************************************************************
+
+void DHCPv6::ia_na(const ia_na_type &value) {
+    std::vector<uint8_t> buffer(sizeof(uint32_t) * 3 + value.options.size());
+    uint32_t *ptr = (uint32_t*)&buffer[0];
+    *ptr++ = Endian::host_to_be(value.id);
+    *ptr++ = Endian::host_to_be(value.t1);
+    *ptr++ = Endian::host_to_be(value.t2);
+    std::copy(
+        value.options.begin(), 
+        value.options.end(), 
+        buffer.begin() + sizeof(uint32_t) * 3
+    );
+    add_option(
+        option(IA_NA, buffer.begin(), buffer.end())
+    );
+}
+
+void DHCPv6::ia_ta(const ia_ta_type &value) {
+    std::vector<uint8_t> buffer(sizeof(uint32_t) + value.options.size());
+    uint32_t *ptr = (uint32_t*)&buffer[0];
+    *ptr++ = Endian::host_to_be(value.id);
+    std::copy(
+        value.options.begin(), 
+        value.options.end(), 
+        buffer.begin() + sizeof(uint32_t)
+    );
+    add_option(
+        option(IA_TA, buffer.begin(), buffer.end())
+    );
+}
+
+void DHCPv6::ia_address(const ia_address_type &value) {
+    std::vector<uint8_t> buffer(
+        sizeof(uint32_t) * 2 + ipaddress_type::address_size + value.options.size()
+    );
+    uint32_t *ptr = (uint32_t*)&buffer[ipaddress_type::address_size];
+    value.address.copy(&buffer[0]);
+    *ptr++ = Endian::host_to_be(value.preferred_lifetime);
+    *ptr++ = Endian::host_to_be(value.valid_lifetime);
+    std::copy(
+        value.options.begin(), 
+        value.options.end(), 
+        buffer.begin() + sizeof(uint32_t) * 2 + ipaddress_type::address_size
+    );
+    add_option(
+        option(IA_ADDR, buffer.begin(), buffer.end())
+    );
+}
+
+void DHCPv6::option_request(const option_request_type &value) {
+    typedef option_request_type::const_iterator iterator;
+    
+    std::vector<uint8_t> buffer(value.size() * sizeof(uint16_t));
+    size_t index = 0;
+    for(iterator it = value.begin(); it != value.end(); ++it, index += 2) 
+        *(uint16_t*)&buffer[index] = Endian::host_to_be<uint16_t>(*it);
+    add_option(
+        option(OPTION_REQUEST, buffer.begin(), buffer.end())
+    );
+}
+
+void DHCPv6::preference(uint8_t value) {
+    add_option(
+        option(PREFERENCE, 1, &value)
+    );
+}
+
+void DHCPv6::elapsed_time(uint16_t value) {
+    value = Endian::host_to_be(value);
+    add_option(
+        option(ELAPSED_TIME, 2, (const uint8_t*)&value)
+    );
+}
+
+void DHCPv6::relay_message(const relay_msg_type &value) {
+    add_option(
+        option(RELAY_MSG, value.begin(), value.end())
+    );
+}
+
+void DHCPv6::authentication(const authentication_type &value) {
+    std::vector<uint8_t> buffer(
+        sizeof(uint8_t) * 3 + sizeof(uint64_t) + value.auth_info.size()
+    );
+    buffer[0] = value.protocol;
+    buffer[1] = value.algorithm;
+    buffer[2] = value.rdm;
+    *(uint64_t*)&buffer[3] = Endian::host_to_be(value.replay_detection);
+    std::copy(
+        value.auth_info.begin(), 
+        value.auth_info.end(),
+        buffer.begin() + sizeof(uint8_t) * 3 + sizeof(uint64_t)
+    );
+    add_option(
+        option(AUTH, buffer.begin(), buffer.end())
+    );
+}
+
+void DHCPv6::server_unicast(const ipaddress_type &value) {
+    add_option(
+        option(UNICAST, value.begin(), value.end())
+    );
+}
+
+void DHCPv6::status_code(const status_code_type &value) {
+    std::vector<uint8_t> buffer(sizeof(uint16_t) + value.message.size());
+    *(uint16_t*)&buffer[0] = Endian::host_to_be(value.code);
+    std::copy(
+        value.message.begin(), 
+        value.message.end(), 
+        buffer.begin() + sizeof(uint16_t)
+    );
+    add_option(
+        option(STATUS_CODE, buffer.begin(), buffer.end())
+    );
+}
+
+void DHCPv6::rapid_commit() {
+    add_option(
+        RAPID_COMMIT
+    );
+}
+
+void DHCPv6::user_class(const user_class_type &value) {
+    typedef user_class_type::const_iterator iterator;
+    
+    std::vector<uint8_t> buffer;
+    class_option_data2option(value.begin(), value.end(), buffer);
+    add_option(
+        option(USER_CLASS, buffer.begin(), buffer.end())
+    );
+}
+
+void DHCPv6::vendor_class(const vendor_class_type &value) {
+    std::vector<uint8_t> buffer(
+        sizeof(uint32_t)
+    );
+    *(uint32_t*)&buffer[0] = Endian::host_to_be(value.enterprise_number);
+    class_option_data2option(
+        value.vendor_class_data.begin(),
+        value.vendor_class_data.end(),
+        buffer,
+        sizeof(uint32_t)
+    );
+    add_option(
+        option(VENDOR_CLASS, buffer.begin(), buffer.end())
+    );
+}
+
+void DHCPv6::vendor_info(const vendor_info_type &value) {
+    std::vector<uint8_t> buffer(sizeof(uint32_t) + value.data.size());
+    *(uint32_t*)&buffer[0] = Endian::host_to_be(value.enterprise_number);
+    std::copy(
+        value.data.begin(),
+        value.data.end(),
+        buffer.begin() + sizeof(uint32_t)
+    );
+    add_option(
+        option(VENDOR_OPTS, buffer.begin(), buffer.end())
+    );
+}
+
+void DHCPv6::interface_id(const interface_id_type &value) {
+    add_option(
+        option(INTERFACE_ID, value.begin(), value.end())
+    );
+}
+
+void DHCPv6::reconfigure_msg(uint8_t value) {
+    add_option(
+        option(RECONF_MSG, 1, &value)
+    );
+}
+
+void DHCPv6::reconfigure_accept() {
+    add_option(RECONF_ACCEPT);
+}
+
+
+// DUIDs
+
+DHCPv6::duid_llt DHCPv6::duid_llt::from_bytes(const uint8_t *buffer, uint32_t total_sz) 
+{
+    // at least one byte for lladdress
+    if(total_sz < sizeof(uint16_t) + sizeof(uint32_t) + 1)
+        throw std::runtime_error("Not enough size for a DUID_LLT identifier");
+    duid_llt output;
+    output.hw_type = Endian::be_to_host(*(const uint16_t*)buffer);
+    buffer += sizeof(uint16_t);
+    output.time = Endian::be_to_host(*(const uint32_t*)buffer);
+    buffer += sizeof(uint32_t);
+    total_sz -= sizeof(uint16_t) + sizeof(uint32_t);
+    output.lladdress.assign(buffer, buffer + total_sz);
+    return output;
+}
+
+PDU::serialization_type DHCPv6::duid_llt::serialize() const {
+    serialization_type output(sizeof(uint16_t) + sizeof(uint32_t) + lladdress.size());
+    *(uint16_t*)&output[0] = Endian::host_to_be(hw_type);
+    *(uint32_t*)&output[sizeof(uint16_t)] = Endian::host_to_be(time);
+    std::copy(
+        lladdress.begin(),
+        lladdress.end(),
+        output.begin() + sizeof(uint16_t) + sizeof(uint32_t)
+    );
+    return output;
+}
+
+DHCPv6::duid_en DHCPv6::duid_en::from_bytes(const uint8_t *buffer, uint32_t total_sz) 
+{
+    // at least one byte for identifier
+    if(total_sz < sizeof(uint32_t) + 1)
+        throw std::runtime_error("Not enough size for a DUID_en identifier");
+    duid_en output;
+    output.enterprise_number = Endian::be_to_host(*(const uint32_t*)buffer);
+    buffer += sizeof(uint32_t);
+    total_sz -= sizeof(uint32_t);
+    output.identifier.assign(buffer, buffer + total_sz);
+    return output;
+}
+
+PDU::serialization_type DHCPv6::duid_en::serialize() const {
+    serialization_type output(sizeof(uint32_t) + identifier.size());
+    *(uint32_t*)&output[0] = Endian::host_to_be(enterprise_number);
+    std::copy(
+        identifier.begin(),
+        identifier.end(),
+        output.begin() + sizeof(uint32_t)
+    );
+    return output;
+}
+
+DHCPv6::duid_ll DHCPv6::duid_ll::from_bytes(const uint8_t *buffer, uint32_t total_sz) 
+{
+    // at least one byte for lladdress
+    if(total_sz < sizeof(uint16_t) + 1)
+        throw std::runtime_error("Not enough size for a DUID_en identifier");
+    duid_ll output;
+    output.hw_type = Endian::be_to_host(*(const uint16_t*)buffer);
+    buffer += sizeof(uint16_t);
+    total_sz -= sizeof(uint16_t);
+    output.lladdress.assign(buffer, buffer + total_sz);
+    return output;
+}
+
+PDU::serialization_type DHCPv6::duid_ll::serialize() const {
+    serialization_type output(sizeof(uint16_t) + lladdress.size());
+    *(uint16_t*)&output[0] = Endian::host_to_be(hw_type);
+    std::copy(
+        lladdress.begin(),
+        lladdress.end(),
+        output.begin() + sizeof(uint16_t)
+    );
+    return output;
+}
+
+void DHCPv6::client_id(const duid_type &value) {
+    serialization_type buffer(sizeof(uint16_t) + value.data.size());
+    *(uint16_t*)&buffer[0] = Endian::host_to_be(value.id);
+    std::copy(
+        value.data.begin(),
+        value.data.end(),
+        buffer.begin() + sizeof(uint16_t)
+    );
+    add_option(
+        option(CLIENTID, buffer.begin(), buffer.end())
+    );
+}
+
+void DHCPv6::server_id(const duid_type &value) {
+    serialization_type buffer(sizeof(uint16_t) + value.data.size());
+    *(uint16_t*)&buffer[0] = Endian::host_to_be(value.id);
+    std::copy(
+        value.data.begin(),
+        value.data.end(),
+        buffer.begin() + sizeof(uint16_t)
+    );
+    add_option(
+        option(SERVERID, buffer.begin(), buffer.end())
+    );
+}
+
+} // namespace Tins

src/dns.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,9 +30,13 @@
 #include <utility>
 #include <stdexcept>
 #include <cassert>
+#include <sstream>
 #include <memory>
 #include "dns.h"
 #include "ip_address.h"
+#include "ipv6_address.h"
+#include "exceptions.h"
+#include "rawpdu.h"
 
 using std::string;
 using std::list;
@@ -45,7 +49,7 @@ DNS::DNS() : extra_size(0) {
 
 DNS::DNS(const uint8_t *buffer, uint32_t total_sz) : extra_size(0) {
     if(total_sz < sizeof(dnshdr))
-        throw std::runtime_error("Not enough size for a DNS header in the buffer.");
+        throw malformed_packet();
     std::memcpy(&dns, buffer, sizeof(dnshdr));
     const uint8_t *end(buffer + total_sz);
     uint16_t nquestions(questions_count());
@@ -57,7 +61,7 @@ DNS::DNS(const uint8_t *buffer, uint32_t total_sz) : extra_size(0) {
             ptr++;
         Query query;
         if((ptr + (sizeof(uint16_t) * 2)) >= end)
-            throw std::runtime_error("Not enough size for a given query.");
+            throw malformed_packet();
         query.dname(string(buffer, ptr));
         ptr++;
         const uint16_t *opt_ptr = reinterpret_cast<const uint16_t*>(ptr);
@@ -71,6 +75,8 @@ DNS::DNS(const uint8_t *buffer, uint32_t total_sz) : extra_size(0) {
     buffer = build_resource_list(ans, buffer, total_sz, answers_count());
     buffer = build_resource_list(arity, buffer, total_sz, authority_count());
     build_resource_list(addit, buffer, total_sz, additional_count());
+    if(total_sz)
+        inner_pdu(new RawPDU(buffer, total_sz));
 }
 
 const uint8_t *DNS::build_resource_list(ResourcesType &lst, const uint8_t *ptr, uint32_t &sz, uint16_t nrecs) {
@@ -79,7 +85,7 @@ const uint8_t *DNS::build_resource_list(ResourcesType &lst, const uint8_t *ptr,
     for(uint16_t i(0); i < nrecs; ++i) {
         const uint8_t *this_opt_start(ptr);
         if(ptr + sizeof(uint16_t) > ptr_end)
-            throw std::runtime_error("Not enough size for a given resource.");
+            throw malformed_packet();
         lst.push_back(DNSResourceRecord(ptr, ptr_end - ptr));
         ptr += lst.back().size();
         extra_size += ptr - this_opt_start;
@@ -165,6 +171,13 @@ void DNS::add_answer(const string &name, const DNSResourceRecord::info &info,
     dns.answers = Endian::host_to_be<uint16_t>(ans.size());
 }
 
+void DNS::add_answer(const string &name, const DNSResourceRecord::info &info, 
+  address_v6_type ip) 
+{
+    ans.push_back(make_record(name, info, ip.begin(), address_v6_type::address_size));
+    dns.answers = Endian::host_to_be<uint16_t>(ans.size());
+}
+
 void DNS::add_answer(const std::string &name, const DNSResourceRecord::info &info, 
   const std::string &dname) 
 {
@@ -211,9 +224,17 @@ DNSResourceRecord DNS::make_record(const std::string &name,
   const DNSResourceRecord::info &info, const uint8_t *ptr, uint32_t len) 
 {
     string nm;
+    std::basic_string<uint8_t> data;
     parse_domain_name(name, nm);
     uint16_t index = find_domain_name(nm);
     DNSResourceRecord res;
+    if(info.type == MX) {
+        data.push_back(0);
+        data.push_back(0);
+        data.insert(data.end(), ptr, ptr + len);
+        ptr = &data[0];
+        len = data.size();
+    }
     if(index)
         res = make_offseted_record(Endian::host_to_be(index), ptr, len);
     else
@@ -281,7 +302,9 @@ void DNS::unparse_domain_name(const std::string &dn, std::string &out) const {
 }
 
 void DNS::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
+    #ifdef TINS_DEBUG
     assert(total_sz >= sizeof(dns) + extra_size);
+    #endif
     std::memcpy(buffer, &dns, sizeof(dns)); 
     buffer += sizeof(dns);
     for(list<Query>::const_iterator it(queries_.begin()); it != queries_.end(); ++it) {
@@ -326,7 +349,7 @@ void DNS::add_suffix(uint32_t index, const uint8_t *data, uint32_t sz) const {
 uint32_t DNS::build_suffix_map(uint32_t index, const ResourcesType &lst) const {
     const string *str;
     for(ResourcesType::const_iterator it(lst.begin()); it != lst.end(); ++it) {
-        str = it->dname();
+        str = it->has_domain_name() ? it->dname() : 0;
         if(str) {
             add_suffix(index, (uint8_t*)str->c_str(), str->size());
             index += str->size() + 1;
@@ -374,8 +397,10 @@ void DNS::compose_name(const uint8_t *ptr, uint32_t sz, std::string &out) const
             index &= 0x3fff;
             SuffixMap::iterator it(suffixes.find(index));
             SuffixIndices::iterator suff_it(suffix_indices.find(index));
-            if(it == suffixes.end() || suff_it == suffix_indices.end())
-                throw std::runtime_error("Malformed DNS packet");
+            // We need at least a suffix or a suffix index to compose 
+            // the domain name
+            if(it == suffixes.end() && suff_it == suffix_indices.end())
+                throw malformed_packet();
             bool first(true);
             do {
                 if(it != suffixes.end()) {
@@ -420,17 +445,36 @@ void DNS::convert_resources(const ResourcesType &lst, std::list<Resource> &res)
         }
         ptr = it->data_ptr();
         sz = it->data_size();
-        if(sz == 4)
-            addr = IPv4Address(*(uint32_t*)ptr).to_string();
-        else {
-            if(Endian::be_to_host(it->information().type) ==  MX) {
-                ptr += 2;
-                sz -= 2;
-            }
-            compose_name(ptr, sz, addr);
+        uint16_t record_type = Endian::be_to_host(it->information().type);
+        // Skip the preference field if it's MX
+        if(record_type ==  MX) {
+            ptr += 2;
+            sz -= 2;
+        }
+        switch(record_type) {
+            case AAAA:
+                if(sz != 16)
+                    throw malformed_packet();
+                addr = IPv6Address(ptr).to_string();
+                break;
+            case A:
+                if(sz != 4)
+                    throw malformed_packet();
+                addr = IPv4Address(*(uint32_t*)ptr).to_string();
+                break;
+            case NS:
+            case CNAME:
+            case DNAM:
+            case PTR:
+            case MX:
+                compose_name(ptr, sz, addr);
+                break;
+            default:
+                addr.assign(ptr, ptr + sz);
+                break;
         }
         res.push_back(
-            Resource(dname, addr, Endian::be_to_host(it->information().type), 
+            Resource(dname, addr, record_type, 
               Endian::host_to_be(it->information().qclass), 
               Endian::be_to_host(it->information().ttl)
             )
@@ -459,4 +503,11 @@ DNS::resources_type DNS::answers() const {
     convert_resources(ans, res);
     return res;
 }
+
+bool DNS::matches_response(const uint8_t *ptr, uint32_t total_sz) const {
+    if(total_sz < sizeof(dnshdr))
+        return false;
+    const dnshdr *hdr = (const dnshdr*)ptr;
+    return hdr->id == dns.id;
+}
 }

src/dns_record.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Nasel
+ * Copyright (c) 2012, Matias Fontanini
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -33,12 +33,15 @@
 #include <typeinfo>
 #include "dns_record.h"
 #include "endianness.h"
+#include "exceptions.h"
 
 namespace Tins {
 bool contains_dname(uint16_t type) {
     type = Endian::be_to_host(type);
-    return type == 15 || type == 5 ||
-          type == 12 || type == 2;
+    return type == 1 || type == 2 || 
+            type == 5 ||  type == 6 || 
+            type == 12 || type == 15 || 
+            type == 28 || type == 41;
 }
     
 DNSResourceRecord::DNSResourceRecord(DNSRRImpl *impl, 
@@ -51,7 +54,7 @@ DNSResourceRecord::DNSResourceRecord(DNSRRImpl *impl,
 DNSResourceRecord::DNSResourceRecord(const uint8_t *buffer, uint32_t size) 
 {
     const uint8_t *buffer_end = buffer + size;
-    std::auto_ptr<DNSRRImpl> tmp_impl;
+    Internals::smart_ptr<DNSRRImpl>::type tmp_impl;
     if((*buffer & 0xc0)) {
         uint16_t offset(*reinterpret_cast<const uint16_t*>(buffer));
         offset = Endian::be_to_host(offset) & 0x3fff;
@@ -63,17 +66,17 @@ DNSResourceRecord::DNSResourceRecord(const uint8_t *buffer, uint32_t size)
         while(str_end < buffer_end && *str_end)
             str_end++;
         if(str_end == buffer_end)
-            throw std::runtime_error("Not enough size for a resource domain name.");
+            throw malformed_packet();
         //str_end++;
         tmp_impl.reset(new NamedDNSRRImpl(buffer, str_end));
         buffer = ++str_end;
     }
     if(buffer + sizeof(info_) > buffer_end)
-        throw std::runtime_error("Not enough size for a resource info.");
+        throw malformed_packet();
     std::memcpy(&info_, buffer, sizeof(info_));
     buffer += sizeof(info_);
     if(buffer + sizeof(uint16_t) > buffer_end)
-        throw std::runtime_error("Not enough size for resource data size.");
+        throw malformed_packet();
 
     // Store the option size.
     data.resize(
@@ -81,13 +84,11 @@ DNSResourceRecord::DNSResourceRecord(const uint8_t *buffer, uint32_t size)
     );
     buffer += sizeof(uint16_t);
     if(buffer + data.size() > buffer_end)
-        throw std::runtime_error("Not enough size for resource data");
-    if(contains_dname(info_.type))
+        throw malformed_packet();
+    if(contains_dname(info_.type) || data.size() != sizeof(uint32_t))
         std::copy(buffer, buffer + data.size(), data.begin());
     else if(data.size() == sizeof(uint32_t))
         *(uint32_t*)&data[0] = *(uint32_t*)buffer;
-    else
-        throw std::runtime_error("Not enough size for resource data");
     impl = tmp_impl.release();
 }
 
@@ -156,7 +157,7 @@ bool DNSResourceRecord::matches(const std::string &dname) const {
 // OffsetedRecord
 
 OffsetedDNSRRImpl::OffsetedDNSRRImpl(uint16_t off) 
-: offset_(off | 0xc0) 
+: offset_(off | Endian::host_to_be<uint16_t>(0xc000)) 
 {
     
 }
@@ -191,7 +192,8 @@ uint32_t NamedDNSRRImpl::size() const {
 }
 
 uint32_t NamedDNSRRImpl::do_write(uint8_t *buffer) const {
-    std::copy(name.begin(), name.end() + 1, buffer);
+    buffer = std::copy(name.begin(), name.end(), buffer);
+    *buffer = 0;
     return name.size() + 1;
 }