Ubertooth patches to Wireshark master debian/1.8.5-0kali2
authorMati Aharoni (Kali Linux Developer) <muts@kali.org>
Sun, 17 Mar 2013 03:21:15 +0000 (23:21 -0400)
committerMati Aharoni (Kali Linux Developer) <muts@kali.org>
Sun, 17 Mar 2013 03:21:15 +0000 (23:21 -0400)
debian/changelog
debian/patches/99_wireshark-1.8.4-ubertooth.patch [new file with mode: 0644]
debian/patches/series

index e9ed42d..5a6902f 100644 (file)
@@ -1,3 +1,9 @@
+wireshark (1.8.5-0kali2) kali; urgency=low
+
+  * Ubertooth patches to Wireshark
+
+ -- Mati Aharoni <muts@kali.org>  Sat, 16 Mar 2013 23:20:44 -0400
+
 wireshark (1.8.5-0kali1) kali; urgency=low
 
   * New upstream release.
diff --git a/debian/patches/99_wireshark-1.8.4-ubertooth.patch b/debian/patches/99_wireshark-1.8.4-ubertooth.patch
new file mode 100644 (file)
index 0000000..b5c016a
--- /dev/null
@@ -0,0 +1,5349 @@
+diff -Naur wireshark-1.8.4/CMakeLists.txt wireshark/CMakeLists.txt
+--- wireshark-1.8.4/CMakeLists.txt     2012-06-05 12:33:43.000000000 -0400
++++ wireshark/CMakeLists.txt   2013-01-26 15:26:14.149570731 -0500
+@@ -410,6 +410,7 @@
+       set(PLUGIN_SRC_DIRS
+               plugins/asn1
+               plugins/docsis
++              plugins/btbb
+               plugins/ethercat
+               plugins/gryphon
+               plugins/irda
+diff -Naur wireshark-1.8.4/configure.in wireshark/configure.in
+--- wireshark-1.8.4/configure.in       2012-11-28 13:50:31.000000000 -0500
++++ wireshark/configure.in     2013-01-26 15:21:19.036107343 -0500
+@@ -2097,6 +2097,7 @@
+   plugins/Makefile
+   plugins/asn1/Makefile
+   plugins/docsis/Makefile
++  plugins/btbb/Makefile
+   plugins/ethercat/Makefile
+   plugins/gryphon/Makefile
+   plugins/irda/Makefile
+diff -Naur wireshark-1.8.4/epan/Makefile.am wireshark/epan/Makefile.am
+--- wireshark-1.8.4/epan/Makefile.am   2012-10-02 15:51:24.000000000 -0400
++++ wireshark/epan/Makefile.am 2013-01-26 15:23:35.084781972 -0500
+@@ -210,6 +210,7 @@
+ plugin_src = \
+       ../plugins/asn1/packet-asn1.c \
+       ../plugins/docsis/packet-bintrngreq.c \
++        ../plugsis/btbb/packet-btbb.c \
+       ../plugins/docsis/packet-bpkmattr.c \
+       ../plugins/docsis/packet-bpkmreq.c \
+       ../plugins/docsis/packet-bpkmrsp.c \
+diff -Naur wireshark-1.8.4/packaging/nsis/Makefile.nmake wireshark/packaging/nsis/Makefile.nmake
+--- wireshark-1.8.4/packaging/nsis/Makefile.nmake      2012-07-27 19:36:21.000000000 -0400
++++ wireshark/packaging/nsis/Makefile.nmake    2013-01-26 15:24:33.829073269 -0500
+@@ -47,6 +47,7 @@
+ PLUGINS= \
+       ../../plugins/asn1/asn1.dll \
+       ../../plugins/docsis/docsis.dll \
++        ../../plugins/btbb/btbb.dll \
+       ../../plugins/ethercat/ethercat.dll \
+       ../../plugins/gryphon/gryphon.dll \
+       ../../plugins/irda/irda.dll \
+diff -Naur wireshark-1.8.4/packaging/nsis/wireshark.nsi wireshark/packaging/nsis/wireshark.nsi
+--- wireshark-1.8.4/packaging/nsis/wireshark.nsi       2012-09-23 16:28:33.000000000 -0400
++++ wireshark/packaging/nsis/wireshark.nsi     2013-01-26 15:25:26.789335885 -0500
+@@ -820,6 +820,7 @@
+ SetOutPath '$INSTDIR\plugins\${VERSION}'
+ File "${STAGING_DIR}\plugins\${VERSION}\asn1.dll"
+ File "${STAGING_DIR}\plugins\${VERSION}\docsis.dll"
++File "${STAGING_DIR}\plugins\${VERSION}\btbb.dll"
+ File "${STAGING_DIR}\plugins\${VERSION}\ethercat.dll"
+ File "${STAGING_DIR}\plugins\${VERSION}\gryphon.dll"
+ File "${STAGING_DIR}\plugins\${VERSION}\irda.dll"
+diff -Naur wireshark-1.8.4/plugins/btbb/AUTHORS wireshark/plugins/btbb/AUTHORS
+--- wireshark-1.8.4/plugins/btbb/AUTHORS       1969-12-31 19:00:00.000000000 -0500
++++ wireshark/plugins/btbb/AUTHORS     2013-01-26 15:04:24.667077358 -0500
+@@ -0,0 +1,2 @@
++Authors:
++Michael Ossmann <mike@ossmann.com>
+diff -Naur wireshark-1.8.4/plugins/btbb/cmake/COPYING wireshark/plugins/btbb/cmake/COPYING
+--- wireshark-1.8.4/plugins/btbb/cmake/COPYING 1969-12-31 19:00:00.000000000 -0500
++++ wireshark/plugins/btbb/cmake/COPYING       2013-01-26 15:04:24.675077398 -0500
+@@ -0,0 +1,22 @@
++Redistribution and use in source and binary forms, with or without
++modification, are permitted provided that the following conditions
++are met:
++
++1. Redistributions of source code must retain the copyright
++   notice, this list of conditions and the following disclaimer.
++2. Redistributions in binary form must reproduce the copyright
++   notice, this list of conditions and the following disclaimer in the
++   documentation and/or other materials provided with the distribution.
++3. The name of the author may not be used to endorse or promote products
++   derived from this software without specific prior written permission.
++
++THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+diff -Naur wireshark-1.8.4/plugins/btbb/cmake/COPYING-CMAKE-SCRIPTS wireshark/plugins/btbb/cmake/COPYING-CMAKE-SCRIPTS
+--- wireshark-1.8.4/plugins/btbb/cmake/COPYING-CMAKE-SCRIPTS   1969-12-31 19:00:00.000000000 -0500
++++ wireshark/plugins/btbb/cmake/COPYING-CMAKE-SCRIPTS 2013-01-26 15:04:24.675077398 -0500
+@@ -0,0 +1,27 @@
++Copyright notice for the files copied from
++http://www.opensync.org/browser/branches/3rd-party-cmake-modules/modules
++
++$Id: COPYING-CMAKE-SCRIPTS 34248 2010-09-25 15:38:12Z jmayer $
++
++Redistribution and use in source and binary forms, with or without
++modification, are permitted provided that the following conditions
++are met:
++
++1. Redistributions of source code must retain the copyright
++   notice, this list of conditions and the following disclaimer.
++2. Redistributions in binary form must reproduce the copyright
++   notice, this list of conditions and the following disclaimer in the
++   documentation and/or other materials provided with the distribution.
++3. The name of the author may not be used to endorse or promote products
++   derived from this software without specific prior written permission.
++
++THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+diff -Naur wireshark-1.8.4/plugins/btbb/cmake/FindGLIB2.cmake wireshark/plugins/btbb/cmake/FindGLIB2.cmake
+--- wireshark-1.8.4/plugins/btbb/cmake/FindGLIB2.cmake 1969-12-31 19:00:00.000000000 -0500
++++ wireshark/plugins/btbb/cmake/FindGLIB2.cmake       2013-01-26 15:04:24.675077398 -0500
+@@ -0,0 +1,238 @@
++#
++# $Id: FindGLIB2.cmake 34248 2010-09-25 15:38:12Z jmayer $
++#
++# - Try to find GLib2
++# Once done this will define
++#
++#  GLIB2_FOUND - system has GLib2
++#  GLIB2_INCLUDE_DIRS - the GLib2 include directory
++#  GLIB2_LIBRARIES - Link these to use GLib2
++#
++#  HAVE_GLIB_GREGEX_H  glib has gregex.h header and 
++#                      supports g_regex_match_simple
++#
++#  Copyright (c) 2006 Andreas Schneider <mail@cynapses.org>
++#  Copyright (c) 2006 Philippe Bernery <philippe.bernery@gmail.com>
++#  Copyright (c) 2007 Daniel Gollub <gollub@b1-systems.de>
++#  Copyright (c) 2007 Alban Browaeys <prahal@yahoo.com>
++#  Copyright (c) 2008 Michael Bell <michael.bell@web.de>
++#  Copyright (c) 2008-2009 Bjoern Ricks <bjoern.ricks@googlemail.com>
++#
++#  Redistribution and use is allowed according to the terms of the New
++#  BSD license.
++#  For details see the accompanying COPYING-CMAKE-SCRIPTS file.
++#
++
++
++IF (GLIB2_LIBRARIES AND GLIB2_INCLUDE_DIRS )
++  # in cache already
++  SET(GLIB2_FOUND TRUE)
++ELSE (GLIB2_LIBRARIES AND GLIB2_INCLUDE_DIRS )
++
++  INCLUDE(FindPkgConfig)
++
++  ## Glib
++  IF ( GLIB2_FIND_REQUIRED )
++    SET( _pkgconfig_REQUIRED "REQUIRED" )
++  ELSE ( GLIB2_FIND_REQUIRED )
++    SET( _pkgconfig_REQUIRED "" )
++  ENDIF ( GLIB2_FIND_REQUIRED )
++
++  IF ( GLIB2_MIN_VERSION )
++    PKG_SEARCH_MODULE( GLIB2 ${_pkgconfig_REQUIRED} glib-2.0>=${GLIB2_MIN_VERSION} )
++  ELSE ( GLIB2_MIN_VERSION )
++    PKG_SEARCH_MODULE( GLIB2 ${_pkgconfig_REQUIRED} glib-2.0 )
++  ENDIF ( GLIB2_MIN_VERSION )
++  IF ( PKG_CONFIG_FOUND )
++    IF ( GLIB2_FOUND )
++      SET ( GLIB2_CORE_FOUND TRUE )
++    ELSE ( GLIB2_FOUND )
++      SET ( GLIB2_CORE_FOUND FALSE )
++    ENDIF ( GLIB2_FOUND )
++  ENDIF ( PKG_CONFIG_FOUND )
++
++  # Look for glib2 include dir and libraries w/o pkgconfig
++  IF ( NOT GLIB2_FOUND AND NOT PKG_CONFIG_FOUND )
++    FIND_PATH(
++      _glibconfig_include_DIR
++    NAMES
++      glibconfig.h
++    PATHS
++      /opt/gnome/lib64
++      /opt/gnome/lib
++      /opt/lib/
++      /opt/local/lib
++      /sw/lib/
++      /usr/lib64
++      /usr/lib
++      /usr/local/include
++      ${CMAKE_LIBRARY_PATH}
++    PATH_SUFFIXES
++      glib-2.0/include
++    )
++
++    FIND_PATH(
++      _glib2_include_DIR
++    NAMES
++      glib.h
++    PATHS
++      /opt/gnome/include
++      /opt/local/include
++      /sw/include
++      /usr/include
++      /usr/local/include
++    PATH_SUFFIXES
++      glib-2.0
++    )
++
++    #MESSAGE(STATUS "Glib headers: ${_glib2_include_DIR}")
++
++    FIND_LIBRARY(
++      _glib2_link_DIR
++    NAMES
++      glib-2.0
++      glib
++    PATHS
++      /opt/gnome/lib
++      /opt/local/lib
++      /sw/lib
++      /usr/lib
++      /usr/local/lib
++    )
++    IF ( _glib2_include_DIR AND _glib2_link_DIR )
++        SET ( _glib2_FOUND TRUE )
++    ENDIF ( _glib2_include_DIR AND _glib2_link_DIR )
++
++
++    IF ( _glib2_FOUND )
++        SET ( GLIB2_INCLUDE_DIRS ${_glib2_include_DIR} ${_glibconfig_include_DIR} )
++        SET ( GLIB2_LIBRARIES ${_glib2_link_DIR} )
++        SET ( GLIB2_CORE_FOUND TRUE )
++    ELSE ( _glib2_FOUND )
++        SET ( GLIB2_CORE_FOUND FALSE )
++    ENDIF ( _glib2_FOUND )
++
++    # Handle dependencies
++    # libintl
++    IF ( NOT LIBINTL_FOUND )
++      FIND_PATH(LIBINTL_INCLUDE_DIR
++      NAMES
++        libintl.h
++      PATHS
++        /opt/gnome/include
++        /opt/local/include
++        /sw/include
++        /usr/include
++        /usr/local/include
++      )
++
++      FIND_LIBRARY(LIBINTL_LIBRARY
++      NAMES
++        intl
++      PATHS
++        /opt/gnome/lib
++        /opt/local/lib
++        /sw/lib
++        /usr/local/lib
++        /usr/lib
++      )
++
++      IF (LIBINTL_LIBRARY AND LIBINTL_INCLUDE_DIR)
++        SET (LIBINTL_FOUND TRUE)
++      ENDIF (LIBINTL_LIBRARY AND LIBINTL_INCLUDE_DIR)
++    ENDIF ( NOT LIBINTL_FOUND )
++
++    # libiconv
++    IF ( NOT LIBICONV_FOUND )
++      FIND_PATH(LIBICONV_INCLUDE_DIR
++      NAMES
++        iconv.h
++      PATHS
++        /opt/gnome/include
++        /opt/local/include
++        /opt/local/include
++        /sw/include
++        /sw/include
++        /usr/local/include
++        /usr/include
++      PATH_SUFFIXES
++        glib-2.0
++      )
++
++      FIND_LIBRARY(LIBICONV_LIBRARY
++      NAMES
++        iconv
++      PATHS
++        /opt/gnome/lib
++        /opt/local/lib
++        /sw/lib
++        /usr/lib
++        /usr/local/lib
++      )
++
++      IF (LIBICONV_LIBRARY AND LIBICONV_INCLUDE_DIR)
++        SET (LIBICONV_FOUND TRUE)
++      ENDIF (LIBICONV_LIBRARY AND LIBICONV_INCLUDE_DIR)
++    ENDIF ( NOT LIBICONV_FOUND )
++
++    IF (LIBINTL_FOUND)
++      SET (GLIB2_LIBRARIES ${GLIB2_LIBRARIES} ${LIBINTL_LIBRARY})
++      SET (GLIB2_INCLUDE_DIRS ${GLIB2_INCLUDE_DIRS} ${LIBINTL_INCLUDE_DIR})
++    ENDIF (LIBINTL_FOUND)
++
++    IF (LIBICONV_FOUND)
++      SET (GLIB2_LIBRARIES ${GLIB2_LIBRARIES} ${LIBICONV_LIBRARY})
++      SET (GLIB2_INCLUDE_DIRS ${GLIB2_INCLUDE_DIRS} ${LIBICONV_INCLUDE_DIR})
++    ENDIF (LIBICONV_FOUND)
++
++  ENDIF ( NOT GLIB2_FOUND AND NOT PKG_CONFIG_FOUND )
++  ##
++
++  IF (GLIB2_CORE_FOUND AND GLIB2_INCLUDE_DIRS AND GLIB2_LIBRARIES)
++    SET (GLIB2_FOUND TRUE)
++  ENDIF (GLIB2_CORE_FOUND AND GLIB2_INCLUDE_DIRS AND GLIB2_LIBRARIES)
++
++  IF (GLIB2_FOUND)
++    IF (NOT GLIB2_FIND_QUIETLY)
++      MESSAGE (STATUS "Found GLib2: ${GLIB2_LIBRARIES} ${GLIB2_INCLUDE_DIRS}")
++    ENDIF (NOT GLIB2_FIND_QUIETLY)
++  ELSE (GLIB2_FOUND)
++    IF (GLIB2_FIND_REQUIRED)
++      MESSAGE (SEND_ERROR "Could not find GLib2")
++    ENDIF (GLIB2_FIND_REQUIRED)
++  ENDIF (GLIB2_FOUND)
++
++  # show the GLIB2_INCLUDE_DIRS and GLIB2_LIBRARIES variables only in the advanced view
++  MARK_AS_ADVANCED(GLIB2_INCLUDE_DIRS GLIB2_LIBRARIES)
++  MARK_AS_ADVANCED(LIBICONV_INCLUDE_DIR LIBICONV_LIBRARY)
++  MARK_AS_ADVANCED(LIBINTL_INCLUDE_DIR LIBINTL_LIBRARY)
++
++ENDIF (GLIB2_LIBRARIES AND GLIB2_INCLUDE_DIRS)
++
++IF ( WIN32 )
++    # include libiconv for win32
++    IF ( NOT LIBICONV_FOUND )
++      FIND_PATH(LIBICONV_INCLUDE_DIR iconv.h PATH_SUFFIXES glib-2.0)
++
++      FIND_LIBRARY(LIBICONV_LIBRARY NAMES iconv)
++
++      IF (LIBICONV_LIBRARY AND LIBICONV_INCLUDE_DIR)
++        SET (LIBICONV_FOUND TRUE)
++      ENDIF (LIBICONV_LIBRARY AND LIBICONV_INCLUDE_DIR)
++    ENDIF ( NOT LIBICONV_FOUND )
++    IF (LIBICONV_FOUND)
++      SET (GLIB2_LIBRARIES ${GLIB2_LIBRARIES} ${LIBICONV_LIBRARY})
++      SET (GLIB2_INCLUDE_DIRS ${GLIB2_INCLUDE_DIRS} ${LIBICONV_INCLUDE_DIR})
++    ENDIF (LIBICONV_FOUND)
++ENDIF ( WIN32 )
++
++IF ( GLIB2_FOUND )
++      # Check if system has a newer version of glib
++      # which supports g_regex_match_simple
++      INCLUDE( CheckIncludeFiles )
++      SET( CMAKE_REQUIRED_INCLUDES ${GLIB2_INCLUDE_DIRS} )
++      CHECK_INCLUDE_FILES ( glib/gregex.h HAVE_GLIB_GREGEX_H )
++      CHECK_INCLUDE_FILES ( glib/gchecksum.h HAVE_GLIB_GCHECKSUM_H )
++      # Reset CMAKE_REQUIRED_INCLUDES
++      SET( CMAKE_REQUIRED_INCLUDES "" )
++ENDIF( GLIB2_FOUND )
+diff -Naur wireshark-1.8.4/plugins/btbb/cmake/FindWireshark.cmake wireshark/plugins/btbb/cmake/FindWireshark.cmake
+--- wireshark-1.8.4/plugins/btbb/cmake/FindWireshark.cmake     1969-12-31 19:00:00.000000000 -0500
++++ wireshark/plugins/btbb/cmake/FindWireshark.cmake   2013-01-26 15:04:24.675077398 -0500
+@@ -0,0 +1,28 @@
++#
++# Try to find the wireshark library and its includes
++#
++# This snippet sets the following variables:
++#  WIRESHARK_FOUND             True if wireshark library got found
++#  WIRESHARK_INCLUDE_DIRS      Location of the wireshark headers 
++#  WIRESHARK_LIBRARIES         List of libraries to use wireshark
++#
++#  Copyright (c) 2011 Reinhold Kainhofer <reinhold@kainhofer.com>
++#
++#  Redistribution and use is allowed according to the terms of the New
++#  BSD license.
++#  For details see the accompanying COPYING-CMAKE-SCRIPTS file.
++#
++
++# wireshark does not install its library with pkg-config information,
++# so we need to manually find the libraries and headers
++
++FIND_PATH( WIRESHARK_INCLUDE_DIRS epan/column_info.h PATH_SUFFIXES wireshark )
++FIND_LIBRARY( WIRESHARK_LIBRARIES wireshark )
++
++# Report results
++IF ( WIRESHARK_LIBRARIES AND WIRESHARK_INCLUDE_DIRS )
++  SET( WIRESHARK_FOUND 1 )
++ELSE ( WIRESHARK_LIBRARIES AND WIRESHARK_INCLUDE_DIRS )
++  MESSAGE( SEND_ERROR "Could NOT find the wireshark library and headers" )
++ENDIF ( WIRESHARK_LIBRARIES AND WIRESHARK_INCLUDE_DIRS )
++
+diff -Naur wireshark-1.8.4/plugins/btbb/cmake/UseMakeDissectorReg.cmake wireshark/plugins/btbb/cmake/UseMakeDissectorReg.cmake
+--- wireshark-1.8.4/plugins/btbb/cmake/UseMakeDissectorReg.cmake       1969-12-31 19:00:00.000000000 -0500
++++ wireshark/plugins/btbb/cmake/UseMakeDissectorReg.cmake     2013-01-26 15:04:24.675077398 -0500
+@@ -0,0 +1,33 @@
++#
++# $Id: UseMakeDissectorReg.cmake 33616 2010-07-22 12:18:36Z stig $
++#
++MACRO(REGISTER_DISSECTOR_FILES _outputfile _registertype )
++      # FIXME: Only the Python stuff has been implemented
++      #        Make this into a MACRO, to avoid duplication with plugins/.../
++      #register.c: $(plugin_src) $(ALL_DISSECTORS_SRC) $(top_srcdir)/tools/make-dissector-reg \
++      #    $(top_srcdir)/tools/make-dissector-reg.py
++      #        @if test -n "$(PYTHON)"; then \
++      #                echo Making register.c with python ; \
++      #                $(PYTHON) $(top_srcdir)/tools/make-dissector-reg.py $(srcdir) \
++      #                    dissectors $(ALL_DISSECTORS_SRC) ; \
++      #        else \
++      #                echo Making register.c with shell script ; \
++      #                $(top_srcdir)/tools/make-dissector-reg $(srcdir) \
++      #                   dissectors $(plugin_src) $(ALL_DISSECTORS_SRC) ; \
++      #        fi
++      set( _sources ${ARGN} )
++      ADD_CUSTOM_COMMAND(
++          OUTPUT 
++            ${_outputfile}
++          COMMAND ${PYTHON_EXECUTABLE}
++            ${CMAKE_SOURCE_DIR}/tools/make-dissector-reg.py
++            ${CMAKE_CURRENT_SOURCE_DIR}
++            ${_registertype}
++            ${_sources}
++          DEPENDS
++            ${_sources}
++            ${CMAKE_SOURCE_DIR}/tools/make-dissector-reg
++            ${CMAKE_SOURCE_DIR}/tools/make-dissector-reg.py
++      )
++ENDMACRO(REGISTER_DISSECTOR_FILES)
++
+diff -Naur wireshark-1.8.4/plugins/btbb/CMakeLists.txt wireshark/plugins/btbb/CMakeLists.txt
+--- wireshark-1.8.4/plugins/btbb/CMakeLists.txt        1969-12-31 19:00:00.000000000 -0500
++++ wireshark/plugins/btbb/CMakeLists.txt      2013-01-26 15:04:24.667077358 -0500
+@@ -0,0 +1,89 @@
++# CMakeLists.txt
++#
++# $Id: CMakeLists.txt 31995 2010-02-24 22:32:10Z jmayer $
++#
++# Wireshark - Network traffic analyzer
++# By Gerald Combs <gerald@wireshark.org>
++# Copyright 1998 Gerald Combs
++#
++# This program is free software; you can redistribute it and/or
++# modify it under the terms of the GNU General Public License
++# as published by the Free Software Foundation; either version 2
++# of the License, or (at your option) any later version.
++#
++# This program is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++# GNU General Public License for more details.
++#
++# You should have received a copy of the GNU General Public License
++# along with this program; if not, write to the Free Software
++# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
++#
++
++project(btbb-wireshark-plugin C)
++
++cmake_minimum_required(VERSION 2.6)
++set(CMAKE_BACKWARDS_COMPATIBILITY 2.6)
++set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake)
++
++IF ( NOT CMAKE_INSTALL_LIBDIR )
++  set(CMAKE_INSTALL_LIBDIR ~/.wireshark/plugins/)
++ENDIF ( NOT CMAKE_INSTALL_LIBDIR )
++MESSAGE (STATUS "Plugin will be installed in: ${CMAKE_INSTALL_LIBDIR}")
++
++INCLUDE(UseMakeDissectorReg)
++  
++set(GLIB2_MIN_VERSION 2.4.0)
++
++find_package(GLIB2)
++include_directories (${GLIB2_INCLUDE_DIRS})
++
++find_package(Wireshark)
++include_directories (${WIRESHARK_INCLUDE_DIRS})
++
++set(LINK_MODE_LIB SHARED)
++set(LINK_MODE_MODULE MODULE)
++
++
++set(DISSECTOR_SRC
++      packet-btbb.c
++      packet-btlmp.c
++)
++
++set(PLUGIN_FILES
++      plugin.c
++      ${DISSECTOR_SRC}
++)
++
++set(CLEAN_FILES
++      ${PLUGIN_FILES}
++)
++
++if (WERROR)
++      set_source_files_properties(
++              ${CLEAN_FILES}
++              PROPERTIES
++              COMPILE_FLAGS -Werror
++      )
++endif()
++
++include_directories(${CMAKE_CURRENT_SOURCE_DIR})
++
++register_dissector_files(plugin.c
++      plugin
++      ${DISSECTOR_SRC}
++)
++
++add_library(btbb ${LINK_MODE_MODULE}
++      ${PLUGIN_FILES}
++)
++set_target_properties(btbb PROPERTIES PREFIX "")
++set_target_properties(btbb PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}")
++
++target_link_libraries(btbb wireshark)
++
++install(TARGETS btbb
++      LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} NAMELINK_SKIP
++)
++
+diff -Naur wireshark-1.8.4/plugins/btbb/COPYING wireshark/plugins/btbb/COPYING
+--- wireshark-1.8.4/plugins/btbb/COPYING       1969-12-31 19:00:00.000000000 -0500
++++ wireshark/plugins/btbb/COPYING     2013-01-26 15:04:24.663077339 -0500
+@@ -0,0 +1,340 @@
++                  GNU GENERAL PUBLIC LICENSE
++                     Version 2, June 1991
++
++ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
++     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
++ Everyone is permitted to copy and distribute verbatim copies
++ of this license document, but changing it is not allowed.
++
++                          Preamble
++
++  The licenses for most software are designed to take away your
++freedom to share and change it.  By contrast, the GNU General Public
++License is intended to guarantee your freedom to share and change free
++software--to make sure the software is free for all its users.  This
++General Public License applies to most of the Free Software
++Foundation's software and to any other program whose authors commit to
++using it.  (Some other Free Software Foundation software is covered by
++the GNU Library General Public License instead.)  You can apply it to
++your programs, too.
++
++  When we speak of free software, we are referring to freedom, not
++price.  Our General Public Licenses are designed to make sure that you
++have the freedom to distribute copies of free software (and charge for
++this service if you wish), that you receive source code or can get it
++if you want it, that you can change the software or use pieces of it
++in new free programs; and that you know you can do these things.
++
++  To protect your rights, we need to make restrictions that forbid
++anyone to deny you these rights or to ask you to surrender the rights.
++These restrictions translate to certain responsibilities for you if you
++distribute copies of the software, or if you modify it.
++
++  For example, if you distribute copies of such a program, whether
++gratis or for a fee, you must give the recipients all the rights that
++you have.  You must make sure that they, too, receive or can get the
++source code.  And you must show them these terms so they know their
++rights.
++
++  We protect your rights with two steps: (1) copyright the software, and
++(2) offer you this license which gives you legal permission to copy,
++distribute and/or modify the software.
++
++  Also, for each author's protection and ours, we want to make certain
++that everyone understands that there is no warranty for this free
++software.  If the software is modified by someone else and passed on, we
++want its recipients to know that what they have is not the original, so
++that any problems introduced by others will not reflect on the original
++authors' reputations.
++
++  Finally, any free program is threatened constantly by software
++patents.  We wish to avoid the danger that redistributors of a free
++program will individually obtain patent licenses, in effect making the
++program proprietary.  To prevent this, we have made it clear that any
++patent must be licensed for everyone's free use or not licensed at all.
++
++  The precise terms and conditions for copying, distribution and
++modification follow.
++
++                  GNU GENERAL PUBLIC LICENSE
++   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
++
++  0. This License applies to any program or other work which contains
++a notice placed by the copyright holder saying it may be distributed
++under the terms of this General Public License.  The "Program", below,
++refers to any such program or work, and a "work based on the Program"
++means either the Program or any derivative work under copyright law:
++that is to say, a work containing the Program or a portion of it,
++either verbatim or with modifications and/or translated into another
++language.  (Hereinafter, translation is included without limitation in
++the term "modification".)  Each licensee is addressed as "you".
++
++Activities other than copying, distribution and modification are not
++covered by this License; they are outside its scope.  The act of
++running the Program is not restricted, and the output from the Program
++is covered only if its contents constitute a work based on the
++Program (independent of having been made by running the Program).
++Whether that is true depends on what the Program does.
++
++  1. You may copy and distribute verbatim copies of the Program's
++source code as you receive it, in any medium, provided that you
++conspicuously and appropriately publish on each copy an appropriate
++copyright notice and disclaimer of warranty; keep intact all the
++notices that refer to this License and to the absence of any warranty;
++and give any other recipients of the Program a copy of this License
++along with the Program.
++
++You may charge a fee for the physical act of transferring a copy, and
++you may at your option offer warranty protection in exchange for a fee.
++
++  2. You may modify your copy or copies of the Program or any portion
++of it, thus forming a work based on the Program, and copy and
++distribute such modifications or work under the terms of Section 1
++above, provided that you also meet all of these conditions:
++
++    a) You must cause the modified files to carry prominent notices
++    stating that you changed the files and the date of any change.
++
++    b) You must cause any work that you distribute or publish, that in
++    whole or in part contains or is derived from the Program or any
++    part thereof, to be licensed as a whole at no charge to all third
++    parties under the terms of this License.
++
++    c) If the modified program normally reads commands interactively
++    when run, you must cause it, when started running for such
++    interactive use in the most ordinary way, to print or display an
++    announcement including an appropriate copyright notice and a
++    notice that there is no warranty (or else, saying that you provide
++    a warranty) and that users may redistribute the program under
++    these conditions, and telling the user how to view a copy of this
++    License.  (Exception: if the Program itself is interactive but
++    does not normally print such an announcement, your work based on
++    the Program is not required to print an announcement.)
++
++These requirements apply to the modified work as a whole.  If
++identifiable sections of that work are not derived from the Program,
++and can be reasonably considered independent and separate works in
++themselves, then this License, and its terms, do not apply to those
++sections when you distribute them as separate works.  But when you
++distribute the same sections as part of a whole which is a work based
++on the Program, the distribution of the whole must be on the terms of
++this License, whose permissions for other licensees extend to the
++entire whole, and thus to each and every part regardless of who wrote it.
++
++Thus, it is not the intent of this section to claim rights or contest
++your rights to work written entirely by you; rather, the intent is to
++exercise the right to control the distribution of derivative or
++collective works based on the Program.
++
++In addition, mere aggregation of another work not based on the Program
++with the Program (or with a work based on the Program) on a volume of
++a storage or distribution medium does not bring the other work under
++the scope of this License.
++
++  3. You may copy and distribute the Program (or a work based on it,
++under Section 2) in object code or executable form under the terms of
++Sections 1 and 2 above provided that you also do one of the following:
++
++    a) Accompany it with the complete corresponding machine-readable
++    source code, which must be distributed under the terms of Sections
++    1 and 2 above on a medium customarily used for software interchange; or,
++
++    b) Accompany it with a written offer, valid for at least three
++    years, to give any third party, for a charge no more than your
++    cost of physically performing source distribution, a complete
++    machine-readable copy of the corresponding source code, to be
++    distributed under the terms of Sections 1 and 2 above on a medium
++    customarily used for software interchange; or,
++
++    c) Accompany it with the information you received as to the offer
++    to distribute corresponding source code.  (This alternative is
++    allowed only for noncommercial distribution and only if you
++    received the program in object code or executable form with such
++    an offer, in accord with Subsection b above.)
++
++The source code for a work means the preferred form of the work for
++making modifications to it.  For an executable work, complete source
++code means all the source code for all modules it contains, plus any
++associated interface definition files, plus the scripts used to
++control compilation and installation of the executable.  However, as a
++special exception, the source code distributed need not include
++anything that is normally distributed (in either source or binary
++form) with the major components (compiler, kernel, and so on) of the
++operating system on which the executable runs, unless that component
++itself accompanies the executable.
++
++If distribution of executable or object code is made by offering
++access to copy from a designated place, then offering equivalent
++access to copy the source code from the same place counts as
++distribution of the source code, even though third parties are not
++compelled to copy the source along with the object code.
++
++  4. You may not copy, modify, sublicense, or distribute the Program
++except as expressly provided under this License.  Any attempt
++otherwise to copy, modify, sublicense or distribute the Program is
++void, and will automatically terminate your rights under this License.
++However, parties who have received copies, or rights, from you under
++this License will not have their licenses terminated so long as such
++parties remain in full compliance.
++
++  5. You are not required to accept this License, since you have not
++signed it.  However, nothing else grants you permission to modify or
++distribute the Program or its derivative works.  These actions are
++prohibited by law if you do not accept this License.  Therefore, by
++modifying or distributing the Program (or any work based on the
++Program), you indicate your acceptance of this License to do so, and
++all its terms and conditions for copying, distributing or modifying
++the Program or works based on it.
++
++  6. Each time you redistribute the Program (or any work based on the
++Program), the recipient automatically receives a license from the
++original licensor to copy, distribute or modify the Program subject to
++these terms and conditions.  You may not impose any further
++restrictions on the recipients' exercise of the rights granted herein.
++You are not responsible for enforcing compliance by third parties to
++this License.
++
++  7. If, as a consequence of a court judgment or allegation of patent
++infringement or for any other reason (not limited to patent issues),
++conditions are imposed on you (whether by court order, agreement or
++otherwise) that contradict the conditions of this License, they do not
++excuse you from the conditions of this License.  If you cannot
++distribute so as to satisfy simultaneously your obligations under this
++License and any other pertinent obligations, then as a consequence you
++may not distribute the Program at all.  For example, if a patent
++license would not permit royalty-free redistribution of the Program by
++all those who receive copies directly or indirectly through you, then
++the only way you could satisfy both it and this License would be to
++refrain entirely from distribution of the Program.
++
++If any portion of this section is held invalid or unenforceable under
++any particular circumstance, the balance of the section is intended to
++apply and the section as a whole is intended to apply in other
++circumstances.
++
++It is not the purpose of this section to induce you to infringe any
++patents or other property right claims or to contest validity of any
++such claims; this section has the sole purpose of protecting the
++integrity of the free software distribution system, which is
++implemented by public license practices.  Many people have made
++generous contributions to the wide range of software distributed
++through that system in reliance on consistent application of that
++system; it is up to the author/donor to decide if he or she is willing
++to distribute software through any other system and a licensee cannot
++impose that choice.
++
++This section is intended to make thoroughly clear what is believed to
++be a consequence of the rest of this License.
++
++  8. If the distribution and/or use of the Program is restricted in
++certain countries either by patents or by copyrighted interfaces, the
++original copyright holder who places the Program under this License
++may add an explicit geographical distribution limitation excluding
++those countries, so that distribution is permitted only in or among
++countries not thus excluded.  In such case, this License incorporates
++the limitation as if written in the body of this License.
++
++  9. The Free Software Foundation may publish revised and/or new versions
++of the General Public License from time to time.  Such new versions will
++be similar in spirit to the present version, but may differ in detail to
++address new problems or concerns.
++
++Each version is given a distinguishing version number.  If the Program
++specifies a version number of this License which applies to it and "any
++later version", you have the option of following the terms and conditions
++either of that version or of any later version published by the Free
++Software Foundation.  If the Program does not specify a version number of
++this License, you may choose any version ever published by the Free Software
++Foundation.
++
++  10. If you wish to incorporate parts of the Program into other free
++programs whose distribution conditions are different, write to the author
++to ask for permission.  For software which is copyrighted by the Free
++Software Foundation, write to the Free Software Foundation; we sometimes
++make exceptions for this.  Our decision will be guided by the two goals
++of preserving the free status of all derivatives of our free software and
++of promoting the sharing and reuse of software generally.
++
++                          NO WARRANTY
++
++  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
++FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
++OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
++PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
++OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
++MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
++TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
++PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
++REPAIR OR CORRECTION.
++
++  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
++WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
++REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
++INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
++OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
++TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
++YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
++PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
++POSSIBILITY OF SUCH DAMAGES.
++
++                   END OF TERMS AND CONDITIONS
++
++          How to Apply These Terms to Your New Programs
++
++  If you develop a new program, and you want it to be of the greatest
++possible use to the public, the best way to achieve this is to make it
++free software which everyone can redistribute and change under these terms.
++
++  To do so, attach the following notices to the program.  It is safest
++to attach them to the start of each source file to most effectively
++convey the exclusion of warranty; and each file should have at least
++the "copyright" line and a pointer to where the full notice is found.
++
++    <one line to give the program's name and a brief idea of what it does.>
++    Copyright (C) 19yy  <name of author>
++
++    This program is free software; you can redistribute it and/or modify
++    it under the terms of the GNU General Public License as published by
++    the Free Software Foundation; either version 2 of the License, or
++    (at your option) any later version.
++
++    This program is distributed in the hope that it will be useful,
++    but WITHOUT ANY WARRANTY; without even the implied warranty of
++    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++    GNU General Public License for more details.
++
++    You should have received a copy of the GNU General Public License
++    along with this program; if not, write to the Free Software
++    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
++
++
++Also add information on how to contact you by electronic and paper mail.
++
++If the program is interactive, make it output a short notice like this
++when it starts in an interactive mode:
++
++    Gnomovision version 69, Copyright (C) 19yy name of author
++    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
++    This is free software, and you are welcome to redistribute it
++    under certain conditions; type `show c' for details.
++
++The hypothetical commands `show w' and `show c' should show the appropriate
++parts of the General Public License.  Of course, the commands you use may
++be called something other than `show w' and `show c'; they could even be
++mouse-clicks or menu items--whatever suits your program.
++
++You should also get your employer (if you work as a programmer) or your
++school, if any, to sign a "copyright disclaimer" for the program, if
++necessary.  Here is a sample; alter the names:
++
++  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
++  `Gnomovision' (which makes passes at compilers) written by James Hacker.
++
++  <signature of Ty Coon>, 1 April 1989
++  Ty Coon, President of Vice
++
++This General Public License does not permit incorporating your program into
++proprietary programs.  If your program is a subroutine library, you may
++consider it more useful to permit linking proprietary applications with the
++library.  If this is what you want to do, use the GNU Library General
++Public License instead of this License.
+diff -Naur wireshark-1.8.4/plugins/btbb/Makefile.am wireshark/plugins/btbb/Makefile.am
+--- wireshark-1.8.4/plugins/btbb/Makefile.am   1969-12-31 19:00:00.000000000 -0500
++++ wireshark/plugins/btbb/Makefile.am 2013-01-26 15:04:24.663077339 -0500
+@@ -0,0 +1,125 @@
++# Makefile.am
++# Automake file for AgentX plugin
++#
++# $Id: Makefile.am 24488 2008-02-27 16:18:30Z stig $
++#
++# Wireshark - Network traffic analyzer
++# By Gerald Combs <gerald@wireshark.org>
++# Copyright 1998 Gerald Combs
++# 
++# This program is free software; you can redistribute it and/or
++# modify it under the terms of the GNU General Public License
++# as published by the Free Software Foundation; either version 2
++# of the License, or (at your option) any later version.
++# 
++# This program is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++# GNU General Public License for more details.
++# 
++# You should have received a copy of the GNU General Public License
++# along with this program; if not, write to the Free Software
++# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
++#
++
++INCLUDES = -I$(top_srcdir) -I$(includedir)
++
++include Makefile.common
++
++#if HAVE_WARNINGS_AS_ERRORS
++#AM_CFLAGS = -Werror
++#endif
++
++plugindir = @plugindir@
++
++plugin_LTLIBRARIES = btbb.la
++btbb_la_SOURCES = \
++      plugin.c \
++      moduleinfo.h \
++      $(DISSECTOR_SRC) \
++      $(DISSECTOR_SUPPORT_SRC) \
++      $(DISSECTOR_INCLUDES)
++btbb_la_LDFLAGS = -module -avoid-version
++btbb_la_LIBADD = @PLUGIN_LIBS@
++
++# Libs must be cleared, or else libtool won't create a shared module.
++# If your module needs to be linked against any particular libraries,
++# add them here.
++LIBS =
++
++#
++# Build plugin.c, which contains the plugin version[] string, a
++# function plugin_register() that calls the register routines for all
++# protocols, and a function plugin_reg_handoff() that calls the handoff
++# registration routines for all protocols.
++#
++# We do this by scanning sources.  If that turns out to be too slow,
++# maybe we could just require every .o file to have an register routine
++# of a given name (packet-aarp.o -> proto_register_aarp, etc.).
++#
++# Formatting conventions:  The name of the proto_register_* routines an
++# proto_reg_handoff_* routines must start in column zero, or must be
++# preceded only by "void " starting in column zero, and must not be
++# inside #if.
++#
++# DISSECTOR_SRC is assumed to have all the files that need to be scanned.
++#
++# For some unknown reason, having a big "for" loop in the Makefile
++# to scan all the files doesn't work with some "make"s; they seem to
++# pass only the first few names in the list to the shell, for some
++# reason.
++#
++# Therefore, we have a script to generate the plugin.c file.
++# The shell script runs slowly, as multiple greps and seds are run
++# for each input file; this is especially slow on Windows.  Therefore,
++# if Python is present (as indicated by PYTHON being defined), we run
++# a faster Python script to do that work instead.
++#
++# The first argument is the directory in which the source files live.
++# The second argument is "plugin", to indicate that we should build
++# a plugin.c file for a plugin.
++# All subsequent arguments are the files to scan.
++#
++plugin.c: $(DISSECTOR_SRC) $(top_srcdir)/tools/make-dissector-reg \
++    $(top_srcdir)/tools/make-dissector-reg.py
++      @if test -n "$(PYTHON)"; then \
++              echo Making plugin.c with python ; \
++              $(PYTHON) $(top_srcdir)/tools/make-dissector-reg.py $(srcdir) \
++                  plugin $(DISSECTOR_SRC) ; \
++      else \
++              echo Making plugin.c with shell script ; \
++              $(top_srcdir)/tools/make-dissector-reg $(srcdir) \
++                  $(plugin_src) plugin $(DISSECTOR_SRC) ; \
++      fi
++
++#
++# Currently plugin.c can be included in the distribution because
++# we always build all protocol dissectors. We used to have to check
++# whether or not to build the snmp dissector. If we again need to
++# variably build something, making plugin.c non-portable, uncomment
++# the dist-hook line below.
++#
++# Oh, yuk.  We don't want to include "plugin.c" in the distribution, as
++# its contents depend on the configuration, and therefore we want it
++# to be built when the first "make" is done; however, Automake insists
++# on putting *all* source into the distribution.
++#
++# We work around this by having a "dist-hook" rule that deletes
++# "plugin.c", so that "dist" won't pick it up.
++#
++#dist-hook:
++#     @rm -f $(distdir)/plugin.c
++
++CLEANFILES = \
++      btbb \
++      *~
++
++MAINTAINERCLEANFILES = \
++      Makefile.in     \
++      plugin.c
++
++EXTRA_DIST = \
++      Makefile.common         \
++      Makefile.nmake          \
++      moduleinfo.nmake        \
++      plugin.rc.in
+diff -Naur wireshark-1.8.4/plugins/btbb/Makefile.common wireshark/plugins/btbb/Makefile.common
+--- wireshark-1.8.4/plugins/btbb/Makefile.common       1969-12-31 19:00:00.000000000 -0500
++++ wireshark/plugins/btbb/Makefile.common     2013-01-26 15:04:24.651077279 -0500
+@@ -0,0 +1,40 @@
++# Makefile.common for AgentX plugin
++#     Contains the stuff from Makefile.am and Makefile.nmake that is
++#     a) common to both files and
++#     b) portable between both files
++#
++# $Id: Makefile.common 23848 2007-12-12 22:10:50Z jake $
++#
++# Wireshark - Network traffic analyzer
++# By Gerald Combs <gerald@wireshark.org>
++# Copyright 1998 Gerald Combs
++#
++# This program is free software; you can redistribute it and/or
++# modify it under the terms of the GNU General Public License
++# as published by the Free Software Foundation; either version 2
++# of the License, or (at your option) any later version.
++#
++# This program is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++# GNU General Public License for more details.
++#
++# You should have received a copy of the GNU General Public License
++# along with this program; if not, write to the Free Software
++# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
++
++# the name of the plugin
++PLUGIN_NAME = btbb
++
++# the dissector sources (without any helpers)
++DISSECTOR_SRC = \
++      packet-btbb.c \
++      packet-btlmp.c
++
++# corresponding headers
++DISSECTOR_INCLUDES =
++
++# Dissector helpers. They're included in the source files in this
++# directory, but they're not dissectors themselves, i.e. they're not
++# used to generate "plugin.c".
++DISSECTOR_SUPPORT_SRC =
+diff -Naur wireshark-1.8.4/plugins/btbb/Makefile.nmake wireshark/plugins/btbb/Makefile.nmake
+--- wireshark-1.8.4/plugins/btbb/Makefile.nmake        1969-12-31 19:00:00.000000000 -0500
++++ wireshark/plugins/btbb/Makefile.nmake      2013-01-26 15:04:24.671077378 -0500
+@@ -0,0 +1,100 @@
++# Makefile.nmake
++# nmake file for Wireshark plugin
++#
++# $Id: Makefile.nmake 24520 2008-03-01 12:31:01Z jake $
++#
++
++include ..\..\config.nmake
++include moduleinfo.nmake
++
++include Makefile.common
++
++CFLAGS=/WX /DHAVE_CONFIG_H /I../.. /I../../wiretap $(GLIB_CFLAGS) \
++      /I$(PCAP_DIR)\include -D_U_="" $(LOCAL_CFLAGS)
++
++.c.obj::
++      $(CC) $(CFLAGS) -Fd.\ -c $<
++      
++LDFLAGS = $(PLUGIN_LDFLAGS)
++
++!IFDEF ENABLE_LIBWIRESHARK
++LINK_PLUGIN_WITH=..\..\epan\libwireshark.lib
++CFLAGS=/DHAVE_WIN32_LIBWIRESHARK_LIB /D_NEED_VAR_IMPORT_ $(CFLAGS)
++
++DISSECTOR_OBJECTS = $(DISSECTOR_SRC:.c=.obj)
++
++DISSECTOR_SUPPORT_OBJECTS = $(DISSECTOR_SUPPORT_SRC:.c=.obj)
++
++OBJECTS = $(DISSECTOR_OBJECTS) $(DISSECTOR_SUPPORT_OBJECTS) plugin.obj
++
++RESOURCE=$(PLUGIN_NAME).res
++
++all: $(PLUGIN_NAME).dll
++
++$(PLUGIN_NAME).rc : moduleinfo.nmake
++      sed -e s/@PLUGIN_NAME@/$(PLUGIN_NAME)/ \
++      -e s/@RC_MODULE_VERSION@/$(RC_MODULE_VERSION)/ \
++      -e s/@RC_VERSION@/$(RC_VERSION)/ \
++      -e s/@MODULE_VERSION@/$(MODULE_VERSION)/ \
++      -e s/@PACKAGE@/$(PACKAGE)/ \
++      -e s/@VERSION@/$(VERSION)/ \
++      -e s/@MSVC_VARIANT@/$(MSVC_VARIANT)/ \
++      < plugin.rc.in > $@
++
++$(PLUGIN_NAME).dll $(PLUGIN_NAME).exp $(PLUGIN_NAME).lib : $(OBJECTS) $(LINK_PLUGIN_WITH) $(RESOURCE)
++      link -dll /out:$(PLUGIN_NAME).dll $(LDFLAGS) $(OBJECTS) $(LINK_PLUGIN_WITH) \
++      $(GLIB_LIBS) $(RESOURCE)
++
++#
++# Build plugin.c, which contains the plugin version[] string, a
++# function plugin_register() that calls the register routines for all
++# protocols, and a function plugin_reg_handoff() that calls the handoff
++# registration routines for all protocols.
++#
++# We do this by scanning sources.  If that turns out to be too slow,
++# maybe we could just require every .o file to have an register routine
++# of a given name (packet-aarp.o -> proto_register_aarp, etc.).
++#
++# Formatting conventions:  The name of the proto_register_* routines an
++# proto_reg_handoff_* routines must start in column zero, or must be
++# preceded only by "void " starting in column zero, and must not be
++# inside #if.
++#
++# DISSECTOR_SRC is assumed to have all the files that need to be scanned.
++#
++# For some unknown reason, having a big "for" loop in the Makefile
++# to scan all the files doesn't work with some "make"s; they seem to
++# pass only the first few names in the list to the shell, for some
++# reason.
++#
++# Therefore, we have a script to generate the plugin.c file.
++# The shell script runs slowly, as multiple greps and seds are run
++# for each input file; this is especially slow on Windows.  Therefore,
++# if Python is present (as indicated by PYTHON being defined), we run
++# a faster Python script to do that work instead.
++#
++# The first argument is the directory in which the source files live.
++# The second argument is "plugin", to indicate that we should build
++# a plugin.c file for a plugin.
++# All subsequent arguments are the files to scan.
++#
++!IFDEF PYTHON
++plugin.c: $(DISSECTOR_SRC) moduleinfo.h ../../tools/make-dissector-reg.py
++      @echo Making plugin.c (using python)
++      @$(PYTHON) "../../tools/make-dissector-reg.py" . plugin $(DISSECTOR_SRC)
++!ELSE
++plugin.c: $(DISSECTOR_SRC) moduleinfo.h ../../tools/make-dissector-reg
++      @echo Making plugin.c (using sh)
++      @$(SH) ../../tools/make-dissector-reg . plugin $(DISSECTOR_SRC)
++!ENDIF
++
++!ENDIF
++
++clean:
++      rm -f $(OBJECTS) $(RESOURCE) plugin.c *.pdb \
++          $(PLUGIN_NAME).dll $(PLUGIN_NAME).dll.manifest $(PLUGIN_NAME).lib \
++          $(PLUGIN_NAME).exp $(PLUGIN_NAME).rc 
++
++distclean: clean
++
++maintainer-clean: distclean
+diff -Naur wireshark-1.8.4/plugins/btbb/moduleinfo.h wireshark/plugins/btbb/moduleinfo.h
+--- wireshark-1.8.4/plugins/btbb/moduleinfo.h  1969-12-31 19:00:00.000000000 -0500
++++ wireshark/plugins/btbb/moduleinfo.h        2013-01-26 15:04:24.663077339 -0500
+@@ -0,0 +1,17 @@
++/* Included *after* config.h, in order to re-define these macros */
++
++#ifdef PACKAGE
++#undef PACKAGE
++#endif
++
++/* Name of package */
++#define PACKAGE "btbb"
++
++
++#ifdef VERSION
++#undef VERSION
++#endif
++
++/* Version number of package */
++#define VERSION "0.0.1"
++
+diff -Naur wireshark-1.8.4/plugins/btbb/moduleinfo.nmake wireshark/plugins/btbb/moduleinfo.nmake
+--- wireshark-1.8.4/plugins/btbb/moduleinfo.nmake      1969-12-31 19:00:00.000000000 -0500
++++ wireshark/plugins/btbb/moduleinfo.nmake    2013-01-26 15:04:24.663077339 -0500
+@@ -0,0 +1,28 @@
++#
++# $Id: moduleinfo.nmake 20155 2006-12-19 22:22:34Z jake $
++#
++
++# The name
++PACKAGE=btbb
++
++# The version
++MODULE_VERSION_MAJOR=0
++MODULE_VERSION_MINOR=0
++MODULE_VERSION_MICRO=0
++MODULE_VERSION_EXTRA=1
++
++#
++# The RC_VERSION should be comma-separated, not dot-separated, 
++# as per Graham Bloice's message in
++#
++#     http://www.ethereal.com/lists/ethereal-dev/200303/msg00283.html
++#
++# "The RC_VERSION variable in config.nmake should be comma separated. 
++# This allows the resources to be built correctly and the version
++# number to be correctly displayed in the explorer properties dialog
++# for the executables, and XP's tooltip, rather than 0.0.0.0."
++#
++
++MODULE_VERSION=$(MODULE_VERSION_MAJOR).$(MODULE_VERSION_MINOR).$(MODULE_VERSION_MICRO).$(MODULE_VERSION_EXTRA)
++RC_MODULE_VERSION=$(MODULE_VERSION_MAJOR),$(MODULE_VERSION_MINOR),$(MODULE_VERSION_MICRO),$(MODULE_VERSION_EXTRA)
++
+diff -Naur wireshark-1.8.4/plugins/btbb/packet-btbb.c wireshark/plugins/btbb/packet-btbb.c
+--- wireshark-1.8.4/plugins/btbb/packet-btbb.c 1969-12-31 19:00:00.000000000 -0500
++++ wireshark/plugins/btbb/packet-btbb.c       2013-01-26 15:04:24.663077339 -0500
+@@ -0,0 +1,579 @@
++/* packet-btbb.c
++ * Routines for Bluetooth baseband dissection
++ * Copyright 2009, Michael Ossmann <mike@ossmann.com>
++ *
++ * $Id$
++ *
++ * Wireshark - Network traffic analyzer
++ * By Gerald Combs <gerald@wireshark.org>
++ * Copyright 1998 Gerald Combs
++ *
++ * This program is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU General Public License
++ * as published by the Free Software Foundation; either version 2
++ * of the License, or (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
++ */
++
++#ifdef HAVE_CONFIG_H
++# include "config.h"
++#endif
++
++#include <config.h> /* needed for epan/gcc-4.x */
++#include <epan/packet.h>
++#include <epan/prefs.h>
++
++/* function prototypes */
++void proto_reg_handoff_btbb(void);
++
++/* initialize the protocol and registered fields */
++static int proto_btbb = -1;
++static int hf_btbb_meta = -1;
++static int hf_btbb_dir = -1;
++static int hf_btbb_clk = -1;
++static int hf_btbb_channel = -1;
++static int hf_btbb_addrbits = -1;
++static int hf_btbb_clkbits = -1;
++static int hf_btbb_pkthdr = -1;
++static int hf_btbb_ltaddr = -1;
++static int hf_btbb_type = -1;
++static int hf_btbb_flags = -1;
++static int hf_btbb_flow = -1;
++static int hf_btbb_arqn = -1;
++static int hf_btbb_seqn = -1;
++static int hf_btbb_hec = -1;
++static int hf_btbb_payload = -1;
++static int hf_btbb_pldhdr = -1;
++static int hf_btbb_llid = -1;
++static int hf_btbb_pldflow = -1;
++static int hf_btbb_length = -1;
++static int hf_btbb_pldbody = -1;
++static int hf_btbb_crc = -1;
++static int hf_btbb_fhs_parity = -1;
++static int hf_btbb_fhs_lap = -1;
++static int hf_btbb_fhs_eir = -1;
++static int hf_btbb_fhs_sr = -1;
++static int hf_btbb_fhs_uap = -1;
++static int hf_btbb_fhs_nap = -1;
++static int hf_btbb_fhs_class = -1;
++static int hf_btbb_fhs_ltaddr = -1;
++static int hf_btbb_fhs_clk = -1;
++static int hf_btbb_fhs_psmode = -1;
++
++/* field values */
++static const true_false_string direction = {
++      "Slave to Master",
++      "Master to Slave"
++};
++
++static const true_false_string clock_bits = {
++      "27",
++      "6"
++};
++
++static const true_false_string address_bits = {
++      "48 (NAP known)",
++      "32 (NAP unknown)"
++};
++
++static const value_string packet_types[] = {
++      /* generic names for unknown logical transport */
++      { 0x0, "NULL" },
++      { 0x1, "POLL" },
++      { 0x2, "FHS" },
++      { 0x3, "DM1" },
++      { 0x4, "DH1/2-DH1" },
++      { 0x5, "HV1" },
++      { 0x6, "HV2/2-EV3" },
++      { 0x7, "HV3/EV3/3-EV3" },
++      { 0x8, "DV/3-DH1" },
++      { 0x9, "AUX1" },
++      { 0xa, "DM3/2-DH3" },
++      { 0xb, "DH3/3-DH3" },
++      { 0xc, "EV4/2-EV5" },
++      { 0xd, "EV5/3-EV5" },
++      { 0xe, "DM5/2-DH5" },
++      { 0xf, "DH5/3-DH5" },
++      { 0, NULL }
++};
++
++static const value_string sr_modes[] = {
++      { 0x0, "R0" },
++      { 0x1, "R1" },
++      { 0x2, "R2" },
++      { 0x3, "Reserved" },
++      { 0, NULL }
++};
++
++static const range_string ps_modes[] = {
++      { 0x0, 0x0, "Mandatory scan mode" },
++      { 0x1, 0x7, "Reserved" },
++      { 0, 0, NULL }
++};
++
++static const value_string llid_codes[] = {
++      { 0x0, "undefined" },
++      { 0x1, "Continuation fragment of an L2CAP message (ACL-U)" },
++      { 0x2, "Start of an L2CAP message or no fragmentation (ACL-U)" },
++      { 0x3, "LMP message (ACL-C)" },
++      { 0, NULL }
++};
++
++/* initialize the subtree pointers */
++static gint ett_btbb = -1;
++static gint ett_btbb_meta = -1;
++static gint ett_btbb_pkthdr = -1;
++static gint ett_btbb_flags = -1;
++static gint ett_btbb_payload = -1;
++static gint ett_btbb_pldhdr = -1;
++
++/* subdissectors */
++static dissector_handle_t btlmp_handle = NULL;
++static dissector_handle_t btl2cap_handle = NULL;
++
++/* packet header flags */
++static const int *flag_fields[] = {
++      &hf_btbb_flow,
++      &hf_btbb_arqn,
++      &hf_btbb_seqn,
++      NULL
++};
++
++/* one byte payload header */
++int
++dissect_payload_header1(proto_tree *tree, tvbuff_t *tvb, int offset)
++{
++      proto_item *hdr_item;
++      proto_tree *hdr_tree;
++
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 1);
++
++      hdr_item = proto_tree_add_item(tree, hf_btbb_pldhdr, tvb, offset, 1, TRUE);
++      hdr_tree = proto_item_add_subtree(hdr_item, ett_btbb_pldhdr);
++
++      proto_tree_add_item(hdr_tree, hf_btbb_llid, tvb, offset, 1, TRUE);
++      proto_tree_add_item(hdr_tree, hf_btbb_pldflow, tvb, offset, 1, TRUE);
++      proto_tree_add_item(hdr_tree, hf_btbb_length, tvb, offset, 1, TRUE);
++
++      /* payload length */
++      return tvb_get_guint8(tvb, offset) >> 3;
++}
++
++void
++dissect_fhs(proto_tree *tree, tvbuff_t *tvb, int offset)
++{
++      proto_item *fhs_item;
++      proto_tree *fhs_tree;
++
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) == 20);
++
++      fhs_item = proto_tree_add_item(tree, hf_btbb_payload, tvb, offset, -1, TRUE);
++      fhs_tree = proto_item_add_subtree(fhs_item, ett_btbb_payload);
++
++      proto_tree_add_item(fhs_tree, hf_btbb_fhs_parity, tvb, offset, 5, TRUE);
++      offset += 4;
++
++      proto_tree_add_item(fhs_tree, hf_btbb_fhs_lap, tvb, offset, 4, TRUE);
++      offset += 3;
++
++      proto_tree_add_item(fhs_tree, hf_btbb_fhs_eir, tvb, offset, 1, TRUE);
++      /* skipping 1 undefined bit */
++      proto_tree_add_item(fhs_tree, hf_btbb_fhs_sr, tvb, offset, 1, TRUE);
++      /* skipping 2 reserved bits */
++      offset += 1;
++
++      proto_tree_add_item(fhs_tree, hf_btbb_fhs_uap, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(fhs_tree, hf_btbb_fhs_nap, tvb, offset, 2, TRUE);
++      offset += 2;
++
++      proto_tree_add_item(fhs_tree, hf_btbb_fhs_class, tvb, offset, 3, TRUE);
++      offset += 3;
++
++      proto_tree_add_item(fhs_tree, hf_btbb_fhs_ltaddr, tvb, offset, 1, TRUE);
++      proto_tree_add_item(fhs_tree, hf_btbb_fhs_clk, tvb, offset, 4, TRUE);
++      offset += 3;
++
++      proto_tree_add_item(fhs_tree, hf_btbb_fhs_psmode, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(fhs_tree, hf_btbb_crc, tvb, offset, 2, TRUE);
++      offset += 2;
++}
++
++void
++dissect_dm1(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, int offset)
++{
++      int len;        /* payload length indicated by payload header */
++      int llid;       /* logical link id */
++      int l2len;      /* length indicated by l2cap header */
++      proto_item *dm1_item;
++      proto_tree *dm1_tree;
++      tvbuff_t *pld_tvb;
++
++      /*
++       * FIXME
++       * I'm probably doing a terrible, terrible thing here, but it gets my
++       * initial test cases working.
++       */
++      guint16 fake_acl_data;
++
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 3);
++
++      dm1_item = proto_tree_add_item(tree, hf_btbb_payload, tvb, offset, -1, TRUE);
++      dm1_tree = proto_item_add_subtree(dm1_item, ett_btbb_payload);
++
++      len = dissect_payload_header1(dm1_tree, tvb, offset);
++      llid = tvb_get_guint8(tvb, offset) & 0x3;
++      offset += 1;
++
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) == len + 2);
++
++      if (llid == 3 && btlmp_handle) {
++              /* LMP */
++              pld_tvb = tvb_new_subset(tvb, offset, len, len);
++              call_dissector(btlmp_handle, pld_tvb, pinfo, dm1_tree);
++      } else if (llid == 2 && btl2cap_handle) {
++              /* unfragmented L2CAP or start of fragment */
++              l2len = tvb_get_letohs(tvb, offset);
++              if (l2len + 4 == len) {
++                      /* unfragmented */
++                      pinfo->private_data = &fake_acl_data;
++                      pld_tvb = tvb_new_subset(tvb, offset, len, len);
++                      call_dissector(btl2cap_handle, pld_tvb, pinfo, dm1_tree);
++              } else {
++                      /* start of fragment */
++                      proto_tree_add_item(dm1_tree, hf_btbb_pldbody, tvb, offset, len, TRUE);
++              }
++      } else {
++              proto_tree_add_item(dm1_tree, hf_btbb_pldbody, tvb, offset, len, TRUE);
++      }
++      offset += len;
++
++      proto_tree_add_item(dm1_tree, hf_btbb_crc, tvb, offset, 2, TRUE);
++      offset += 2;
++}
++
++/* dissect a packet */
++static int
++dissect_btbb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
++{
++      proto_item *btbb_item, *meta_item, *pkthdr_item, *pld_item;
++      proto_tree *btbb_tree, *meta_tree, *pkthdr_tree;
++      int offset;
++      guint8 type;
++      char *info;
++
++      /* sanity check: length */
++      if (tvb_length(tvb) > 0 && tvb_length(tvb) < 9)
++              /* bad length: look for a different dissector */
++              return 0;
++
++      /* maybe should verify HEC */
++
++      /* make entries in protocol column and info column on summary display */
++      if (check_col(pinfo->cinfo, COL_PROTOCOL))
++              col_set_str(pinfo->cinfo, COL_PROTOCOL, "Bluetooth");
++
++      if (tvb_length(tvb) == 0) {
++              info = "ID";
++      } else {
++              type = (tvb_get_guint8(tvb, 6) >> 3) & 0x0f;
++              info = match_strval(type, packet_types);
++      }
++
++      if (check_col(pinfo->cinfo, COL_INFO)) {
++              col_clear(pinfo->cinfo, COL_INFO);
++              col_add_str(pinfo->cinfo, COL_INFO, info);
++      }
++
++      /* see if we are being asked for details */
++      if (tree) {
++
++              /* create display subtree for the protocol */
++              offset = 0;
++              btbb_item = proto_tree_add_item(tree, proto_btbb, tvb, offset, -1, TRUE);
++              btbb_tree = proto_item_add_subtree(btbb_item, ett_btbb);
++
++              /* ID packets have no header, no payload */
++              if (tvb_length(tvb) == 0)
++                      return 1;
++
++              /* meta data */
++              meta_item = proto_tree_add_item(btbb_tree, hf_btbb_meta, tvb, offset, 3, TRUE);
++              meta_tree = proto_item_add_subtree(meta_item, ett_btbb_meta);
++
++              proto_tree_add_item(meta_tree, hf_btbb_dir, tvb, offset, 1, TRUE);
++              proto_tree_add_item(meta_tree, hf_btbb_clk, tvb, offset, 4, TRUE);
++              offset += 4;
++
++              proto_tree_add_item(meta_tree, hf_btbb_channel, tvb, offset, 1, TRUE);
++              offset += 1;
++
++              proto_tree_add_item(meta_tree, hf_btbb_clkbits, tvb, offset, 1, TRUE);
++              proto_tree_add_item(meta_tree, hf_btbb_addrbits, tvb, offset, 1, TRUE);
++              offset += 1;
++
++              /* packet header */
++              pkthdr_item = proto_tree_add_item(btbb_tree, hf_btbb_pkthdr, tvb, offset, 3, TRUE);
++              pkthdr_tree = proto_item_add_subtree(pkthdr_item, ett_btbb_pkthdr);
++
++              proto_tree_add_item(pkthdr_tree, hf_btbb_ltaddr, tvb, offset, 1, TRUE);
++              proto_tree_add_item(pkthdr_tree, hf_btbb_type, tvb, offset, 1, TRUE);
++              offset += 1;
++              proto_tree_add_bitmask(pkthdr_tree, tvb, offset, hf_btbb_flags,
++                      ett_btbb_flags, flag_fields, TRUE);
++              offset += 1;
++              proto_tree_add_item(pkthdr_tree, hf_btbb_hec, tvb, offset, 1, TRUE);
++              offset += 1;
++
++              /* payload */
++              switch (type) {
++              case 0x0: /* NULL */
++              case 0x1: /* POLL */
++                      break;
++              case 0x2: /* FHS */
++                      dissect_fhs(btbb_tree, tvb, offset);
++                      break;
++              case 0x3: /* DM1 */
++                      dissect_dm1(btbb_tree, tvb, pinfo, offset);
++                      break;
++              case 0x4: /* DH1/2-DH1 */
++                      dissect_dm1(btbb_tree, tvb, pinfo, offset);
++                      break;
++              case 0x5: /* HV1 */
++              case 0x6: /* HV2/2-EV3 */
++              case 0x7: /* HV3/EV3/3-EV3 */
++              case 0x8: /* DV/3-DH1 */
++              case 0x9: /* AUX1 */
++              case 0xa: /* DM3/2-DH3 */
++              case 0xb: /* DH3/3-DH3 */
++              case 0xc: /* EV4/2-EV5 */
++              case 0xd: /* EV5/3-EV5 */
++              case 0xe: /* DM5/2-DH5 */
++              case 0xf: /* DH5/3-DH5 */
++                      pld_item = proto_tree_add_item(btbb_tree, hf_btbb_payload, tvb, offset, -1, TRUE);
++                      break;
++              default:
++                      break;
++              }
++      }
++
++      /* Return the amount of data this dissector was able to dissect */
++      return tvb_length(tvb);
++}
++
++/* register the protocol with Wireshark */
++void
++proto_register_btbb(void)
++{
++
++      /* list of fields */
++      static hf_register_info hf[] = {
++              { &hf_btbb_meta,
++                      { "Meta Data", "btbb.meta",
++                      FT_NONE, BASE_NONE, NULL, 0x0,
++                      "Meta Data About the Packet", HFILL }
++              },
++              { &hf_btbb_dir,
++                      { "Direction", "btbb.dir",
++                      FT_BOOLEAN, BASE_NONE, TFS(&direction), 0x01,
++                      "Direction of Transmission", HFILL }
++              },
++              { &hf_btbb_clk,
++                      { "CLK", "btbb.clk",
++                      FT_UINT32, BASE_HEX, NULL, 0x0,
++                      "Clock bits 1 through 27", HFILL }
++              },
++              { &hf_btbb_channel,
++                      { "Channel", "btbb.channel",
++                      FT_UINT8, BASE_DEC, NULL, 0x0,
++                      "Channel (0-78)", HFILL }
++              },
++              { &hf_btbb_clkbits,
++                      { "Known Clock Bits ", "btbb.clkbits",
++                      FT_BOOLEAN, BASE_NONE, TFS(&clock_bits), 0x01,
++                      "Number of Known Master CLK Bits (6 or 27)", HFILL }
++              },
++              { &hf_btbb_addrbits,
++                      { "Known Address Bits ", "btbb.addrbits",
++                      FT_BOOLEAN, BASE_NONE, TFS(&address_bits), 0x02,
++                      "Number of Known Bits of BD_ADDR (32 or 48)", HFILL }
++              },
++              { &hf_btbb_pkthdr,
++                      { "Packet Header", "btbb.pkthdr",
++                      FT_NONE, BASE_NONE, NULL, 0x0,
++                      "Bluetooth Baseband Packet Header", HFILL }
++              },
++              { &hf_btbb_ltaddr,
++                      { "LT_ADDR", "btbb.lt_addr",
++                      FT_UINT8, BASE_HEX, NULL, 0x07,
++                      "Logical Transport Address", HFILL }
++              },
++              { &hf_btbb_type,
++                      { "TYPE", "btbb.type",
++                      FT_UINT8, BASE_HEX, VALS(packet_types), 0x78,
++                      "Packet Type", HFILL }
++              },
++              { &hf_btbb_flags,
++                      { "Flags", "btbb.flags",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "Packet Header Flags", HFILL }
++              },
++              { &hf_btbb_flow,
++                      { "FLOW", "btbb.flow",
++                      FT_BOOLEAN, 8, NULL, 0x01,
++                      "Flow control indication", HFILL }
++              },
++              { &hf_btbb_arqn,
++                      { "ARQN", "btbb.arqn",
++                      FT_BOOLEAN, 8, NULL, 0x02,
++                      "Acknowledgment indication", HFILL }
++              },
++              { &hf_btbb_seqn,
++                      { "SEQN", "btbb.seqn",
++                      FT_BOOLEAN, 8, NULL, 0x04,
++                      "Sequence number", HFILL }
++              },
++              { &hf_btbb_hec,
++                      { "HEC", "btbb.lt_addr",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "Header Error Check", HFILL }
++              },
++              { &hf_btbb_payload,
++                      { "Payload", "btbb.payload",
++                      FT_NONE, BASE_NONE, NULL, 0x0,
++                      "Payload", HFILL }
++              },
++              { &hf_btbb_llid,
++                      { "LLID", "btbb.llid",
++                      FT_UINT8, BASE_HEX, VALS(llid_codes), 0x03,
++                      "Logical Link ID", HFILL }
++              },
++              { &hf_btbb_pldflow,
++                      { "Flow", "btbb.flow",
++                      FT_BOOLEAN, BASE_NONE, NULL, 0x04,
++                      "Payload Flow indication", HFILL }
++              },
++              { &hf_btbb_length,
++                      { "Length", "btbb.length",
++                      FT_UINT8, BASE_DEC, NULL, 0xf8,
++                      "Payload Length", HFILL }
++              },
++              { &hf_btbb_pldhdr,
++                      { "Payload Header", "btbb.pldhdr",
++                      FT_NONE, BASE_NONE, NULL, 0x0,
++                      "Payload Header", HFILL }
++              },
++              { &hf_btbb_pldbody,
++                      { "Payload Body", "btbb.pldbody",
++                      FT_BYTES, BASE_NONE, NULL, 0x0,
++                      "Payload Body", HFILL }
++              },
++              { &hf_btbb_crc,
++                      { "CRC", "btbb.crc",
++                      FT_UINT16, BASE_HEX, NULL, 0x0,
++                      "Payload CRC", HFILL }
++              },
++              { &hf_btbb_fhs_parity,
++                      { "Parity", "btbb.parity",
++                      /* FIXME not sure why this mask doesn't have an effect.  bug? */
++                      FT_UINT64, BASE_HEX, NULL, 0x00000003ffffffff,
++                      "LAP parity", HFILL }
++              },
++              { &hf_btbb_fhs_lap,
++                      { "LAP", "btbb.lap",
++                      FT_UINT24, BASE_HEX, NULL, 0x03fffffc,
++                      "Lower Address Part", HFILL }
++              },
++              { &hf_btbb_fhs_eir,
++                      { "EIR", "btbb.eir",
++                      FT_BOOLEAN, BASE_NONE, NULL, 0x04,
++                      "Extended Inquiry Response packet may follow", HFILL }
++              },
++              { &hf_btbb_fhs_sr,
++                      { "SR", "btbb.sr",
++                      FT_UINT8, BASE_HEX, VALS(sr_modes), 0x30,
++                      "Scan Repetition", HFILL }
++              },
++              { &hf_btbb_fhs_uap,
++                      { "UAP", "btbb.uap",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "Upper Address Part", HFILL }
++              },
++              { &hf_btbb_fhs_nap,
++                      { "NAP", "btbb.nap",
++                      FT_UINT16, BASE_HEX, NULL, 0x0,
++                      "Non-Significant Address Part", HFILL }
++              },
++              { &hf_btbb_fhs_class, /* FIXME break out further */
++                      { "Class of Device", "btbb.class",
++                      FT_UINT24, BASE_HEX, NULL, 0x0,
++                      "Class of Device", HFILL }
++              },
++              { &hf_btbb_fhs_ltaddr,
++                      { "LT_ADDR", "btbb.lt_addr",
++                      FT_UINT8, BASE_HEX, NULL, 0x07,
++                      "Logical Transport Address", HFILL }
++              },
++              { &hf_btbb_fhs_clk,
++                      { "CLK", "btbb.clk",
++                      FT_UINT32, BASE_HEX, NULL, 0x1ffffff8,
++                      "Clock bits 2 through 27", HFILL }
++              },
++              { &hf_btbb_fhs_psmode,
++                      { "Page Scan Mode", "btbb.psmode",
++                      FT_UINT8, BASE_HEX, RVALS(ps_modes), 0xe0,
++                      "Page Scan Mode", HFILL }
++              },
++      };
++
++      /* protocol subtree arrays */
++      static gint *ett[] = {
++              &ett_btbb,
++              &ett_btbb_meta,
++              &ett_btbb_pkthdr,
++              &ett_btbb_flags,
++              &ett_btbb_payload,
++              &ett_btbb_pldhdr,
++      };
++
++      /* register the protocol name and description */
++      proto_btbb = proto_register_protocol(
++              "Bluetooth Baseband",   /* full name */
++              "btbb",                 /* short name */
++              "btbb"                  /* abbreviation (e.g. for filters) */
++              );
++
++      /* register the header fields and subtrees used */
++      proto_register_field_array(proto_btbb, hf, array_length(hf));
++      proto_register_subtree_array(ett, array_length(ett));
++}
++
++void
++proto_reg_handoff_btbb(void)
++{
++      static gboolean inited = FALSE;
++
++      if (!inited) {
++              dissector_handle_t btbb_handle;
++
++              btbb_handle = new_create_dissector_handle(dissect_btbb, proto_btbb);
++              /* hijacking this ethertype */
++              dissector_add("ethertype", 0xFFF0, btbb_handle);
++
++              btlmp_handle = find_dissector("btlmp");
++              btl2cap_handle = find_dissector("btl2cap");
++
++              inited = TRUE;
++      }
++}
+diff -Naur wireshark-1.8.4/plugins/btbb/packet-btlmp.c wireshark/plugins/btbb/packet-btlmp.c
+--- wireshark-1.8.4/plugins/btbb/packet-btlmp.c        1969-12-31 19:00:00.000000000 -0500
++++ wireshark/plugins/btbb/packet-btlmp.c      2013-01-26 15:04:24.667077358 -0500
+@@ -0,0 +1,2878 @@
++/* packet-btlmp.c
++ * Routines for Bluetooth LMP dissection
++ * Copyright 2009, Michael Ossmann <mike@ossmann.com>
++ *
++ * $Id$
++ *
++ * Wireshark - Network traffic analyzer
++ * By Gerald Combs <gerald@wireshark.org>
++ * Copyright 1998 Gerald Combs
++ *
++ * This program is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU General Public License
++ * as published by the Free Software Foundation; either version 2
++ * of the License, or (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
++ */
++
++#ifdef HAVE_CONFIG_H
++# include "config.h"
++#endif
++
++#include <config.h> /* needed for epan/gcc-4.x */
++#include <epan/packet.h>
++#include <epan/prefs.h>
++
++/* LMP opcodes */
++#define LMP_NAME_REQ                     1
++#define LMP_NAME_RES                     2
++#define LMP_ACCEPTED                     3
++#define LMP_NOT_ACCEPTED                 4
++#define LMP_CLKOFFSET_REQ                5
++#define LMP_CLKOFFSET_RES                6
++#define LMP_DETACH                       7
++#define LMP_IN_RAND                      8
++#define LMP_COMB_KEY                     9
++#define LMP_UNIT_KEY                     10
++#define LMP_AU_RAND                      11
++#define LMP_SRES                         12
++#define LMP_TEMP_RAND                    13
++#define LMP_TEMP_KEY                     14
++#define LMP_ENCRYPTION_MODE_REQ          15
++#define LMP_ENCRYPTION_KEY_SIZE_REQ      16
++#define LMP_START_ENCRYPTION_REQ         17
++#define LMP_STOP_ENCRYPTION_REQ          18
++#define LMP_SWITCH_REQ                   19
++#define LMP_HOLD                         20
++#define LMP_HOLD_REQ                     21
++#define LMP_SNIFF_REQ                    23
++#define LMP_UNSNIFF_REQ                  24
++#define LMP_PARK_REQ                     25
++#define LMP_SET_BROADCAST_SCAN_WINDOW    27
++#define LMP_MODIFY_BEACON                28
++#define LMP_UNPARK_BD_ADDR_REQ           29
++#define LMP_UNPARK_PM_ADDR_REQ           30
++#define LMP_INCR_POWER_REQ               31
++#define LMP_DECR_POWER_REQ               32
++#define LMP_MAX_POWER                    33
++#define LMP_MIN_POWER                    34
++#define LMP_AUTO_RATE                    35
++#define LMP_PREFERRED_RATE               36
++#define LMP_VERSION_REQ                  37
++#define LMP_VERSION_RES                  38
++#define LMP_FEATURES_REQ                 39
++#define LMP_FEATURES_RES                 40
++#define LMP_QUALITY_OF_SERVICE           41
++#define LMP_QUALITY_OF_SERVICE_REQ       42
++#define LMP_SCO_LINK_REQ                 43
++#define LMP_REMOVE_SCO_LINK_REQ          44
++#define LMP_MAX_SLOT                     45
++#define LMP_MAX_SLOT_REQ                 46
++#define LMP_TIMING_ACCURACY_REQ          47
++#define LMP_TIMING_ACCURACY_RES          48
++#define LMP_SETUP_COMPLETE               49
++#define LMP_USE_SEMI_PERMANENT_KEY       50
++#define LMP_HOST_CONNECTION_REQ          51
++#define LMP_SLOT_OFFSET                  52
++#define LMP_PAGE_MODE_REQ                53
++#define LMP_PAGE_SCAN_MODE_REQ           54
++#define LMP_SUPERVISION_TIMEOUT          55
++#define LMP_TEST_ACTIVATE                56
++#define LMP_TEST_CONTROL                 57
++#define LMP_ENCRYPTION_KEY_SIZE_MASK_REQ 58
++#define LMP_ENCRYPTION_KEY_SIZE_MASK_RES 59
++#define LMP_SET_AFH                      60
++#define LMP_ENCAPSULATED_HEADER          61
++#define LMP_ENCAPSULATED_PAYLOAD         62
++#define LMP_SIMPLE_PAIRING_CONFIRM       63
++#define LMP_SIMPLE_PAIRING_NUMBER        64
++#define LMP_DHKEY_CHECK                  65
++#define LMP_ESCAPE_1                     124
++#define LMP_ESCAPE_2                     125
++#define LMP_ESCAPE_3                     126
++#define LMP_ESCAPE_4                     127
++
++/* LMP extended opcodes */
++#define LMP_ACCEPTED_EXT               1
++#define LMP_NOT_ACCEPTED_EXT           2
++#define LMP_FEATURES_REQ_EXT           3
++#define LMP_FEATURES_RES_EXT           4
++#define LMP_PACKET_TYPE_TABLE_REQ      11
++#define LMP_ESCO_LINK_REQ              12
++#define LMP_REMOVE_ESCO_LINK_REQ       13
++#define LMP_CHANNEL_CLASSIFICATION_REQ 16
++#define LMP_CHANNEL_CLASSIFICATION     17
++#define LMP_SNIFF_SUBRATING_REQ        21
++#define LMP_SNIFF_SUBRATING_RES        22
++#define LMP_PAUSE_ENCRYPTION_REQ       23
++#define LMP_RESUME_ENCRYPTION_REQ      24
++#define LMP_IO_CAPABILITY_REQ          25
++#define LMP_IO_CAPABILITY_RES          26
++#define LMP_NUMERIC_COMPARISON_FAILED  27
++#define LMP_PASSKEY_FAILED             28
++#define LMP_OOB_FAILED                 29
++#define LMP_KEYPRESS_NOTIFICATION      30
++#define LMP_POWER_CONTROL_REQ          31
++#define LMP_POWER_CONTROL_RES          32
++
++/* initialize the protocol and registered fields */
++static int proto_btlmp = -1;
++static int hf_lmp_accscheme = -1;
++static int hf_lmp_afhchmap = -1;
++static int hf_lmp_afhclass = -1;
++static int hf_lmp_afhinst = -1;
++static int hf_lmp_afhmaxintvl = -1;
++static int hf_lmp_afhminintvl = -1;
++static int hf_lmp_afhmode = -1;
++static int hf_lmp_afhrptmode = -1;
++static int hf_lmp_airmode = -1;
++static int hf_lmp_araddr = -1;
++static int hf_lmp_authreqs = -1;
++static int hf_lmp_authres = -1;
++static int hf_lmp_bdaddr = -1;
++static int hf_lmp_bdaddr1 = -1;
++static int hf_lmp_bdaddr2 = -1;
++static int hf_lmp_bsw = -1;
++static int hf_lmp_clkoffset = -1;
++static int hf_lmp_commit = -1;
++static int hf_lmp_confirm = -1;
++static int hf_lmp_compid = -1;
++static int hf_lmp_cryptmode = -1;
++static int hf_lmp_daccess = -1;
++static int hf_lmp_db = -1;
++static int hf_lmp_dbsleep = -1;
++static int hf_lmp_deltab = -1;
++static int hf_lmp_desco = -1;
++static int hf_lmp_drift = -1;
++static int hf_lmp_dsco = -1;
++static int hf_lmp_dsniff = -1;
++static int hf_lmp_encdata = -1;
++static int hf_lmp_enclen = -1;
++static int hf_lmp_encmaj = -1;
++static int hf_lmp_encmin = -1;
++static int hf_lmp_eop = -1;
++static int hf_lmp_eopinre = -1;
++static int hf_lmp_escolenms = -1;
++static int hf_lmp_escolensm = -1;
++static int hf_lmp_escotypems = -1;
++static int hf_lmp_escotypesm = -1;
++static int hf_lmp_err = -1;
++static int hf_lmp_escohdl = -1;
++static int hf_lmp_escoltaddr = -1;
++static int hf_lmp_features = -1;
++static int hf_lmp_fpage = -1;
++static int hf_lmp_htime = -1;
++static int hf_lmp_hinst = -1;
++static int hf_lmp_hopmode = -1;
++static int hf_lmp_iocaps = -1;
++static int hf_lmp_jitter = -1;
++static int hf_lmp_key = -1;
++static int hf_lmp_keysz = -1;
++static int hf_lmp_ksmask = -1;
++static int hf_lmp_ltaddr1 = -1;
++static int hf_lmp_ltaddr2 = -1;
++static int hf_lmp_ltaddr3 = -1;
++static int hf_lmp_ltaddr4 = -1;
++static int hf_lmp_ltaddr5 = -1;
++static int hf_lmp_ltaddr6 = -1;
++static int hf_lmp_ltaddr7 = -1;
++static int hf_lmp_maccess = -1;
++static int hf_lmp_maxslots = -1;
++static int hf_lmp_maxsp = -1;
++static int hf_lmp_maxss = -1;
++static int hf_lmp_minsmt = -1;
++static int hf_lmp_naccslots = -1;
++static int hf_lmp_namefrag = -1;
++static int hf_lmp_namelen = -1;
++static int hf_lmp_nameoffset = -1;
++static int hf_lmp_nb = -1;
++static int hf_lmp_nbc = -1;
++static int hf_lmp_nbsleep = -1;
++static int hf_lmp_negstate = -1;
++static int hf_lmp_nonce = -1;
++static int hf_lmp_nottype = -1;
++static int hf_lmp_npoll = -1;
++static int hf_lmp_oobauthdata = -1;
++static int hf_lmp_op = -1;
++static int hf_lmp_opinre = -1;
++static int hf_lmp_pagesch = -1;
++static int hf_lmp_pcmode = -1;
++static int hf_lmp_pkttype = -1;
++static int hf_lmp_pkttypetbl = -1;
++static int hf_lmp_pmaddr = -1;
++static int hf_lmp_pmaddr1 = -1;
++static int hf_lmp_pmaddr2 = -1;
++static int hf_lmp_pmaddr3 = -1;
++static int hf_lmp_pmaddr4 = -1;
++static int hf_lmp_pmaddr5 = -1;
++static int hf_lmp_pmaddr6 = -1;
++static int hf_lmp_pmaddr7 = -1;
++static int hf_lmp_pollintvl = -1;
++static int hf_lmp_pollper = -1;
++static int hf_lmp_pssettings = -1;
++static int hf_lmp_pwradjreq = -1;
++static int hf_lmp_pwradjres = -1;
++static int hf_lmp_pwradj_8dpsk = -1;
++static int hf_lmp_pwradj_dqpsk = -1;
++static int hf_lmp_pwradj_gfsk = -1;
++static int hf_lmp_rand = -1;
++static int hf_lmp_rate = -1;
++static int hf_lmp_rate_fec = -1;
++static int hf_lmp_rate_size = -1;
++static int hf_lmp_rate_type = -1;
++static int hf_lmp_rate_edrsize = -1;
++static int hf_lmp_rxfreq = -1;
++static int hf_lmp_scohdl = -1;
++static int hf_lmp_scopkt = -1;
++static int hf_lmp_slotoffset = -1;
++static int hf_lmp_sniffatt = -1;
++static int hf_lmp_sniffsi = -1;
++static int hf_lmp_sniffto = -1;
++static int hf_lmp_subversnr = -1;
++static int hf_lmp_suptimeout = -1;
++static int hf_lmp_swinst = -1;
++static int hf_lmp_taccess = -1;
++static int hf_lmp_tb = -1;
++static int hf_lmp_tesco = -1;
++static int hf_lmp_testlen = -1;
++static int hf_lmp_testscen = -1;
++static int hf_lmp_tid = -1;
++static int hf_lmp_timectrl = -1;
++static int hf_lmp_time_change = -1;
++static int hf_lmp_time_init = -1;
++static int hf_lmp_time_accwin = -1;
++static int hf_lmp_tsco = -1;
++static int hf_lmp_tsniff = -1;
++static int hf_lmp_txfreq = -1;
++static int hf_lmp_versnr = -1;
++static int hf_lmp_wesco = -1;
++
++/* timing control flags */
++static const int *timectrl_fields[] = {
++      &hf_lmp_time_change,
++      &hf_lmp_time_init,
++      &hf_lmp_time_accwin,
++      /* bits 3-7 reserved */
++      NULL
++};
++
++static const true_false_string time_change = {
++      "timing change",
++      "no timing change"
++};
++
++static const true_false_string time_init = {
++      "use initialization 2",
++      "use initialization 1"
++};
++
++static const true_false_string time_accwin = {
++      "no access window",
++      "access window"
++};
++
++static const true_false_string fec = {
++      "do not use FEC",
++      "use FEC"
++};
++
++static const true_false_string tid = {
++      "transaction initiated by slave",
++      "transaction initiated by master"
++};
++
++/* short LMP opcodes */
++static const value_string opcode[] = {
++      { LMP_NAME_REQ, "LMP_name_req" },
++      { LMP_NAME_RES, "LMP_name_res" },
++      { LMP_ACCEPTED, "LMP_accepted" },
++      { LMP_NOT_ACCEPTED, "LMP_not_accepted" },
++      { LMP_CLKOFFSET_REQ, "LMP_clkoffset_req" },
++      { LMP_CLKOFFSET_RES, "LMP_clkoffset_res" },
++      { LMP_DETACH, "LMP_detach" },
++      { LMP_IN_RAND, "LMP_in_rand" },
++      { LMP_COMB_KEY, "LMP_comb_key" },
++      { LMP_UNIT_KEY, "LMP_unit_key" },
++      { LMP_AU_RAND, "LMP_au_rand" },
++      { LMP_SRES, "LMP_sres" },
++      { LMP_TEMP_RAND, "LMP_temp_rand" },
++      { LMP_TEMP_KEY, "LMP_temp_key" },
++      { LMP_ENCRYPTION_MODE_REQ, "LMP_encryption_mode_req" },
++      { LMP_ENCRYPTION_KEY_SIZE_REQ, "LMP_encryption_key_size_req" },
++      { LMP_START_ENCRYPTION_REQ, "LMP_start_encryption_req" },
++      { LMP_STOP_ENCRYPTION_REQ, "LMP_stop_encryption_req" },
++      { LMP_SWITCH_REQ, "LMP_switch_req" },
++      { LMP_HOLD, "LMP_hold" },
++      { LMP_HOLD_REQ, "LMP_hold_req" },
++      { LMP_SNIFF_REQ, "LMP_sniff_req" },
++      { LMP_UNSNIFF_REQ, "LMP_unsniff_req" },
++      { LMP_PARK_REQ, "LMP_park_req" },
++      { LMP_SET_BROADCAST_SCAN_WINDOW, "LMP_set_broadcast_scan_window" },
++      { LMP_MODIFY_BEACON, "LMP_modify_beacon" },
++      { LMP_UNPARK_BD_ADDR_REQ, "LMP_unpark_BD_ADDR_req" },
++      { LMP_UNPARK_PM_ADDR_REQ, "LMP_unpark_PM_ADDR_req" },
++      { LMP_INCR_POWER_REQ, "LMP_incr_power_req" },
++      { LMP_DECR_POWER_REQ, "LMP_decr_power_req" },
++      { LMP_MAX_POWER, "LMP_max_power" },
++      { LMP_MIN_POWER, "LMP_min_power" },
++      { LMP_AUTO_RATE, "LMP_auto_rate" },
++      { LMP_PREFERRED_RATE, "LMP_preferred_rate" },
++      { LMP_VERSION_REQ, "LMP_version_req" },
++      { LMP_VERSION_RES, "LMP_version_res" },
++      { LMP_FEATURES_REQ, "LMP_features_req" },
++      { LMP_FEATURES_RES, "LMP_features_res" },
++      { LMP_QUALITY_OF_SERVICE, "LMP_quality_of_service" },
++      { LMP_QUALITY_OF_SERVICE_REQ, "LMP_quality_of_service_req" },
++      { LMP_SCO_LINK_REQ, "LMP_SCO_link_req" },
++      { LMP_REMOVE_SCO_LINK_REQ, "LMP_remove_SCO_link_req" },
++      { LMP_MAX_SLOT, "LMP_max_slot" },
++      { LMP_MAX_SLOT_REQ, "LMP_max_slot_req" },
++      { LMP_TIMING_ACCURACY_REQ, "LMP_timing_accuracy_req" },
++      { LMP_TIMING_ACCURACY_RES, "LMP_timing_accuracy_res" },
++      { LMP_SETUP_COMPLETE, "LMP_setup_complete" },
++      { LMP_USE_SEMI_PERMANENT_KEY, "LMP_use_semi_permanent_key" },
++      { LMP_HOST_CONNECTION_REQ, "LMP_host_connection_req" },
++      { LMP_SLOT_OFFSET, "LMP_slot_offset" },
++      { LMP_PAGE_MODE_REQ, "LMP_page_mode_req" },
++      { LMP_PAGE_SCAN_MODE_REQ, "LMP_page_scan_mode_req" },
++      { LMP_SUPERVISION_TIMEOUT, "LMP_supervision_timeout" },
++      { LMP_TEST_ACTIVATE, "LMP_test_activate" },
++      { LMP_TEST_CONTROL, "LMP_test_control" },
++      { LMP_ENCRYPTION_KEY_SIZE_MASK_REQ, "LMP_encryption_key_size_mask_req" },
++      { LMP_ENCRYPTION_KEY_SIZE_MASK_RES, "LMP_encryption_key_size_mask_res" },
++      { LMP_SET_AFH, "LMP_set_AFH" },
++      { LMP_ENCAPSULATED_HEADER, "LMP_encapsulated_header" },
++      { LMP_ENCAPSULATED_PAYLOAD, "LMP_encapsulated_payload" },
++      { LMP_SIMPLE_PAIRING_CONFIRM, "LMP_Simple_Pairing_Confirm" },
++      { LMP_SIMPLE_PAIRING_NUMBER, "LMP_Simple_Pairing_Number" },
++      { LMP_DHKEY_CHECK, "LMP_DHkey_Check" },
++      { LMP_ESCAPE_1, "Escape 1" },
++      { LMP_ESCAPE_2, "Escape 2" },
++      { LMP_ESCAPE_3, "Escape 3" },
++      { LMP_ESCAPE_4, "Escape 4" },
++      { 0, NULL }
++};
++
++/* extended LMP opcodes */
++static const value_string ext_opcode[] = {
++      { LMP_ACCEPTED_EXT, "LMP_accepted_ext" },
++      { LMP_NOT_ACCEPTED_EXT, "LMP_not_accepted_ext" },
++      { LMP_FEATURES_REQ_EXT, "LMP_features_req_ext" },
++      { LMP_FEATURES_RES_EXT, "LMP_features_res_ext" },
++      { LMP_PACKET_TYPE_TABLE_REQ, "LMP_packet_type_table_req" },
++      { LMP_ESCO_LINK_REQ, "LMP_eSCO_link_req" },
++      { LMP_REMOVE_ESCO_LINK_REQ, "LMP_remove_eSCO_link_req" },
++      { LMP_CHANNEL_CLASSIFICATION_REQ, "LMP_channel_classification_req" },
++      { LMP_CHANNEL_CLASSIFICATION, "LMP_channel_classification" },
++      { LMP_SNIFF_SUBRATING_REQ, "LMP_sniff_subrating_req" },
++      { LMP_SNIFF_SUBRATING_RES, "LMP_sniff_subrating_res" },
++      { LMP_PAUSE_ENCRYPTION_REQ, "LMP_pause_encryption_req" },
++      { LMP_RESUME_ENCRYPTION_REQ, "LMP_resume_encryption_req" },
++      { LMP_IO_CAPABILITY_REQ, "LMP_IO_Capability_req" },
++      { LMP_IO_CAPABILITY_RES, "LMP_IO_Capability_res" },
++      { LMP_NUMERIC_COMPARISON_FAILED, "LMP_numeric_comparison_failed" },
++      { LMP_PASSKEY_FAILED, "LMP_passkey_failed" },
++      { LMP_OOB_FAILED, "LMP_oob_failed" },
++      { LMP_KEYPRESS_NOTIFICATION, "LMP_keypress_notification" },
++      { LMP_POWER_CONTROL_REQ, "LMP_power_control_req" },
++      { LMP_POWER_CONTROL_RES, "LMP_power_control_res" },
++      { 0, NULL }
++};
++
++/* LMP error codes */
++static const value_string error_code[] = {
++      { 0x00, "Success" },
++      { 0x01, "Unknown HCI Command" },
++      { 0x02, "Unknown Connection Identifier" },
++      { 0x03, "Hardware Failure" },
++      { 0x04, "Page Timeout" },
++      { 0x05, "Authentication Failure" },
++      { 0x06, "PIN or Key Missing" },
++      { 0x07, "Memory Capacity Exceeded" },
++      { 0x08, "Connection Timeout" },
++      { 0x09, "Connection Limit Exceeded" },
++      { 0x0A, "Synchronous Connection Limit To A Device Exceeded" },
++      { 0x0B, "ACL Connection Already Exists" },
++      { 0x0C, "Command Disallowed" },
++      { 0x0D, "Connection Rejected due to Limited Resources" },
++      { 0x0E, "Connection Rejected Due To Security Reasons" },
++      { 0x0F, "Connection Rejected due to Unacceptable BD_ADDR" },
++      { 0x10, "Connection Accept Timeout Exceeded" },
++      { 0x11, "Unsupported Feature or Parameter Value" },
++      { 0x12, "Invalid HCI Command Parameters" },
++      { 0x13, "Remote User Terminated Connection" },
++      { 0x14, "Remote Device Terminated Connection due to Low Resources" },
++      { 0x15, "Remote Device Terminated Connection due to Power Off" },
++      { 0x16, "Connection Terminated By Local Host" },
++      { 0x17, "Repeated Attempts" },
++      { 0x18, "Pairing Not Allowed" },
++      { 0x19, "Unknown LMP PDU" },
++      { 0x1A, "Unsupported Remote Feature / Unsupported LMP Feature" },
++      { 0x1B, "SCO Offset Rejected" },
++      { 0x1C, "SCO Interval Rejected" },
++      { 0x1D, "SCO Air Mode Rejected" },
++      { 0x1E, "Invalid LMP Parameters" },
++      { 0x1F, "Unspecified Error" },
++      { 0x20, "Unsupported LMP Parameter Value" },
++      { 0x21, "Role Change Not Allowed" },
++      { 0x22, "LMP Response Timeout" },
++      { 0x23, "LMP Error Transaction Collision" },
++      { 0x24, "LMP PDU Not Allowed" },
++      { 0x25, "Encryption Mode Not Acceptable" },
++      { 0x26, "Link Key Can Not be Changed" },
++      { 0x27, "Requested QoS Not Supported" },
++      { 0x28, "Instant Passed" },
++      { 0x29, "Pairing With Unit Key Not Supported" },
++      { 0x2A, "Different Transaction Collision" },
++      { 0x2B, "Reserved" },
++      { 0x2C, "QoS Unacceptable Parameter" },
++      { 0x2D, "QoS Rejected" },
++      { 0x2E, "Channel Classification Not Supported" },
++      { 0x2F, "Insufficient Security" },
++      { 0x30, "Parameter Out Of Mandatory Range" },
++      { 0x31, "Reserved" },
++      { 0x32, "Role Switch Pending" },
++      { 0x33, "Reserved" },
++      { 0x34, "Reserved Slot Violation" },
++      { 0x35, "Role Switch Failed" },
++      { 0x36, "Extended Inquiry Response Too Large" },
++      { 0x37, "Secure Simple Pairing Not Supported By Host." },
++      { 0x38, "Host Busy - Pairing" },
++      { 0x39, "Connection Rejected due to No Suitable Channel Found" },
++      { 0, NULL }
++};
++
++static const value_string encryption_mode[] = {
++      { 0, "no encryption" },
++      { 1, "encryption" },
++      { 2, "encryption" },
++      /* 3 - 255 reserved */
++      { 0, NULL }
++};
++
++static const value_string access_scheme[] = {
++      { 0, "polling technique" },
++      /* 1 - 15 reserved */
++      { 0, NULL }
++};
++
++static const value_string packet_size[] = {
++      { 0, "no packet-size preference available" },
++      { 1, "use 1-slot packets" },
++      { 2, "use 3-slot packets" },
++      { 3, "use 5-slot packets" },
++      { 0, NULL }
++};
++
++static const value_string edr_type[] = {
++      { 0, "use DM1 packets" },
++      { 1, "use 2 Mbps packets" },
++      { 2, "use 3 Mbps packets" },
++      /* 3 reserved */
++      { 0, NULL }
++};
++
++static const value_string versnr[] = {
++      { 0, "Bluetooth Core Specification 1.0b" },
++      { 1, "Bluetooth Core Specification 1.1" },
++      { 2, "Bluetooth Core Specification 1.2" },
++      { 3, "Bluetooth Core Specification 2.0 + EDR" },
++      { 4, "Bluetooth Core Specification 2.1 + EDR" },
++      { 5, "Bluetooth Core Specification 3.0 + HS" },
++      /* 6 - 255 reserved */
++      { 0, NULL }
++};
++
++static const value_string compid[] = {
++      { 0, "Ericsson Technology Licensing" },
++      { 1, "Nokia Mobile Phones" },
++      { 2, "Intel Corp." },
++      { 3, "IBM Corp." },
++      { 4, "Toshiba Corp." },
++      { 5, "3Com" },
++      { 6, "Microsoft" },
++      { 7, "Lucent" },
++      { 8, "Motorola" },
++      { 9, "Infineon Technologies AG" },
++      { 10, "Cambridge Silicon Radio" },
++      { 11, "Silicon Wave" },
++      { 12, "Digianswer A/S" },
++      { 13, "Texas Instruments Inc." },
++      { 14, "Parthus Technologies Inc." },
++      { 15, "Broadcom Corporation" },
++      { 16, "Mitel Semiconductor" },
++      { 17, "Widcomm, Inc." },
++      { 18, "Zeevo, Inc." },
++      { 19, "Atmel Corporation" },
++      { 20, "Mitsubishi Electric Corporation" },
++      { 21, "RTX Telecom A/S" },
++      { 22, "KC Technology Inc." },
++      { 23, "Newlogic" },
++      { 24, "Transilica, Inc." },
++      { 25, "Rohde & Schwarz GmbH & Co. KG" },
++      { 26, "TTPCom Limited" },
++      { 27, "Signia Technologies, Inc." },
++      { 28, "Conexant Systems Inc." },
++      { 29, "Qualcomm" },
++      { 30, "Inventel" },
++      { 31, "AVM Berlin" },
++      { 32, "BandSpeed, Inc." },
++      { 33, "Mansella Ltd" },
++      { 34, "NEC Corporation" },
++      { 35, "WavePlus Technology Co., Ltd." },
++      { 36, "Alcatel" },
++      { 37, "Philips Semiconductors" },
++      { 38, "C Technologies" },
++      { 39, "Open Interface" },
++      { 40, "R F Micro Devices" },
++      { 41, "Hitachi Ltd" },
++      { 42, "Symbol Technologies, Inc." },
++      { 43, "Tenovis" },
++      { 44, "Macronix International Co. Ltd." },
++      { 45, "GCT Semiconductor" },
++      { 46, "Norwood Systems" },
++      { 47, "MewTel Technology Inc." },
++      { 48, "ST Microelectronics" },
++      { 49, "Synopsys" },
++      { 50, "Red-M (Communications) Ltd" },
++      { 51, "Commil Ltd" },
++      { 52, "Computer Access Technology Corporation (CATC)" },
++      { 53, "Eclipse (HQ Espana) S.L." },
++      { 54, "Renesas Technology Corp." },
++      { 55, "Mobilian Corporation" },
++      { 56, "Terax" },
++      { 57, "Integrated System Solution Corp." },
++      { 58, "Matsushita Electric Industrial Co., Ltd." },
++      { 59, "Gennum Corporation" },
++      { 60, "Research In Motion" },
++      { 61, "IPextreme, Inc." },
++      { 62, "Systems and Chips, Inc" },
++      { 63, "Bluetooth SIG, Inc" },
++      { 64, "Seiko Epson Corporation" },
++      { 65, "Integrated Silicon Solution Taiwan, Inc." },
++      { 66, "CONWISE Technology Corporation Ltd" },
++      { 67, "PARROT SA" },
++      { 68, "Socket Mobile" },
++      { 69, "Atheros Communications, Inc." },
++      { 70, "MediaTek, Inc." },
++      { 71, "Bluegiga (tentative)" },
++      { 72, "Marvell Technology Group Ltd." },
++      { 73, "3DSP Corporation" },
++      { 74, "Accel Semiconductor Ltd." },
++      { 75, "Continental Automotive Systems" },
++      { 76, "Apple, Inc." },
++      { 77, "Staccato Communications, Inc." },
++      { 78, "Avago Technologies" },
++      { 79, "APT Ltd." },
++      { 80, "SiRF Technology, Inc." },
++      { 81, "Tzero Technologies, Inc." },
++      { 82, "J&M Corporation" },
++      { 83, "Free2move AB" },
++      /* 84 - 65534 reserved */
++      { 65535, "test" },
++      { 0, NULL }
++};
++
++static const value_string sco_packet[] = {
++      { 0, "HV1" },
++      { 1, "HV2" },
++      { 2, "HV3" },
++      /* 3 - 255 reserved */
++      { 0, NULL }
++};
++
++static const value_string air_mode[] = {
++      { 0, "mu-law log" },
++      { 1, "A-law log" },
++      { 2, "CVSD" },
++      { 3, "transparent data" },
++      /* 4 - 255 reserved */
++      { 0, NULL }
++};
++
++static const value_string paging_scheme[] = {
++      { 0, "mandatory scheme" },
++      /* 1 - 255 reserved */
++      { 0, NULL }
++};
++
++static const value_string paging_scheme_settings[] = {
++      /* for mandatory scheme: */
++      { 0, "R0" },
++      { 1, "R1" },
++      { 2, "R2" },
++      /* 3 - 255 reserved */
++      { 0, NULL }
++};
++
++static const value_string afh_mode[] = {
++      { 0, "AFH disabled" },
++      { 1, "AFH enabled" },
++      /* 2 - 255 reserved */
++      { 0, NULL }
++};
++
++static const value_string features_page[] = {
++      { 0, "standard features" },
++      /* 1 - 255 other feature pages */
++      { 0, NULL }
++};
++
++static const value_string packet_type_table[] = {
++      { 0, "1 Mbps only" },
++      { 1, "2/3 Mbps" },
++      /* 2 - 255 reserved */
++      { 0, NULL }
++};
++
++static const value_string negotiation_state[] = {
++      { 0, "Initiate negotiation" },
++      { 1, "The latest received set of negotiable parameters were possible but these parameters are preferred." },
++      { 2, "The latest received set of negotiable parameters would cause a reserved slot violation." },
++      { 3, "The latest received set of negotiable parameters would cause a latency violation." },
++      { 4, "The latest received set of negotiable parameters are not supported." },
++      /* 5 - 255 reserved */
++      { 0, NULL }
++};
++
++static const value_string afh_reporting_mode[] = {
++      { 0, "AFH reporting disabled" },
++      { 1, "AFH reporting enabled" },
++      /* 2 - 255 reserved */
++      { 0, NULL }
++};
++
++static const value_string io_capabilities[] = {
++      { 0, "Display Only" },
++      { 1, "Display Yes/No" },
++      { 2, "Keyboard Only" },
++      { 3, "No Input/No Output" },
++      /* 4 - 255 reserved */
++      { 0, NULL }
++};
++
++static const value_string oob_auth_data[] = {
++      { 0, "No OOB Authentication Data received" },
++      { 1, "OOB Authentication Data received" },
++      /* 2 - 255 reserved */
++      { 0, NULL }
++};
++
++static const value_string auth_requirements[] = {
++      { 0x00, "MITM Protection Not Required - No Bonding" },
++      { 0x01, "MITM Protection Required - No Bonding" },
++      { 0x02, "MITM Protection Not Required - Dedicated Bonding" },
++      { 0x03, "MITM Protection Required - Dedicated Bonding" },
++      { 0x04, "MITM Protection Not Required - General Bonding" },
++      { 0x05, "MITM Protection Required - General Bonding" },
++      /* 0x06 - 0xff reserved */
++      { 0, NULL }
++};
++
++static const value_string power_adjust_req[] = {
++      { 0, "decrement power one step" },
++      { 1, "increment power one step" },
++      { 2, "increase to maximum power" },
++      /* 3 - 255 reserved */
++      { 0, NULL }
++};
++
++static const value_string power_adjust_res[] = {
++      { 0, "not supported" },
++      { 1, "changed one step (not min or max)" },
++      { 2, "max power" },
++      { 3, "min power" },
++      /* 4 - 255 reserved */
++      { 0, NULL }
++};
++
++static const value_string test_scenario[] = {
++      { 0, "Pause Test Mode" },
++      { 1, "Transmitter test - 0 pattern" },
++      { 2, "Transmitter test - 1 pattern" },
++      { 3, "Transmitter test - 1010 pattern" },
++      { 4, "Pseudorandom bit sequence" },
++      { 5, "Closed Loop Back - ACL packets" },
++      { 6, "Closed Loop Back - Synchronous packets" },
++      { 7, "ACL Packets without whitening" },
++      { 8, "Synchronous Packets without whitening" },
++      { 9, "Transmitter test - 1111 0000 pattern" },
++      /* 10 - 254 reserved */
++      { 255, "Exit Test Mode" },
++      { 0, NULL }
++};
++
++static const value_string hopping_mode[] = {
++      { 0, "RX/TX on single frequency" },
++      { 1, "Normal hopping" },
++      /* 2 - 255 reserved */
++      { 0, NULL }
++};
++
++static const value_string power_control_mode[] = {
++      { 0, "fixed TX output power" },
++      { 1, "adaptive power control" },
++      /* 2 - 255 reserved */
++      { 0, NULL }
++};
++
++static const value_string esco_packet_type[] = {
++      { 0x00, "NULL/POLL" },
++      { 0x07, "EV3" },
++      { 0x0C, "EV4" },
++      { 0x0D, "EV5" },
++      { 0x26, "2-EV3" },
++      { 0x2C, "2-EV5" },
++      { 0x37, "3-EV3" },
++      { 0x3D, "3-EV5" },
++      /* other values reserved */
++      { 0, NULL }
++};
++
++static const value_string notification_value[] = {
++      { 0, "passkey entry started" },
++      { 1, "passkey digit entered" },
++      { 2, "passkey digit erased" },
++      { 3, "passkey cleared" },
++      { 4, "passkey entry completed" },
++      /* 5 - 255 reserved */
++      { 0, NULL }
++};
++
++/* initialize the subtree pointers */
++static gint ett_lmp = -1;
++static gint ett_lmp_pwradjres = -1;
++static gint ett_lmp_rate = -1;
++static gint ett_lmp_timectrl = -1;
++
++/* LMP PDUs with short opcodes */
++
++void
++dissect_name_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 2);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 1);
++
++      proto_tree_add_item(tree, hf_lmp_nameoffset, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_name_res(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 17);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 16);
++
++      proto_tree_add_item(tree, hf_lmp_nameoffset, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_namelen, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_namefrag, tvb, offset, 14, TRUE);
++}
++
++void
++dissect_accepted(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 2);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 1);
++
++      proto_tree_add_item(tree, hf_lmp_opinre, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_not_accepted(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 3);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 2);
++
++      proto_tree_add_item(tree, hf_lmp_opinre, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_err, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_clkoffset_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 1);
++}
++
++void
++dissect_clkoffset_res(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 3);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 2);
++
++      proto_tree_add_item(tree, hf_lmp_clkoffset, tvb, offset, 2, TRUE);
++}
++
++void
++dissect_detach(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 2);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 1);
++
++      proto_tree_add_item(tree, hf_lmp_err, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_in_rand(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 17);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 16);
++
++      proto_tree_add_item(tree, hf_lmp_rand, tvb, offset, 16, TRUE);
++}
++
++void
++dissect_comb_key(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 17);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 16);
++
++      proto_tree_add_item(tree, hf_lmp_rand, tvb, offset, 16, TRUE);
++}
++
++void
++dissect_unit_key(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 17);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 16);
++
++      proto_tree_add_item(tree, hf_lmp_key, tvb, offset, 16, TRUE);
++}
++
++void
++dissect_au_rand(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 17);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 16);
++
++      proto_tree_add_item(tree, hf_lmp_rand, tvb, offset, 16, TRUE);
++}
++
++void
++dissect_sres(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 5);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 4);
++
++      proto_tree_add_item(tree, hf_lmp_authres, tvb, offset, 4, TRUE);
++}
++
++void
++dissect_temp_rand(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 17);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 16);
++
++      proto_tree_add_item(tree, hf_lmp_rand, tvb, offset, 16, TRUE);
++}
++
++void
++dissect_temp_key(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 17);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 16);
++
++      proto_tree_add_item(tree, hf_lmp_key, tvb, offset, 16, TRUE);
++}
++
++void
++dissect_encryption_mode_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 2);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 1);
++
++      proto_tree_add_item(tree, hf_lmp_cryptmode, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_encryption_key_size_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 2);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 1);
++
++      proto_tree_add_item(tree, hf_lmp_keysz, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_start_encryption_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 17);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 16);
++
++      proto_tree_add_item(tree, hf_lmp_rand, tvb, offset, 16, TRUE);
++}
++
++void
++dissect_stop_encryption_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 1);
++}
++
++void
++dissect_switch_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 5);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 4);
++
++      proto_tree_add_item(tree, hf_lmp_swinst, tvb, offset, 4, TRUE);
++}
++
++void
++dissect_hold(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 7);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 6);
++
++      proto_tree_add_item(tree, hf_lmp_htime, tvb, offset, 2, TRUE);
++      offset += 2;
++
++      proto_tree_add_item(tree, hf_lmp_hinst, tvb, offset, 4, TRUE);
++}
++
++void
++dissect_hold_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 7);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 6);
++
++      proto_tree_add_item(tree, hf_lmp_htime, tvb, offset, 2, TRUE);
++      offset += 2;
++
++      proto_tree_add_item(tree, hf_lmp_hinst, tvb, offset, 4, TRUE);
++}
++
++void
++dissect_sniff_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 10);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 9);
++
++      proto_tree_add_bitmask(tree, tvb, offset, hf_lmp_timectrl,
++                      ett_lmp_timectrl, timectrl_fields, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_dsniff, tvb, offset, 2, TRUE);
++      offset += 2;
++
++      proto_tree_add_item(tree, hf_lmp_tsniff, tvb, offset, 2, TRUE);
++      offset += 2;
++
++      proto_tree_add_item(tree, hf_lmp_sniffatt, tvb, offset, 2, TRUE);
++      offset += 2;
++
++      proto_tree_add_item(tree, hf_lmp_sniffto, tvb, offset, 2, TRUE);
++}
++
++void
++dissect_unsniff_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 1);
++}
++
++void
++dissect_park_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 17);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 16);
++
++      proto_tree_add_bitmask(tree, tvb, offset, hf_lmp_timectrl,
++                      ett_lmp_timectrl, timectrl_fields, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_db, tvb, offset, 2, TRUE);
++      offset += 2;
++
++      proto_tree_add_item(tree, hf_lmp_tb, tvb, offset, 2, TRUE);
++      offset += 2;
++
++      proto_tree_add_item(tree, hf_lmp_nb, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_deltab, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_pmaddr, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_araddr, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_nbsleep, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_dbsleep, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_daccess, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_taccess, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_naccslots, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_npoll, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_maccess, tvb, offset, 1, TRUE);
++      proto_tree_add_item(tree, hf_lmp_accscheme, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_set_broadcast_scan_window(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      int db_present;
++
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 1);
++
++      proto_tree_add_bitmask(tree, tvb, offset, hf_lmp_timectrl,
++                      ett_lmp_timectrl, timectrl_fields, TRUE);
++
++      /* bit0 of timing control flags indicates presence of db */
++      db_present = tvb_get_guint8(tvb, offset) & 0x01;
++      offset += 1;
++
++      if (db_present) {
++              DISSECTOR_ASSERT(len == 6);
++              DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 4);
++
++              proto_tree_add_item(tree, hf_lmp_db, tvb, offset, 2, TRUE);
++              offset += 2;
++      } else {
++              DISSECTOR_ASSERT(len == 4);
++              DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 2);
++      }
++
++      proto_tree_add_item(tree, hf_lmp_bsw, tvb, offset, 2, TRUE);
++}
++
++void
++dissect_modify_beacon(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      int db_present;
++
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 1);
++
++      proto_tree_add_bitmask(tree, tvb, offset, hf_lmp_timectrl,
++                      ett_lmp_timectrl, timectrl_fields, TRUE);
++
++      /* bit0 of timing control flags indicates presence of db */
++      db_present = tvb_get_guint8(tvb, offset) & 0x01;
++      offset += 1;
++
++      if (db_present) {
++              DISSECTOR_ASSERT(len == 13);
++              DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 11);
++
++              proto_tree_add_item(tree, hf_lmp_db, tvb, offset, 2, TRUE);
++              offset += 2;
++      } else {
++              DISSECTOR_ASSERT(len == 11);
++              DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 9);
++      }
++
++      proto_tree_add_item(tree, hf_lmp_tb, tvb, offset, 2, TRUE);
++      offset += 2;
++
++      proto_tree_add_item(tree, hf_lmp_nb, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_deltab, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_daccess, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_taccess, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_naccslots, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_npoll, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_maccess, tvb, offset, 1, TRUE);
++      proto_tree_add_item(tree, hf_lmp_accscheme, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_unpark_bd_addr_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      int db_present;
++      proto_item *item;
++
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 1);
++
++      proto_tree_add_bitmask(tree, tvb, offset, hf_lmp_timectrl,
++                      ett_lmp_timectrl, timectrl_fields, TRUE);
++
++      /* bit0 of timing control flags indicates presence of db */
++      db_present = tvb_get_guint8(tvb, offset) & 0x01;
++      offset += 1;
++
++      if (db_present) {
++              DISSECTOR_ASSERT(len == 17);
++              DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 15);
++
++              proto_tree_add_item(tree, hf_lmp_db, tvb, offset, 2, TRUE);
++              offset += 2;
++      } else {
++              DISSECTOR_ASSERT(len == 15);
++              DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 13);
++      }
++
++      proto_tree_add_item(tree, hf_lmp_ltaddr1, tvb, offset, 1, TRUE);
++      proto_tree_add_item(tree, hf_lmp_ltaddr2, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_bdaddr1, tvb, offset, 6, TRUE);
++      offset += 6;
++
++      proto_tree_add_item(tree, hf_lmp_bdaddr2, tvb, offset, 6, TRUE);
++      offset += 6;
++}
++
++void
++dissect_unpark_pm_addr_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      int db_present;
++
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 1);
++
++      proto_tree_add_bitmask(tree, tvb, offset, hf_lmp_timectrl,
++                      ett_lmp_timectrl, timectrl_fields, TRUE);
++
++      /* bit0 of timing control flags indicates presence of db */
++      db_present = tvb_get_guint8(tvb, offset) & 0x01;
++      offset += 1;
++
++      if (db_present) {
++              DISSECTOR_ASSERT(len == 15);
++              DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 13);
++
++              proto_tree_add_item(tree, hf_lmp_db, tvb, offset, 2, TRUE);
++              offset += 2;
++      } else {
++              DISSECTOR_ASSERT(len == 13);
++              DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 11);
++      }
++
++      proto_tree_add_item(tree, hf_lmp_ltaddr1, tvb, offset, 1, TRUE);
++      proto_tree_add_item(tree, hf_lmp_ltaddr2, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_pmaddr1, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_pmaddr2, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_ltaddr3, tvb, offset, 1, TRUE);
++      proto_tree_add_item(tree, hf_lmp_ltaddr4, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_pmaddr3, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_pmaddr4, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_ltaddr5, tvb, offset, 1, TRUE);
++      proto_tree_add_item(tree, hf_lmp_ltaddr6, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_pmaddr5, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_pmaddr6, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_ltaddr7, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_pmaddr7, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_incr_power_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 2);
++
++      /* skipping one byte "for future use" */
++}
++
++void
++dissect_decr_power_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 2);
++
++      /* skipping one byte "for future use" */
++}
++
++void
++dissect_max_power(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 1);
++}
++
++void
++dissect_min_power(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 1);
++}
++
++void
++dissect_auto_rate(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 1);
++}
++
++void
++dissect_preferred_rate(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      proto_item *rate_item;
++      proto_tree *rate_tree;
++
++      DISSECTOR_ASSERT(len == 2);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 1);
++
++      rate_item = proto_tree_add_item(tree, hf_lmp_rate, tvb, offset, 1, TRUE);
++      rate_tree = proto_item_add_subtree(rate_item, ett_lmp_rate);
++
++      proto_tree_add_item(rate_tree, hf_lmp_rate_fec, tvb, offset, 1, TRUE);
++      proto_tree_add_item(rate_tree, hf_lmp_rate_size, tvb, offset, 1, TRUE);
++      proto_tree_add_item(rate_tree, hf_lmp_rate_type, tvb, offset, 1, TRUE);
++      proto_tree_add_item(rate_tree, hf_lmp_rate_edrsize, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_version_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 6);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 5);
++
++      proto_tree_add_item(tree, hf_lmp_versnr, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_compid, tvb, offset, 2, TRUE);
++      offset += 2;
++
++      proto_tree_add_item(tree, hf_lmp_subversnr, tvb, offset, 2, TRUE);
++}
++
++void
++dissect_version_res(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 6);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 5);
++
++      proto_tree_add_item(tree, hf_lmp_versnr, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_compid, tvb, offset, 2, TRUE);
++      offset += 2;
++
++      proto_tree_add_item(tree, hf_lmp_subversnr, tvb, offset, 2, TRUE);
++}
++
++void
++dissect_features_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 9);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 8);
++
++      proto_tree_add_item(tree, hf_lmp_features, tvb, offset, 8, TRUE);
++}
++
++void
++dissect_features_res(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 9);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 8);
++
++      proto_tree_add_item(tree, hf_lmp_features, tvb, offset, 8, TRUE);
++}
++
++void
++dissect_quality_of_service(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 4);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 3);
++
++      proto_tree_add_item(tree, hf_lmp_pollintvl, tvb, offset, 2, TRUE);
++      offset += 2;
++
++      proto_tree_add_item(tree, hf_lmp_nbc, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_quality_of_service_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 4);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 3);
++
++      proto_tree_add_item(tree, hf_lmp_pollintvl, tvb, offset, 2, TRUE);
++      offset += 2;
++
++      proto_tree_add_item(tree, hf_lmp_nbc, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_sco_link_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 7);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 6);
++
++      proto_tree_add_item(tree, hf_lmp_scohdl, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_bitmask(tree, tvb, offset, hf_lmp_timectrl,
++                      ett_lmp_timectrl, timectrl_fields, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_dsco, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_tsco, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_scopkt, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_airmode, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_remove_sco_link_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 3);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 2);
++
++      proto_tree_add_item(tree, hf_lmp_scohdl, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_err, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_max_slot(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 2);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 1);
++
++      proto_tree_add_item(tree, hf_lmp_maxslots, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_max_slot_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 2);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 1);
++
++      proto_tree_add_item(tree, hf_lmp_maxslots, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_timing_accuracy_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 1);
++}
++
++void
++dissect_timing_accuracy_res(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 3);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 2);
++
++      proto_tree_add_item(tree, hf_lmp_drift, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_jitter, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_setup_complete(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 1);
++}
++
++void
++dissect_use_semi_permanent_key(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 1);
++}
++
++void
++dissect_host_connection_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 1);
++}
++
++void
++dissect_slot_offset(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 9);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 8);
++
++      proto_tree_add_item(tree, hf_lmp_slotoffset, tvb, offset, 2, TRUE);
++      offset += 2;
++
++      proto_tree_add_item(tree, hf_lmp_bdaddr, tvb, offset, 6, TRUE);
++}
++
++void
++dissect_page_mode_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 3);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 2);
++
++      proto_tree_add_item(tree, hf_lmp_pagesch, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_pssettings, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_page_scan_mode_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 3);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 2);
++
++      proto_tree_add_item(tree, hf_lmp_pagesch, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_pssettings, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_supervision_timeout(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 3);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 2);
++
++      proto_tree_add_item(tree, hf_lmp_suptimeout, tvb, offset, 2, TRUE);
++}
++
++void
++dissect_test_activate(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 1);
++}
++
++void
++dissect_test_control(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 10);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 9);
++
++      /* FIXME these fields should all be XORed with 0x55. . . */
++
++      proto_tree_add_item(tree, hf_lmp_testscen, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_hopmode, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_txfreq, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_rxfreq, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_pcmode, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_pollper, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_pkttype, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_testlen, tvb, offset, 2, TRUE);
++}
++
++void
++dissect_encryption_key_size_mask_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 1);
++}
++
++void
++dissect_encryption_key_size_mask_res(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 3);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 2);
++
++      proto_tree_add_item(tree, hf_lmp_ksmask, tvb, offset, 2, TRUE);
++}
++
++void
++dissect_set_afh(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 16);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 15);
++
++      proto_tree_add_item(tree, hf_lmp_afhinst, tvb, offset, 4, TRUE);
++      offset += 4;
++
++      proto_tree_add_item(tree, hf_lmp_afhmode, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_afhchmap, tvb, offset, 10, TRUE);
++}
++
++void
++dissect_encapsulated_header(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 4);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 3);
++
++      proto_tree_add_item(tree, hf_lmp_encmaj, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_encmin, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_enclen, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_encapsulated_payload(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 17);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 16);
++
++      proto_tree_add_item(tree, hf_lmp_encdata, tvb, offset, 16, TRUE);
++}
++
++void
++dissect_simple_pairing_confirm(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 17);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 16);
++
++      proto_tree_add_item(tree, hf_lmp_commit, tvb, offset, 16, TRUE);
++}
++
++void
++dissect_simple_pairing_number(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 17);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 16);
++
++      proto_tree_add_item(tree, hf_lmp_nonce, tvb, offset, 16, TRUE);
++}
++
++void
++dissect_dhkey_check(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 17);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 16);
++
++      proto_tree_add_item(tree, hf_lmp_confirm, tvb, offset, 16, TRUE);
++}
++
++/* LMP PDUs with extended opcodes */
++
++void
++dissect_accepted_ext(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 4);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 2);
++
++      proto_tree_add_item(tree, hf_lmp_opinre, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_eopinre, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_not_accepted_ext(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 4);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 2);
++
++      proto_tree_add_item(tree, hf_lmp_opinre, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_eopinre, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_err, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_features_req_ext(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 12);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 10);
++
++      proto_tree_add_item(tree, hf_lmp_fpage, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_maxsp, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      /*
++       * extended features might need to be different from hf_lmp_features
++       * if hf_lmp_features is broken out
++       */
++      proto_tree_add_item(tree, hf_lmp_features, tvb, offset, 8, TRUE);
++}
++
++void
++dissect_features_res_ext(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 12);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 10);
++
++      proto_tree_add_item(tree, hf_lmp_fpage, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_maxsp, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      /*
++       * extended features might need to be different from hf_lmp_features
++       * if hf_lmp_features is broken out
++       */
++      proto_tree_add_item(tree, hf_lmp_features, tvb, offset, 8, TRUE);
++}
++
++void
++dissect_packet_type_table_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 3);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 1);
++
++      proto_tree_add_item(tree, hf_lmp_pkttypetbl, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_esco_link_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 16);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 14);
++
++      proto_tree_add_item(tree, hf_lmp_escohdl, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_escoltaddr, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_bitmask(tree, tvb, offset, hf_lmp_timectrl,
++                      ett_lmp_timectrl, timectrl_fields, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_desco, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_tesco, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_wesco, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_escotypems, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_escotypesm, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_escolenms, tvb, offset, 2, TRUE);
++      offset += 2;
++
++      proto_tree_add_item(tree, hf_lmp_escolensm, tvb, offset, 2, TRUE);
++      offset += 2;
++
++      proto_tree_add_item(tree, hf_lmp_airmode, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_negstate, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_remove_esco_link_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 4);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 2);
++
++      proto_tree_add_item(tree, hf_lmp_escohdl, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_err, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_channel_classification_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 7);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 5);
++
++      proto_tree_add_item(tree, hf_lmp_afhrptmode, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_afhminintvl, tvb, offset, 2, TRUE);
++      offset += 2;
++
++      proto_tree_add_item(tree, hf_lmp_afhmaxintvl, tvb, offset, 2, TRUE);
++}
++
++void
++dissect_channel_classification(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 12);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 10);
++
++      proto_tree_add_item(tree, hf_lmp_afhclass, tvb, offset, 10, TRUE);
++}
++
++void
++dissect_sniff_subrating_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 9);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 7);
++
++      proto_tree_add_item(tree, hf_lmp_maxss, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_minsmt, tvb, offset, 2, TRUE);
++      offset += 2;
++
++      proto_tree_add_item(tree, hf_lmp_sniffsi, tvb, offset, 2, TRUE);
++}
++
++void
++dissect_sniff_subrating_res(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 9);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 7);
++
++      proto_tree_add_item(tree, hf_lmp_maxss, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_minsmt, tvb, offset, 2, TRUE);
++      offset += 2;
++
++      proto_tree_add_item(tree, hf_lmp_sniffsi, tvb, offset, 2, TRUE);
++}
++
++void
++dissect_pause_encryption_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 2);
++}
++
++void
++dissect_resume_encryption_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 2);
++}
++
++void
++dissect_io_capability_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 5);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 3);
++
++      proto_tree_add_item(tree, hf_lmp_iocaps, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_oobauthdata, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_authreqs, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_io_capability_res(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 5);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 3);
++
++      proto_tree_add_item(tree, hf_lmp_iocaps, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_oobauthdata, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      proto_tree_add_item(tree, hf_lmp_authreqs, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_numeric_comparison_failed(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 2);
++}
++
++void
++dissect_passkey_failed(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 2);
++}
++
++void
++dissect_oob_failed(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 2);
++}
++
++void
++dissect_keypress_notification(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 3);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 1);
++
++      proto_tree_add_item(tree, hf_lmp_nottype, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_power_control_req(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      DISSECTOR_ASSERT(len == 3);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 1);
++
++      proto_tree_add_item(tree, hf_lmp_pwradjreq, tvb, offset, 1, TRUE);
++}
++
++void
++dissect_power_control_res(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
++{
++      proto_item *pa_item;
++      proto_tree *pa_tree;
++
++      DISSECTOR_ASSERT(len == 3);
++      DISSECTOR_ASSERT(tvb_length_remaining(tvb, offset) >= 1);
++
++      pa_item = proto_tree_add_item(tree, hf_lmp_pwradjres, tvb, offset, 1, TRUE);
++      pa_tree = proto_item_add_subtree(pa_item, ett_lmp_pwradjres);
++
++      proto_tree_add_item(pa_tree, hf_lmp_pwradj_gfsk, tvb, offset, 1, TRUE);
++      proto_tree_add_item(pa_tree, hf_lmp_pwradj_dqpsk, tvb, offset, 1, TRUE);
++      proto_tree_add_item(pa_tree, hf_lmp_pwradj_8dpsk, tvb, offset, 1, TRUE);
++}
++
++/* Link Manager Protocol */
++static void
++dissect_btlmp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
++{
++      proto_item *lmp_item;
++      proto_tree *lmp_tree;
++      int offset;
++      int len;
++      int op;     /* opcode */
++      int eop;    /* extended opcode */
++
++      offset = 0;
++      len = tvb_length(tvb);
++
++      DISSECTOR_ASSERT(len >= 1);
++
++      /* make entries in protocol column and info column on summary display */
++      if (check_col(pinfo->cinfo, COL_PROTOCOL))
++              col_set_str(pinfo->cinfo, COL_PROTOCOL, "LMP");
++
++      /* clear the info column first just in case of type fetching failure. */
++      if (check_col(pinfo->cinfo, COL_INFO))
++              col_clear(pinfo->cinfo, COL_INFO);
++
++      op = tvb_get_guint8(tvb, offset) >> 1;
++
++      if (op == LMP_ESCAPE_4) {
++              DISSECTOR_ASSERT(len >= 2);
++
++              eop = tvb_get_guint8(tvb, offset + 1);
++
++              if (check_col(pinfo->cinfo, COL_INFO))
++                      col_add_str(pinfo->cinfo, COL_INFO, val_to_str(eop,
++                              opcode, "Unknown Extended Opcode (%d)"));
++      } else {
++              if (check_col(pinfo->cinfo, COL_INFO))
++                      col_add_str(pinfo->cinfo, COL_INFO, val_to_str(op,
++                              opcode, "Unknown Opcode (%d)"));
++      }
++
++      /* see if we are being asked for details */
++      if (!tree)
++              return;
++
++      lmp_item = proto_tree_add_item(tree, proto_btlmp, tvb, offset, -1, TRUE);
++      lmp_tree = proto_item_add_subtree(lmp_item, ett_lmp);
++
++      proto_tree_add_item(lmp_tree, hf_lmp_tid, tvb, offset, 1, TRUE);
++
++      proto_tree_add_item(lmp_tree, hf_lmp_op, tvb, offset, 1, TRUE);
++      offset += 1;
++
++      switch (op) {
++      case LMP_NAME_REQ:
++              dissect_name_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_NAME_RES:
++              dissect_name_res(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_ACCEPTED:
++              dissect_accepted(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_NOT_ACCEPTED:
++              dissect_not_accepted(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_CLKOFFSET_REQ:
++              dissect_clkoffset_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_CLKOFFSET_RES:
++              dissect_clkoffset_res(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_DETACH:
++              dissect_detach(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_IN_RAND:
++              dissect_in_rand(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_COMB_KEY:
++              dissect_comb_key(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_UNIT_KEY:
++              dissect_unit_key(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_AU_RAND:
++              dissect_au_rand(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_SRES:
++              dissect_sres(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_TEMP_RAND:
++              dissect_temp_rand(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_TEMP_KEY:
++              dissect_temp_key(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_ENCRYPTION_MODE_REQ:
++              dissect_encryption_mode_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_ENCRYPTION_KEY_SIZE_REQ:
++              dissect_encryption_key_size_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_START_ENCRYPTION_REQ:
++              dissect_start_encryption_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_STOP_ENCRYPTION_REQ:
++              dissect_stop_encryption_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_SWITCH_REQ:
++              dissect_switch_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_HOLD:
++              dissect_hold(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_HOLD_REQ:
++              dissect_hold_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_SNIFF_REQ:
++              dissect_sniff_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_UNSNIFF_REQ:
++              dissect_unsniff_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_PARK_REQ:
++              dissect_park_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_SET_BROADCAST_SCAN_WINDOW:
++              dissect_set_broadcast_scan_window(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_MODIFY_BEACON:
++              dissect_modify_beacon(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_UNPARK_BD_ADDR_REQ:
++              dissect_unpark_bd_addr_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_UNPARK_PM_ADDR_REQ:
++              dissect_unpark_pm_addr_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_INCR_POWER_REQ:
++              dissect_incr_power_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_DECR_POWER_REQ:
++              dissect_decr_power_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_MAX_POWER:
++              dissect_max_power(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_MIN_POWER:
++              dissect_min_power(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_AUTO_RATE:
++              dissect_auto_rate(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_PREFERRED_RATE:
++              dissect_preferred_rate(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_VERSION_REQ:
++              dissect_version_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_VERSION_RES:
++              dissect_version_res(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_FEATURES_REQ:
++              dissect_features_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_FEATURES_RES:
++              dissect_features_res(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_QUALITY_OF_SERVICE:
++              dissect_quality_of_service(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_QUALITY_OF_SERVICE_REQ:
++              dissect_quality_of_service_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_SCO_LINK_REQ:
++              dissect_sco_link_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_REMOVE_SCO_LINK_REQ:
++              dissect_remove_sco_link_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_MAX_SLOT:
++              dissect_max_slot(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_MAX_SLOT_REQ:
++              dissect_max_slot_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_TIMING_ACCURACY_REQ:
++              dissect_timing_accuracy_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_TIMING_ACCURACY_RES:
++              dissect_timing_accuracy_res(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_SETUP_COMPLETE:
++              dissect_setup_complete(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_USE_SEMI_PERMANENT_KEY:
++              dissect_use_semi_permanent_key(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_HOST_CONNECTION_REQ:
++              dissect_host_connection_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_SLOT_OFFSET:
++              dissect_slot_offset(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_PAGE_MODE_REQ:
++              dissect_page_mode_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_PAGE_SCAN_MODE_REQ:
++              dissect_page_scan_mode_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_SUPERVISION_TIMEOUT:
++              dissect_supervision_timeout(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_TEST_ACTIVATE:
++              dissect_test_activate(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_TEST_CONTROL:
++              dissect_test_control(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_ENCRYPTION_KEY_SIZE_MASK_REQ:
++              dissect_encryption_key_size_mask_req(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_ENCRYPTION_KEY_SIZE_MASK_RES:
++              dissect_encryption_key_size_mask_res(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_SET_AFH:
++              dissect_set_afh(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_ENCAPSULATED_HEADER:
++              dissect_encapsulated_header(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_ENCAPSULATED_PAYLOAD:
++              dissect_encapsulated_payload(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_SIMPLE_PAIRING_CONFIRM:
++              dissect_simple_pairing_confirm(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_SIMPLE_PAIRING_NUMBER:
++              dissect_simple_pairing_number(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_DHKEY_CHECK:
++              dissect_dhkey_check(lmp_tree, tvb, offset, len);
++              break;
++      case LMP_ESCAPE_1:
++              break;
++      case LMP_ESCAPE_2:
++              break;
++      case LMP_ESCAPE_3:
++              break;
++      case LMP_ESCAPE_4:
++              /* extended opcode */
++              DISSECTOR_ASSERT(len >= 2);
++              proto_tree_add_item(lmp_tree, hf_lmp_eop, tvb, offset, 1, TRUE);
++              offset += 1;
++
++              switch (eop) {
++              case LMP_ACCEPTED_EXT:
++                      dissect_accepted_ext(lmp_tree, tvb, offset, len);
++                      break;
++              case LMP_NOT_ACCEPTED_EXT:
++                      dissect_not_accepted_ext(lmp_tree, tvb, offset, len);
++                      break;
++              case LMP_FEATURES_REQ_EXT:
++                      dissect_features_req_ext(lmp_tree, tvb, offset, len);
++                      break;
++              case LMP_FEATURES_RES_EXT:
++                      dissect_features_res_ext(lmp_tree, tvb, offset, len);
++                      break;
++              case LMP_PACKET_TYPE_TABLE_REQ:
++                      dissect_packet_type_table_req(lmp_tree, tvb, offset, len);
++                      break;
++              case LMP_ESCO_LINK_REQ:
++                      dissect_esco_link_req(lmp_tree, tvb, offset, len);
++                      break;
++              case LMP_REMOVE_ESCO_LINK_REQ:
++                      dissect_remove_esco_link_req(lmp_tree, tvb, offset, len);
++                      break;
++              case LMP_CHANNEL_CLASSIFICATION_REQ:
++                      dissect_channel_classification_req(lmp_tree, tvb, offset, len);
++                      break;
++              case LMP_CHANNEL_CLASSIFICATION:
++                      dissect_channel_classification(lmp_tree, tvb, offset, len);
++                      break;
++              case LMP_SNIFF_SUBRATING_REQ:
++                      dissect_sniff_subrating_req(lmp_tree, tvb, offset, len);
++                      break;
++              case LMP_SNIFF_SUBRATING_RES:
++                      dissect_sniff_subrating_res(lmp_tree, tvb, offset, len);
++                      break;
++              case LMP_PAUSE_ENCRYPTION_REQ:
++                      dissect_pause_encryption_req(lmp_tree, tvb, offset, len);
++                      break;
++              case LMP_RESUME_ENCRYPTION_REQ:
++                      dissect_resume_encryption_req(lmp_tree, tvb, offset, len);
++                      break;
++              case LMP_IO_CAPABILITY_REQ:
++                      dissect_io_capability_req(lmp_tree, tvb, offset, len);
++                      break;
++              case LMP_IO_CAPABILITY_RES:
++                      dissect_io_capability_res(lmp_tree, tvb, offset, len);
++                      break;
++              case LMP_NUMERIC_COMPARISON_FAILED:
++                      dissect_numeric_comparison_failed(lmp_tree, tvb, offset, len);
++                      break;
++              case LMP_PASSKEY_FAILED:
++                      dissect_passkey_failed(lmp_tree, tvb, offset, len);
++                      break;
++              case LMP_OOB_FAILED:
++                      dissect_oob_failed(lmp_tree, tvb, offset, len);
++                      break;
++              case LMP_KEYPRESS_NOTIFICATION:
++                      dissect_keypress_notification(lmp_tree, tvb, offset, len);
++                      break;
++              case LMP_POWER_CONTROL_REQ:
++                      dissect_power_control_req(lmp_tree, tvb, offset, len);
++                      break;
++              case LMP_POWER_CONTROL_RES:
++                      dissect_power_control_res(lmp_tree, tvb, offset, len);
++                      break;
++              default:
++                      break;
++              }
++      default:
++              break;
++      }
++};
++
++/* register the protocol with Wireshark */
++void
++proto_register_btlmp(void)
++{
++
++      /* list of fields */
++      static hf_register_info hf[] = {
++              { &hf_lmp_accscheme,
++                      { "Access Scheme", "btlmp.accscheme",
++                      FT_UINT8, BASE_DEC, VALS(access_scheme), 0xf0,
++                      "Access Scheme", HFILL }
++              },
++              { &hf_lmp_afhchmap,
++                      { "AFH Channel Map", "btlmp.afhchmap",
++                      /* could break out individual channels but long */
++                      FT_BYTES, BASE_NONE, NULL, 0x0,
++                      "Adaptive Frequency Hopping Channel Map", HFILL }
++              },
++              { &hf_lmp_afhclass,
++                      { "AFH Channel Classification", "btlmp.afhclass",
++                      /* could break out individual channels but long */
++                      FT_BYTES, BASE_NONE, NULL, 0x0,
++                      "Adaptive Frequency Hopping Channel Classification", HFILL }
++              },
++              { &hf_lmp_afhinst,
++                      { "AFH Instant", "btlmp.afhinst",
++                      FT_UINT32, BASE_HEX, NULL, 0x0,
++                      "Adaptive Frequency Hopping Instant (slot)", HFILL }
++              },
++              { &hf_lmp_afhmaxintvl,
++                      { "AFH Max Interval", "btlmp.maxintvl",
++                      FT_UINT16, BASE_HEX, NULL, 0x0,
++                      "Adaptive Maximum Interval in slots", HFILL }
++              },
++              { &hf_lmp_afhminintvl,
++                      { "AFH Min Interval", "btlmp.minintvl",
++                      FT_UINT16, BASE_HEX, NULL, 0x0,
++                      "Adaptive Minimum Interval in slots", HFILL }
++              },
++              { &hf_lmp_afhmode,
++                      { "AFH Mode", "btlmp.afhmode",
++                      FT_UINT8, BASE_DEC, VALS(afh_mode), 0x0,
++                      "Adaptive Frequency Hopping Mode", HFILL }
++              },
++              { &hf_lmp_afhrptmode,
++                      { "AFH Reporting Mode", "btlmp.afhrptmode",
++                      FT_UINT8, BASE_DEC, VALS(afh_reporting_mode), 0x0,
++                      "Adaptive Frequency Hopping Reporting Mode", HFILL }
++              },
++              { &hf_lmp_airmode,
++                      { "Air Mode", "btlmp.airmode",
++                      FT_UINT8, BASE_HEX, VALS(air_mode), 0x0,
++                      "Air Mode", HFILL }
++              },
++              { &hf_lmp_araddr,
++                      { "AR_ADDR", "btlmp.araddr",
++                      FT_UINT8, BASE_HEX, NULL, 0xfe,
++                      "AR_ADDR", HFILL }
++              },
++              { &hf_lmp_authreqs,
++                      { "Authentication Requirements", "btlmp.authreqs",
++                      FT_UINT8, BASE_HEX, VALS(auth_requirements), 0xf0,
++                      "Authentication Requirements", HFILL }
++              },
++              { &hf_lmp_authres,
++                      { "Authentication Response", "btlmp.authres",
++                      FT_BYTES, BASE_NONE, NULL, 0x0,
++                      "Authentication Response", HFILL }
++              },
++              { &hf_lmp_bdaddr,
++                      { "BD_ADDR", "btlmp.bdaddr",
++                      FT_UINT64, BASE_HEX, NULL, 0x0000ffffffffffff,
++                      "BD_ADDR", HFILL }
++              },
++              { &hf_lmp_bdaddr1,
++                      { "BD_ADDR 1", "btlmp.bdaddr",
++                      FT_UINT64, BASE_HEX, NULL, 0x0000ffffffffffff,
++                      "BD_ADDR 1", HFILL }
++              },
++              { &hf_lmp_bdaddr2,
++                      { "BD_ADDR2", "btlmp.bdaddr",
++                      FT_UINT64, BASE_HEX, NULL, 0x0000ffffffffffff,
++                      "BD_ADDR 2", HFILL }
++              },
++              { &hf_lmp_bsw,
++                      { "Broadcast Scan Window", "btlmp.bsw",
++                      FT_UINT16, BASE_HEX, NULL, 0x0,
++                      "Broadcast Scan Window in slots", HFILL }
++              },
++              { &hf_lmp_clkoffset,
++                      { "Clock Offset", "btlmp.clkoffset",
++                      FT_UINT16, BASE_DEC, NULL, 0x0,
++                      "Clock Offset in units of 1.25 ms", HFILL }
++              },
++              { &hf_lmp_commit,
++                      { "Commitment Value", "btlmp.commit",
++                      FT_BYTES, BASE_NONE, NULL, 0x0,
++                      "Commitment Value", HFILL }
++              },
++              { &hf_lmp_confirm,
++                      { "Confirmation Value", "btlmp.confirm",
++                      FT_BYTES, BASE_NONE, NULL, 0x0,
++                      "Confirmation Value", HFILL }
++              },
++              { &hf_lmp_compid,
++                      { "Company ID", "btlmp.compid",
++                      FT_UINT16, BASE_DEC, VALS(compid), 0x0,
++                      "Company ID", HFILL }
++              },
++              { &hf_lmp_cryptmode,
++                      { "Encryption Mode", "btlmp.cryptmode",
++                      FT_UINT8, BASE_DEC, VALS(encryption_mode), 0x0,
++                      "Encryption Mode", HFILL }
++              },
++              { &hf_lmp_daccess,
++                      { "Daccess", "btlmp.daccess",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "Daccess in slots", HFILL }
++              },
++              { &hf_lmp_db,
++                      { "Db", "btlmp.db",
++                      FT_UINT16, BASE_HEX, NULL, 0x0,
++                      "Db in slots", HFILL }
++              },
++              { &hf_lmp_dbsleep,
++                      { "Dbsleep", "btlmp.dbsleep",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "Dbsleep", HFILL }
++              },
++              { &hf_lmp_deltab,
++                      { "Deltab", "btlmp.deltab",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "Deltab in slots", HFILL }
++              },
++              { &hf_lmp_desco,
++                      { "Desco", "btlmp.desco",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "Desco in slots", HFILL }
++              },
++              { &hf_lmp_drift,
++                      { "Drift", "btlmp.drift",
++                      FT_UINT8, BASE_DEC, NULL, 0x0,
++                      "Drift in ppm", HFILL }
++              },
++              { &hf_lmp_dsco,
++                      { "Dsco", "btlmp.dsco",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "Dsco in slots", HFILL }
++              },
++              { &hf_lmp_dsniff,
++                      { "Dsniff", "btlmp.dsniff",
++                      FT_UINT16, BASE_HEX, NULL, 0x0,
++                      "Dsniff in slots", HFILL }
++              },
++              { &hf_lmp_encdata,
++                      { "Encapsulated Data", "btlmp.encdata",
++                      FT_BYTES, BASE_NONE, NULL, 0x0,
++                      "Encapsulated Data", HFILL }
++              },
++              { &hf_lmp_enclen,
++                      { "Encapsulated Length", "btlmp.enclen",
++                      FT_UINT8, BASE_DEC, NULL, 0x0,
++                      "Encapsulated Length", HFILL }
++              },
++              { &hf_lmp_encmaj,
++                      { "Encapsulated Major Type", "btlmp.encmaj",
++                      FT_UINT8, BASE_DEC, NULL, 0x0,
++                      "Encapsulated Major Type", HFILL }
++              },
++              { &hf_lmp_encmin,
++                      { "Encapsulated Minor Type", "btlmp.encmin",
++                      FT_UINT8, BASE_DEC, NULL, 0x0,
++                      "Encapsulated Minor Type", HFILL }
++              },
++              { &hf_lmp_eop,
++                      { "Extended Opcode", "btlmp.eop",
++                      FT_UINT8, BASE_DEC, VALS(ext_opcode), 0x0,
++                      "Extended Opcode", HFILL }
++              },
++              { &hf_lmp_eopinre,
++                      { "In Response To", "btlmp.eopinre",
++                      FT_UINT8, BASE_DEC, VALS(ext_opcode), 0x0,
++                      "Extended Opcode this is in response to", HFILL }
++              },
++              { &hf_lmp_escolenms,
++                      { "Packet Length M -> S", "btlmp.escolenms",
++                      FT_UINT16, BASE_DEC, NULL, 0x0,
++                      "Packet Length in bytes Master to Slave", HFILL }
++              },
++              { &hf_lmp_escolensm,
++                      { "Packet Length S -> M", "btlmp.escolensm",
++                      FT_UINT16, BASE_DEC, NULL, 0x0,
++                      "Packet Length in bytes Slave to Master", HFILL }
++              },
++              { &hf_lmp_escotypems,
++                      { "eSCO Packet Type M -> S", "btlmp.escotypems",
++                      FT_UINT8, BASE_HEX, VALS(esco_packet_type), 0x0,
++                      "eSCO Packet Type Master to Slave", HFILL }
++              },
++              { &hf_lmp_escotypesm,
++                      { "eSCO Packet Type S -> M", "btlmp.escotypesm",
++                      FT_UINT8, BASE_HEX, VALS(esco_packet_type), 0x0,
++                      "eSCO Packet Type Slave to Master", HFILL }
++              },
++              { &hf_lmp_err,
++                      { "Error Code", "btlmp.err",
++                      FT_UINT8, BASE_HEX, VALS(error_code), 0x0,
++                      "Error Code", HFILL }
++              },
++              { &hf_lmp_escohdl,
++                      { "eSCO Handle", "btlmp.escohdl",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "eSCO Handle", HFILL }
++              },
++              { &hf_lmp_escoltaddr,
++                      { "eSCO LT_ADDR", "btlmp.escoltaddr",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "eSCO Logical Transport Address", HFILL }
++              },
++              { &hf_lmp_features,
++                      { "Features", "btlmp.features",
++                      /* could break out individual features but long */
++                      FT_BYTES, BASE_NONE, NULL, 0x0,
++                      "Feature Mask", HFILL }
++              },
++              { &hf_lmp_fpage,
++                      { "Features Page", "btlmp.fpage",
++                      FT_UINT8, BASE_DEC, VALS(features_page), 0x0,
++                      "Features Page", HFILL }
++              },
++              { &hf_lmp_htime,
++                      { "Hold Time", "btlmp.htime",
++                      FT_UINT16, BASE_HEX, NULL, 0x0,
++                      "Hold Time in slots", HFILL }
++              },
++              { &hf_lmp_hinst,
++                      { "Hold Instant", "btlmp.hinst",
++                      FT_UINT32, BASE_HEX, NULL, 0x0,
++                      "Hold Instant (slot)", HFILL }
++              },
++              { &hf_lmp_hopmode,
++                      { "Hopping Mode", "btlmp.hopmode",
++                      FT_UINT8, BASE_DEC, VALS(hopping_mode), 0x0,
++                      "Hopping Mode", HFILL }
++              },
++              { &hf_lmp_iocaps,
++                      { "IO Capabilities", "btlmp.iocaps",
++                      FT_UINT8, BASE_DEC, VALS(io_capabilities), 0x0,
++                      "Input/Output Capabilities", HFILL }
++              },
++              { &hf_lmp_jitter,
++                      { "Jitter", "btlmp.jitter",
++                      FT_UINT8, BASE_DEC, NULL, 0x0,
++                      "Jitter in microseconds", HFILL }
++              },
++              { &hf_lmp_key,
++                      { "Key", "btlmp.key",
++                      FT_BYTES, BASE_NONE, NULL, 0x0,
++                      "Key", HFILL }
++              },
++              { &hf_lmp_keysz,
++                      { "Key Size", "btlmp.keysz",
++                      FT_UINT8, BASE_DEC, NULL, 0x0,
++                      "Key Size in bytes", HFILL }
++              },
++              { &hf_lmp_ksmask,
++                      { "Key Size Mask", "btlmp.ksmask",
++                      FT_UINT16, BASE_HEX, NULL, 0x0,
++                      "Key Size Mask", HFILL }
++              },
++              { &hf_lmp_ltaddr1,
++                      { "LT_ADDR 1", "btlmp.ltaddr",
++                      FT_UINT8, BASE_HEX, NULL, 0x0f,
++                      "Logical Transport Address 1", HFILL }
++              },
++              { &hf_lmp_ltaddr2,
++                      { "LT_ADDR 2", "btlmp.ltaddr",
++                      FT_UINT8, BASE_HEX, NULL, 0xf0,
++                      "Logical Transport Address 2", HFILL }
++              },
++              { &hf_lmp_ltaddr3,
++                      { "LT_ADDR 3", "btlmp.ltaddr",
++                      FT_UINT8, BASE_HEX, NULL, 0x0f,
++                      "Logical Transport Address 3", HFILL }
++              },
++              { &hf_lmp_ltaddr4,
++                      { "LT_ADDR 4", "btlmp.ltaddr",
++                      FT_UINT8, BASE_HEX, NULL, 0xf0,
++                      "Logical Transport Address 4", HFILL }
++              },
++              { &hf_lmp_ltaddr5,
++                      { "LT_ADDR 5", "btlmp.ltaddr",
++                      FT_UINT8, BASE_HEX, NULL, 0x0f,
++                      "Logical Transport Address 5", HFILL }
++              },
++              { &hf_lmp_ltaddr6,
++                      { "LT_ADDR 6", "btlmp.ltaddr",
++                      FT_UINT8, BASE_HEX, NULL, 0xf0,
++                      "Logical Transport Address 6", HFILL }
++              },
++              { &hf_lmp_ltaddr7,
++                      { "LT_ADDR 7", "btlmp.ltaddr",
++                      FT_UINT8, BASE_HEX, NULL, 0x0f,
++                      "Logical Transport Address 7", HFILL }
++              },
++              { &hf_lmp_maccess,
++                      { "Maccess", "btlmp.maccess",
++                      FT_UINT8, BASE_HEX, NULL, 0x0f,
++                      "Number of access windows", HFILL }
++              },
++              { &hf_lmp_maxslots,
++                      { "Max Slots", "btlmp.maxslots",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "Max Slots", HFILL }
++              },
++              { &hf_lmp_maxsp,
++                      { "Max Supported Page", "btlmp.maxsp",
++                      FT_UINT8, BASE_DEC, NULL, 0x0,
++                      "Highest extended features page with non-zero bit", HFILL }
++              },
++              { &hf_lmp_maxss,
++                      { "Max Sniff Subrate", "btlmp.maxss",
++                      FT_UINT8, BASE_DEC, NULL, 0x0,
++                      "Max Sniff Subrate", HFILL }
++              },
++              { &hf_lmp_minsmt,
++                      { "Min Sniff Mode Timeout", "btlmp.minsmt",
++                      FT_UINT16, BASE_HEX, NULL, 0x0,
++                      "Min Sniff Mode Timeout in slots", HFILL }
++              },
++              { &hf_lmp_naccslots,
++                      { "Nacc-slots", "btlmp.naccslots",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "Nacc-slots", HFILL }
++              },
++              { &hf_lmp_namefrag,
++                      { "Name Fragment", "btlmp.namefrag",
++                      FT_STRING, BASE_NONE, NULL, 0x0,
++                      "Name Fragment", HFILL }
++              },
++              { &hf_lmp_namelen,
++                      { "Name Length", "btlmp.namelen",
++                      FT_UINT8, BASE_DEC, NULL, 0x0,
++                      "Name Length in bytes", HFILL }
++              },
++              { &hf_lmp_nameoffset,
++                      { "Name Offset", "btlmp.nameoffset",
++                      FT_UINT8, BASE_DEC, NULL, 0x0,
++                      "Name Offset in bytes", HFILL }
++              },
++              { &hf_lmp_nb,
++                      { "Nb", "btlmp.nb",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "Nb", HFILL }
++              },
++              { &hf_lmp_nbc,
++                      { "Nbc", "btlmp.nbc",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "Nbc", HFILL }
++              },
++              { &hf_lmp_nbsleep,
++                      { "Nbsleep", "btlmp.nbsleep",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "Nbsleep", HFILL }
++              },
++              { &hf_lmp_negstate,
++                      { "Negotiation State", "btlmp.negstate",
++                      FT_UINT8, BASE_DEC, VALS(negotiation_state), 0x0,
++                      "Negotiation State", HFILL }
++              },
++              { &hf_lmp_nonce,
++                      { "Nonce Value", "btlmp.nonce",
++                      FT_BYTES, BASE_NONE, NULL, 0x0,
++                      "Nonce Value", HFILL }
++              },
++              { &hf_lmp_nottype,
++                      { "Notification Type", "btlmp.nottype",
++                      FT_UINT8, BASE_DEC, VALS(notification_value), 0x0,
++                      "Notification Type", HFILL }
++              },
++              { &hf_lmp_npoll,
++                      { "Npoll", "btlmp.npoll",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "Npoll", HFILL }
++              },
++              { &hf_lmp_oobauthdata,
++                      { "OOB Authentication Data", "btlmp.oobauthdata",
++                      FT_UINT8, BASE_DEC, VALS(oob_auth_data), 0xfe,
++                      "OOB Authentication Data", HFILL }
++              },
++              { &hf_lmp_op,
++                      { "Opcode", "btlmp.op",
++                      FT_UINT8, BASE_DEC, VALS(opcode), 0xfe,
++                      "Opcode", HFILL }
++              },
++              { &hf_lmp_opinre,
++                      { "In Response To", "btlmp.opinre",
++                      FT_UINT8, BASE_DEC, VALS(opcode), 0x7f,
++                      "Opcode this is in response to", HFILL }
++              },
++              { &hf_lmp_pagesch,
++                      { "Paging Scheme", "btlmp.pagesch",
++                      FT_UINT8, BASE_DEC, VALS(paging_scheme), 0x0,
++                      "Paging Scheme", HFILL }
++              },
++              { &hf_lmp_pcmode,
++                      { "Power Control Mode", "btlmp.pcmode",
++                      FT_UINT8, BASE_DEC, VALS(power_control_mode), 0x0,
++                      "Power Control Mode", HFILL }
++              },
++              { &hf_lmp_pkttype,
++                      { "Packet Type", "btlmp.pkttype",
++                      /* FIXME break out further */
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "Packet Type", HFILL }
++              },
++              { &hf_lmp_pkttypetbl,
++                      { "Packet Type Table", "btlmp.pkttypetbl",
++                      FT_UINT8, BASE_DEC, VALS(packet_type_table), 0x0,
++                      "Packet Type Table", HFILL }
++              },
++              { &hf_lmp_pmaddr,
++                      { "PM_ADDR", "btlmp.pmaddr",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "PM_ADDR", HFILL }
++              },
++              { &hf_lmp_pmaddr1,
++                      { "PM_ADDR 1", "btlmp.pmaddr1",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "PM_ADDR 1", HFILL }
++              },
++              { &hf_lmp_pmaddr2,
++                      { "PM_ADDR 2", "btlmp.pmaddr2",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "PM_ADDR 2", HFILL }
++              },
++              { &hf_lmp_pmaddr3,
++                      { "PM_ADDR 3", "btlmp.pmaddr3",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "PM_ADDR 3", HFILL }
++              },
++              { &hf_lmp_pmaddr4,
++                      { "PM_ADDR 4", "btlmp.pmaddr4",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "PM_ADDR 4", HFILL }
++              },
++              { &hf_lmp_pmaddr5,
++                      { "PM_ADDR 5", "btlmp.pmaddr5",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "PM_ADDR 5", HFILL }
++              },
++              { &hf_lmp_pmaddr6,
++                      { "PM_ADDR 6", "btlmp.pmaddr6",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "PM_ADDR 6", HFILL }
++              },
++              { &hf_lmp_pmaddr7,
++                      { "PM_ADDR 7", "btlmp.pmaddr7",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "PM_ADDR 7", HFILL }
++              },
++              { &hf_lmp_pollintvl,
++                      { "Poll Interval", "btlmp.pollintvl",
++                      FT_UINT16, BASE_HEX, NULL, 0x0,
++                      "Poll Interval in slots", HFILL }
++              },
++              { &hf_lmp_pollper,
++                      { "Poll Period", "btlmp.pollper",
++                      FT_UINT8, BASE_DEC, NULL, 0x0,
++                      "Poll Period in units of 1.25 ms", HFILL }
++              },
++              { &hf_lmp_pssettings,
++                      { "Paging Scheme Settings", "btlmp.pssettings",
++                      FT_UINT8, BASE_DEC, VALS(paging_scheme_settings), 0x0,
++                      "Paging Scheme Settings", HFILL }
++              },
++              { &hf_lmp_pwradjreq,
++                      { "Power Adjustment Request", "btlmp.pwradjreq",
++                      FT_UINT8, BASE_DEC, VALS(power_adjust_req), 0x0,
++                      "Power Adjustment Request", HFILL }
++              },
++              { &hf_lmp_pwradjres,
++                      { "Power Adjustment Response", "btlmp.pwradjres",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "Power Adjustment Response", HFILL }
++              },
++              { &hf_lmp_pwradj_8dpsk,
++                      { "8DPSK", "btlmp.pwradj_8dpsk",
++                      FT_UINT8, BASE_DEC, VALS(power_adjust_res), 0x30,
++                      "8DPSK Power Adjustment Response", HFILL }
++              },
++              { &hf_lmp_pwradj_dqpsk,
++                      { "DQPSK", "btlmp.pwradj_dqpsk",
++                      FT_UINT8, BASE_DEC, VALS(power_adjust_res), 0x0C,
++                      "DQPSK Power Adjustment Response", HFILL }
++              },
++              { &hf_lmp_pwradj_gfsk,
++                      { "GFSK", "btlmp.pwradj_gfsk",
++                      FT_UINT8, BASE_DEC, VALS(power_adjust_res), 0x03,
++                      "GFSK Power Adjustment Response", HFILL }
++              },
++              { &hf_lmp_rand,
++                      { "Random Number", "btlmp.rand",
++                      FT_BYTES, BASE_NONE, NULL, 0x0,
++                      "Random Number", HFILL }
++              },
++              { &hf_lmp_rate,
++                      { "Data Rate", "btlmp.rate",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "Data Rate", HFILL }
++              },
++              { &hf_lmp_rate_fec,
++                      { "FEC", "btlmp.rate.fec",
++                      FT_BOOLEAN, BASE_DEC, TFS(&fec), 0x01,
++                      "Forward Error Correction", HFILL }
++              },
++              { &hf_lmp_rate_size,
++                      { "Packet Size", "btlmp.rate.size",
++                      FT_UINT8, BASE_HEX, VALS(packet_size), 0x06,
++                      "Basic Rate Packet Size", HFILL }
++              },
++              { &hf_lmp_rate_type,
++                      { "EDR Type", "btlmp.rate.type",
++                      FT_UINT8, BASE_HEX, VALS(edr_type), 0x18,
++                      "Enhanced Data Rate type", HFILL }
++              },
++              { &hf_lmp_rate_edrsize,
++                      { "EDR Size", "btlmp.rate.edrsize",
++                      FT_UINT8, BASE_HEX, VALS(packet_size), 0x60,
++                      "Enhanced Data Rate packet size", HFILL }
++              },
++              { &hf_lmp_rxfreq,
++                      { "RX Frequency", "btlmp.rxfreq",
++                      FT_UINT8, BASE_DEC, NULL, 0x0,
++                      "Receive Frequency in MHz above 2402", HFILL }
++              },
++              { &hf_lmp_scohdl,
++                      { "SCO Handle", "btlmp.scohdl",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "SCO Handle", HFILL }
++              },
++              { &hf_lmp_scopkt,
++                      { "SCO Packet", "btlmp.scopkt",
++                      FT_UINT8, BASE_DEC, VALS(sco_packet), 0x0,
++                      "SCO Packet", HFILL }
++              },
++              { &hf_lmp_slotoffset,
++                      { "Slot Offset", "btlmp.slotoffset",
++                      FT_UINT16, BASE_DEC, NULL, 0x0,
++                      "Slot Offset in microseconds", HFILL }
++              },
++              { &hf_lmp_sniffatt,
++                      { "Sniff Attempt", "btlmp.sniffatt",
++                      FT_UINT16, BASE_HEX, NULL, 0x0,
++                      "Number of receive slots", HFILL }
++              },
++              { &hf_lmp_sniffsi,
++                      { "Sniff Subrating Instant", "btlmp.sniffsi",
++                      FT_UINT32, BASE_HEX, NULL, 0x0,
++                      "Sniff Subrating Instant (slot)", HFILL }
++              },
++              { &hf_lmp_sniffto,
++                      { "Sniff Timeout", "btlmp.sniffto",
++                      FT_UINT16, BASE_HEX, NULL, 0x0,
++                      "Number of receive slots", HFILL }
++              },
++              { &hf_lmp_subversnr,
++                      { "SubVersNr", "btlmp.subversnr",
++                      FT_UINT16, BASE_DEC, NULL, 0x0,
++                      "SubVersion", HFILL }
++              },
++              { &hf_lmp_suptimeout,
++                      { "Supervision Timeout", "btlmp.suptimeout",
++                      FT_UINT16, BASE_HEX, NULL, 0x0,
++                      "Supervision Timeout in slots", HFILL }
++              },
++              { &hf_lmp_swinst,
++                      { "Switch Instant", "btlmp.swinst",
++                      FT_UINT32, BASE_HEX, NULL, 0x0,
++                      "Switch Instant (slot)", HFILL }
++              },
++              { &hf_lmp_taccess,
++                      { "Taccess", "btlmp.taccess",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "Taccess in slots", HFILL }
++              },
++              { &hf_lmp_tb,
++                      { "Tb", "btlmp.tb",
++                      FT_UINT16, BASE_HEX, NULL, 0x0,
++                      "Tb in slots", HFILL }
++              },
++              { &hf_lmp_tesco,
++                      { "Tesco", "btlmp.tesco",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "Tesco in slots", HFILL }
++              },
++              { &hf_lmp_testlen,
++                      { "Test Length", "btlmp.testlen",
++                      FT_UINT16, BASE_DEC, NULL, 0x0,
++                      "Length of test sequence in bytes", HFILL }
++              },
++              { &hf_lmp_testscen,
++                      { "Test Scenario", "btlmp.testscen",
++                      FT_UINT8, BASE_DEC, VALS(test_scenario), 0x0,
++                      "Test Scenario", HFILL }
++              },
++              { &hf_lmp_tid,
++                      { "TID", "btlmp.tid",
++                      FT_BOOLEAN, BASE_DEC, TFS(&tid), 0x01,
++                      "Transaction ID", HFILL }
++              },
++              { &hf_lmp_timectrl,
++                      { "Timing Control Flags", "btlmp.timectrl",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "Timing Control Flags", HFILL }
++              },
++              { &hf_lmp_time_change,
++                      { "Timing Change", "btlmp.time.change",
++                      FT_BOOLEAN, 8, TFS(&time_change), 0x01,
++                      "Timing Change", HFILL }
++              },
++              { &hf_lmp_time_init,
++                      { "Initialization", "btlmp.time.init",
++                      FT_BOOLEAN, 8, TFS(&time_init), 0x02,
++                      "Initialization", HFILL }
++              },
++              { &hf_lmp_time_accwin,
++                      { "Access Window", "btlmp.time.accwin",
++                      FT_BOOLEAN, 8, TFS(&time_accwin), 0x04,
++                      "Access Window", HFILL }
++              },
++              { &hf_lmp_tsco,
++                      { "Tsco", "btlmp.tsco",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "Tsco in slots", HFILL }
++              },
++              { &hf_lmp_tsniff,
++                      { "Tsniff", "btlmp.tsniff",
++                      FT_UINT16, BASE_HEX, NULL, 0x0,
++                      "Tsniff in slots", HFILL }
++              },
++              { &hf_lmp_txfreq,
++                      { "TX Frequency", "btlmp.txfreq",
++                      FT_UINT8, BASE_DEC, NULL, 0x0,
++                      "Transmit Frequency in MHz above 2402", HFILL }
++              },
++              { &hf_lmp_versnr,
++                      { "VersNr", "btlmp.versnr",
++                      FT_UINT8, BASE_DEC, VALS(versnr), 0x0,
++                      "Version", HFILL }
++              },
++              { &hf_lmp_wesco,
++                      { "Wesco", "btlmp.wesco",
++                      FT_UINT8, BASE_HEX, NULL, 0x0,
++                      "Number of slots in retransmission window", HFILL }
++              },
++      };
++
++      /* protocol subtree arrays */
++      static gint *ett[] = {
++              &ett_lmp,
++              &ett_lmp_pwradjres,
++              &ett_lmp_rate,
++              &ett_lmp_timectrl,
++      };
++
++      /* register the protocol name and description */
++      proto_btlmp = proto_register_protocol(
++              "Bluetooth Link Manager Protocol",      /* full name */
++              "btlmp",                /* short name */
++              "btlmp"                 /* abbreviation (e.g. for filters) */
++              );
++
++      register_dissector("btlmp", dissect_btlmp, proto_btlmp);
++
++      /* register the header fields and subtrees used */
++      proto_register_field_array(proto_btlmp, hf, array_length(hf));
++      proto_register_subtree_array(ett, array_length(ett));
++}
++
++void
++proto_reg_handoff_btlmp(void)
++{
++}
+diff -Naur wireshark-1.8.4/plugins/btbb/plugin.rc.in wireshark/plugins/btbb/plugin.rc.in
+--- wireshark-1.8.4/plugins/btbb/plugin.rc.in  1969-12-31 19:00:00.000000000 -0500
++++ wireshark/plugins/btbb/plugin.rc.in        2013-01-26 15:04:24.671077378 -0500
+@@ -0,0 +1,34 @@
++#include "winver.h"
++
++VS_VERSION_INFO VERSIONINFO
++ FILEVERSION @RC_MODULE_VERSION@
++ PRODUCTVERSION @RC_VERSION@
++ FILEFLAGSMASK 0x0L
++#ifdef _DEBUG
++ FILEFLAGS VS_FF_DEBUG
++#else
++ FILEFLAGS 0
++#endif
++ FILEOS VOS_NT_WINDOWS32
++ FILETYPE VFT_DLL
++BEGIN
++    BLOCK "StringFileInfo"
++    BEGIN
++        BLOCK "040904b0"
++        BEGIN
++            VALUE "CompanyName", "The Wireshark developer community, http://www.wireshark.org/\0"
++            VALUE "FileDescription", "@PACKAGE@ dissector\0"
++            VALUE "FileVersion", "@MODULE_VERSION@\0"
++            VALUE "InternalName", "@PACKAGE@ @MODULE_VERSION@\0"
++            VALUE "LegalCopyright", "Copyright © 1998 Gerald Combs <gerald@wireshark.org>, Gilbert Ramirez <gram@alumni.rice.edu> and others\0"
++            VALUE "OriginalFilename", "@PLUGIN_NAME@.dll\0"
++            VALUE "ProductName", "Wireshark\0"
++            VALUE "ProductVersion", "@VERSION@\0"
++            VALUE "Comments", "Build with @MSVC_VARIANT@\0"
++        END
++    END
++    BLOCK "VarFileInfo"
++    BEGIN
++        VALUE "Translation", 0x409, 1200
++    END
++END
+diff -Naur wireshark-1.8.4/plugins/btbb/README wireshark/plugins/btbb/README
+--- wireshark-1.8.4/plugins/btbb/README        1969-12-31 19:00:00.000000000 -0500
++++ wireshark/plugins/btbb/README      2013-01-26 15:04:24.667077358 -0500
+@@ -0,0 +1,26 @@
++BTBB Wireshark plugin
++
++This is the Bluetooth baseband plugin for Wireshark, it also includes an LMP
++level dissector.
++
++To build this on Debian/Ubuntu/BackTrack linux distributions:
++  sudo apt-get install wireshark-dev wireshark
++  cd libbtbb/wireshark/plugins/btbb/
++  cmake .
++  make
++  make install
++
++This will install to the .wireshark/ in your home directory.  To override this
++set the DESTDIR environment variable when running cmake.
++
++To build the plugin as part of wireshark, use the following commands:
++  tar xf wireshark-1.8.2.tar.bz2
++  cp -R libbtbb/wireshark/plugins/btbb wireshark-1.8.2/plugins/
++  patch -p0 < wireshark-1.8.2/plugins/btbb/wireshark-1.8-btbb.patch
++
++  cd wireshark-1.8.2
++  ./autogen.sh
++  ./configure
++  make
++  sudo make install
++
+diff -Naur wireshark-1.8.4/plugins/btbb/tools/make-dissector-reg wireshark/plugins/btbb/tools/make-dissector-reg
+--- wireshark-1.8.4/plugins/btbb/tools/make-dissector-reg      1969-12-31 19:00:00.000000000 -0500
++++ wireshark/plugins/btbb/tools/make-dissector-reg    2013-01-26 15:04:24.671077378 -0500
+@@ -0,0 +1,186 @@
++#! /bin/sh
++
++#
++# $Id: make-dissector-reg 21716 2007-05-07 17:55:42Z gal $
++#
++
++#
++# The first argument is the directory in which the source files live.
++#
++srcdir="$1"
++shift
++
++#
++# The second argument is either "plugin" or "dissectors"; if it's
++# "plugin", we build a plugin.c for a plugin, and if it's
++# "dissectors", we build a register.c for libwireshark.
++#
++registertype="$1"
++shift
++if [ "$registertype" = plugin ]
++then
++      outfile="plugin.c"
++elif [ "$registertype" = dissectors ]
++then
++      outfile="register.c"
++else
++      echo "Unknown output type '$registertype'" 1>&2
++      exit 1
++fi
++
++#
++# All subsequent arguments are the files to scan.
++#
++rm -f ${outfile}-tmp
++echo '/* Do not modify this file.  */' >${outfile}-tmp
++echo '/* It is created automatically by the Makefile. */'>>${outfile}-tmp
++if [ "$registertype" = plugin ]
++then
++      cat <<"EOF" >>${outfile}-tmp
++#ifdef HAVE_CONFIG_H
++# include "config.h"
++#endif
++
++#include <gmodule.h>
++
++#include "moduleinfo.h"
++
++#ifndef ENABLE_STATIC
++G_MODULE_EXPORT const gchar version[] = VERSION;
++
++/* Start the functions we need for the plugin stuff */
++
++G_MODULE_EXPORT void
++plugin_register (void)
++{
++EOF
++#
++# Build code to call all the protocol registration routines.
++#
++for f in "$@"
++do
++      if [ -f $f ]
++      then
++              srcfile=$f
++      else
++              srcfile=$srcdir/$f
++      fi
++      grep '^proto_register_[a-z_0-9A-Z]* *(' $srcfile 2>/dev/null | grep -v ';'
++done | sed -e 's/^.*://' -e 's/^\([a-z_0-9A-Z]*\).*/  {extern void \1 (void); \1 ();}/' >>${outfile}-tmp
++for f in "$@"
++do
++      if [ -f $f ]
++      then
++              srcfile=$f
++      else
++              srcfile=$srcdir/$f
++      fi
++      grep '^void proto_register_[a-z_0-9A-Z]* *(' $srcfile 2>/dev/null | grep -v ';'
++done | sed -e 's/^.*://' -e 's/^void \([a-z_0-9A-Z]*\).*/  {extern void \1 (void); \1 ();}/' >>${outfile}-tmp
++else
++      cat <<"EOF" >>${outfile}-tmp
++#include "register.h"
++void
++register_all_protocols(register_cb cb, gpointer client_data)
++{
++EOF
++#
++# Build code to call all the protocol registration routines.
++#
++for f in "$@"
++do
++      if [ -f $f ]
++      then
++              srcfile=$f
++      else
++              srcfile=$srcdir/$f
++      fi
++      grep '^proto_register_[a-z_0-9A-Z]* *(' $srcfile 2>/dev/null | grep -v ';'
++done | sed -e 's/^.*://' -e 's/^\([a-z_0-9A-Z]*\).*/  {extern void \1 (void); if(cb) (*cb)(RA_REGISTER, \"\1\", client_data); \1 ();}/' >>${outfile}-tmp
++for f in "$@"
++do
++      if [ -f $f ]
++      then
++              srcfile=$f
++      else
++              srcfile=$srcdir/$f
++      fi
++      grep '^void proto_register_[a-z_0-9A-Z]* *(' $srcfile 2>/dev/null | grep -v ';'
++done | sed -e 's/^.*://' -e 's/^void \([a-z_0-9A-Z]*\).*/  {extern void \1 (void); if(cb) (*cb)(RA_REGISTER, \"\1\", client_data); \1 ();}/' >>${outfile}-tmp
++
++fi
++echo '}' >>${outfile}-tmp
++
++
++#
++# Build code to call all the protocol handoff registration routines.
++#
++if [ "$registertype" = plugin ]
++then
++      cat <<"EOF" >>${outfile}-tmp
++G_MODULE_EXPORT void
++plugin_reg_handoff(void)
++{
++EOF
++for f in "$@"
++do
++      if [ -f $f ]
++      then
++              srcfile=$f
++      else
++              srcfile=$srcdir/$f
++      fi
++      grep '^proto_reg_handoff_[a-z_0-9A-Z]* *(' $srcfile 2>/dev/null | grep -v ';'
++done | sed -e 's/^.*://' -e 's/^\([a-z_0-9A-Z]*\).*/  {extern void \1 (void); \1 ();}/' >>${outfile}-tmp
++for f in "$@"
++do
++      if [ -f $f ]
++      then
++              srcfile=$f
++      else
++              srcfile=$srcdir/$f
++      fi
++      grep '^void proto_reg_handoff_[a-z_0-9A-Z]* *(' $srcfile 2>/dev/null | grep -v ';'
++done | sed -e 's/^.*://' -e 's/^void \([a-z_0-9A-Z]*\).*/  {extern void \1 (void); \1 ();}/' >>${outfile}-tmp
++else
++      cat <<"EOF" >>${outfile}-tmp
++void
++register_all_protocol_handoffs(register_cb cb, gpointer client_data)
++{
++EOF
++for f in "$@"
++do
++      if [ -f $f ]
++      then
++              srcfile=$f
++      else
++              srcfile=$srcdir/$f
++      fi
++      grep '^proto_reg_handoff_[a-z_0-9A-Z]* *(' $srcfile 2>/dev/null | grep -v ';'
++done | sed -e 's/^.*://' -e 's/^\([a-z_0-9A-Z]*\).*/  {extern void \1 (void); if(cb) (*cb)(RA_HANDOFF, \"\1\", client_data); \1 ();}/' >>${outfile}-tmp
++for f in "$@"
++do
++      if [ -f $f ]
++      then
++              srcfile=$f
++      else
++              srcfile=$srcdir/$f
++      fi
++      grep '^void proto_reg_handoff_[a-z_0-9A-Z]* *(' $srcfile 2>/dev/null | grep -v ';'
++done | sed -e 's/^.*://' -e 's/^void \([a-z_0-9A-Z]*\).*/  {extern void \1 (void); if(cb) (*cb)(RA_HANDOFF, \"\1\", client_data); \1 ();}/' >>${outfile}-tmp
++fi
++echo '}' >>${outfile}-tmp
++if [ "$registertype" = plugin ]
++then
++      echo '#endif' >>${outfile}-tmp
++else 
++      cat <<"EOF" >>${outfile}-tmp
++gulong register_count(void)
++{
++EOF
++      proto_regs=`grep RA_REGISTER ${outfile}-tmp | wc -l`
++      handoff_regs=`grep RA_HANDOFF ${outfile}-tmp | wc -l`
++      echo "  return $proto_regs + $handoff_regs;" >>${outfile}-tmp
++      echo '}' >>${outfile}-tmp
++fi
++mv ${outfile}-tmp ${outfile}
+diff -Naur wireshark-1.8.4/plugins/btbb/tools/make-dissector-reg.py wireshark/plugins/btbb/tools/make-dissector-reg.py
+--- wireshark-1.8.4/plugins/btbb/tools/make-dissector-reg.py   1969-12-31 19:00:00.000000000 -0500
++++ wireshark/plugins/btbb/tools/make-dissector-reg.py 2013-01-26 15:04:24.671077378 -0500
+@@ -0,0 +1,311 @@
++#!/usr/bin/env python
++#
++# Looks for registration routines in the protocol dissectors,
++# and assembles C code to call all the routines.
++#
++# This is a Python version of the make-reg-dotc shell script.
++# Running the shell script on Win32 is very very slow because of
++# all the process-launching that goes on --- multiple greps and
++# seds for each input file.  I wrote this python version so that
++# less processes would have to be started.
++#
++# $Id: make-dissector-reg.py 40736 2012-01-26 21:38:53Z gerald $
++
++import os
++import sys
++import re
++import pickle
++from stat import *
++
++VERSION_KEY = '_VERSION'
++CUR_VERSION = '$Id: make-dissector-reg.py 40736 2012-01-26 21:38:53Z gerald $'
++
++#
++# The first argument is the directory in which the source files live.
++#
++srcdir = sys.argv[1]
++
++#
++# The second argument is either "plugin" or "dissectors"; if it's
++# "plugin", we build a plugin.c for a plugin, and if it's
++# "dissectors", we build a register.c for libwireshark.
++#
++registertype = sys.argv[2]
++if registertype == "plugin" or registertype == "plugin_wtap":
++      tmp_filename = "plugin.c-tmp"
++      final_filename = "plugin.c"
++      cache_filename = None
++      preamble = """\
++/*
++ * Do not modify this file.
++ *
++ * It is created automatically by Makefile or Makefile.nmake.
++ */
++"""
++elif registertype == "dissectors":
++      tmp_filename = "register.c-tmp"
++      final_filename = "register.c"
++      cache_filename = "register-cache.pkl"
++      preamble = """\
++/*
++ * Do not modify this file.
++ *
++ * It is created automatically by the "register.c" target in
++ * epan/dissectors/Makefile or Makefile.nmake using information in
++ * epan/dissectors/register-cache.pkl.
++ *
++ * You can force this file to be regenerated completely by deleting
++ * it along with epan/dissectors/register-cache.pkl.
++ */
++"""
++else:
++      print(("Unknown output type '%s'" % registertype))
++      sys.exit(1)
++
++
++#
++# All subsequent arguments are the files to scan.
++#
++files = sys.argv[3:]
++
++# Create the proper list of filenames
++filenames = []
++for file in files:
++      if os.path.isfile(file):
++              filenames.append(file)
++      else:
++              filenames.append(os.path.join(srcdir, file))
++
++if len(filenames) < 1:
++      print("No files found")
++      sys.exit(1)
++
++
++# Look through all files, applying the regex to each line.
++# If the pattern matches, save the "symbol" section to the
++# appropriate array.
++regs = {
++      'proto_reg': [],
++      'handoff_reg': [],
++      'wtap_register': [],
++      }
++
++# For those that don't know Python, r"" indicates a raw string,
++# devoid of Python escapes.
++proto_regex0 = r"^(?P<symbol>proto_register_[_A-Za-z0-9]+)\s*\([^;]+$"
++proto_regex1 = r"void\s+(?P<symbol>proto_register_[_A-Za-z0-9]+)\s*\([^;]+$"
++
++handoff_regex0 = r"^(?P<symbol>proto_reg_handoff_[_A-Za-z0-9]+)\s*\([^;]+$"
++handoff_regex1 = r"void\s+(?P<symbol>proto_reg_handoff_[_A-Za-z0-9]+)\s*\([^;]+$"
++
++wtap_reg_regex0 = r"^(?P<symbol>wtap_register_[_A-Za-z0-9]+)\s*\([^;]+$"
++wtap_reg_regex1 = r"void\s+(?P<symbol>wtap_register_[_A-Za-z0-9]+)\s*\([^;]+$"
++
++# This table drives the pattern-matching and symbol-harvesting
++patterns = [
++      ( 'proto_reg', re.compile(proto_regex0) ),
++      ( 'proto_reg', re.compile(proto_regex1) ),
++      ( 'handoff_reg', re.compile(handoff_regex0) ),
++      ( 'handoff_reg', re.compile(handoff_regex1) ),
++      ( 'wtap_register', re.compile(wtap_reg_regex0) ),
++      ( 'wtap_register', re.compile(wtap_reg_regex1) ),
++      ]
++
++# Open our registration symbol cache
++cache = None
++if cache_filename:
++      try:
++              cache_file = open(cache_filename, 'rb')
++              cache = pickle.load(cache_file)
++              cache_file.close()
++              if VERSION_KEY not in cache or cache[VERSION_KEY] != CUR_VERSION:
++                      cache = {VERSION_KEY: CUR_VERSION}
++      except:
++              cache = {VERSION_KEY: CUR_VERSION}
++
++      print(("Registering %d files, %d cached" % (len(filenames), len(list(cache.keys()))-1)))
++
++# Grep
++cache_hits = 0
++cache_misses = 0
++for filename in filenames:
++      file = open(filename)
++      cur_mtime = os.fstat(file.fileno())[ST_MTIME]
++      if cache and filename in cache:
++              cdict = cache[filename]
++              if cur_mtime == cdict['mtime']:
++                      cache_hits += 1
++#                     print "Pulling %s from cache" % (filename)
++                      regs['proto_reg'].extend(cdict['proto_reg'])
++                      regs['handoff_reg'].extend(cdict['handoff_reg'])
++                      regs['wtap_register'].extend(cdict['wtap_register'])
++                      file.close()
++                      continue
++      # We don't have a cache entry
++      if cache is not None:
++              cache_misses += 1
++              cache[filename] = {
++                      'mtime': cur_mtime,
++                      'proto_reg': [],
++                      'handoff_reg': [],
++                      'wtap_register': [],
++                      }
++#     print "Searching %s" % (filename)
++      for line in file.readlines():
++              for action in patterns:
++                      regex = action[1]
++                      match = regex.search(line)
++                      if match:
++                              symbol = match.group("symbol")
++                              sym_type = action[0]
++                              regs[sym_type].append(symbol)
++                              if cache is not None:
++#                                     print "Caching %s for %s: %s" % (sym_type, filename, symbol)
++                                      cache[filename][sym_type].append(symbol)
++      file.close()
++
++
++if cache is not None and cache_filename is not None:
++      cache_file = open(cache_filename, 'wb')
++      pickle.dump(cache, cache_file)
++      cache_file.close()
++      print(("Cache hits: %d, misses: %d" % (cache_hits, cache_misses)))
++
++# Make sure we actually processed something
++if len(regs['proto_reg']) < 1:
++      print("No protocol registrations found")
++      sys.exit(1)
++
++# Sort the lists to make them pretty
++regs['proto_reg'].sort()
++regs['handoff_reg'].sort()
++regs['wtap_register'].sort()
++
++reg_code = open(tmp_filename, "w")
++
++reg_code.write(preamble)
++
++# Make the routine to register all protocols
++if registertype == "plugin" or registertype == "plugin_wtap":
++      reg_code.write("""
++#ifdef HAVE_CONFIG_H
++# include "config.h"
++#endif
++
++#include <gmodule.h>
++
++#include "moduleinfo.h"
++
++#ifndef ENABLE_STATIC
++G_MODULE_EXPORT const gchar version[] = VERSION;
++
++/* Start the functions we need for the plugin stuff */
++
++G_MODULE_EXPORT void
++plugin_register (void)
++{
++""");
++else:
++      reg_code.write("""
++#include "register.h"
++void
++register_all_protocols(register_cb cb, gpointer client_data)
++{
++""");
++
++for symbol in regs['proto_reg']:
++      if registertype == "plugin" or registertype == "plugin_wtap":
++              line = "  {extern void %s (void); %s ();}\n" % (symbol, symbol)
++      else:
++              line = "  {extern void %s (void); if(cb) (*cb)(RA_REGISTER, \"%s\", client_data); %s ();}\n" % (symbol, symbol, symbol)
++      reg_code.write(line)
++
++reg_code.write("}\n")
++
++
++# Make the routine to register all protocol handoffs
++if registertype == "plugin" or registertype == "plugin_wtap":
++      reg_code.write("""
++G_MODULE_EXPORT void
++plugin_reg_handoff(void)
++{
++""");
++else:
++      reg_code.write("""
++void
++register_all_protocol_handoffs(register_cb cb, gpointer client_data)
++{
++""");
++
++for symbol in regs['handoff_reg']:
++      if registertype == "plugin" or registertype == "plugin_wtap":
++              line = "  {extern void %s (void); %s ();}\n" % (symbol, symbol)
++      else:
++              line = "  {extern void %s (void); if(cb) (*cb)(RA_HANDOFF, \"%s\", client_data); %s ();}\n" % (symbol, symbol, symbol)
++      reg_code.write(line)
++
++reg_code.write("}\n")
++
++if registertype == "plugin":
++      reg_code.write("#endif\n");
++elif registertype == "plugin_wtap":
++      reg_code.write("""
++G_MODULE_EXPORT void
++register_wtap_module(void)
++{
++""");
++
++      for symbol in regs['wtap_register']:
++              line = "  {extern void %s (void); %s ();}\n" % (symbol, symbol)
++              reg_code.write(line)
++
++      reg_code.write("}\n");
++      reg_code.write("#endif\n");
++else:
++      reg_code.write("""
++static gulong proto_reg_count(void)
++{
++""");
++
++      line = "  return %d;\n" % len(regs['proto_reg'])
++      reg_code.write(line)
++
++      reg_code.write("""
++}
++""");
++      reg_code.write("""
++static gulong handoff_reg_count(void)
++{
++""");
++
++      line = "  return %d;\n" % len(regs['handoff_reg'])
++      reg_code.write(line)
++
++      reg_code.write("""
++}
++""");
++      reg_code.write("""
++gulong register_count(void)
++{
++""");
++
++      line = "  return proto_reg_count() + handoff_reg_count();"
++      reg_code.write(line)
++
++      reg_code.write("""
++}\n
++""");
++
++
++# Close the file
++reg_code.close()
++
++# Remove the old final_file if it exists.
++try:
++      os.stat(final_filename)
++      os.remove(final_filename)
++except OSError:
++      pass
++
++# Move from tmp file to final file
++os.rename(tmp_filename, final_filename)
+diff -Naur wireshark-1.8.4/plugins/btbb/wireshark-1.8-btbb.patch wireshark/plugins/btbb/wireshark-1.8-btbb.patch
+--- wireshark-1.8.4/plugins/btbb/wireshark-1.8-btbb.patch      1969-12-31 19:00:00.000000000 -0500
++++ wireshark/plugins/btbb/wireshark-1.8-btbb.patch    2013-01-26 15:04:24.651077279 -0500
+@@ -0,0 +1,89 @@
++diff -urN wireshark-1.8.2.orig//CMakeLists.txt wireshark-1.8.2/CMakeLists.txt
++--- wireshark-1.8.2.orig//CMakeLists.txt      2012-06-06 00:33:43.000000000 +0800
+++++ wireshark-1.8.2/CMakeLists.txt    2012-06-25 21:48:57.997186003 +0800
++@@ -409,6 +409,7 @@
++      set(PLUGIN_DIR="${DATAFILE_DIR}/plugins/${CPACK_PACKAGE_VERSION}")
++      set(PLUGIN_SRC_DIRS
++              plugins/asn1
+++             plugins/btbb
++              plugins/docsis
++              plugins/ethercat
++              plugins/gryphon
++diff -urN wireshark-1.8.2.orig//Makefile.am wireshark-1.8.2/Makefile.am
++--- wireshark-1.8.2.orig//Makefile.am 2012-06-20 01:47:22.000000000 +0800
+++++ wireshark-1.8.2/Makefile.am       2012-06-25 21:50:00.721186002 +0800
++@@ -273,6 +273,7 @@
++ -include plugins/Custom.make
++ plugin_ldadd = $(_CUSTOM_plugin_ldadd_) \
++      -dlopen plugins/asn1/asn1.la \
+++     -dlopen plugins/btbb/btbb.la \
++      -dlopen plugins/docsis/docsis.la \
++      -dlopen plugins/ethercat/ethercat.la \
++      -dlopen plugins/gryphon/gryphon.la \
++diff -urN wireshark-1.8.2.orig//configure.in wireshark-1.8.2/configure.in
++--- wireshark-1.8.2.orig//configure.in        2012-06-22 02:21:10.000000000 +0800
+++++ wireshark-1.8.2/configure.in      2012-06-25 21:51:10.925186002 +0800
++@@ -2096,6 +2096,7 @@
++   packaging/svr4/pkginfo
++   plugins/Makefile
++   plugins/asn1/Makefile
+++  plugins/btbb/Makefile
++   plugins/docsis/Makefile
++   plugins/ethercat/Makefile
++   plugins/gryphon/Makefile
++diff -urN wireshark-1.8.2.orig//epan/Makefile.am wireshark-1.8.2/epan/Makefile.am
++--- wireshark-1.8.2.orig//epan/Makefile.am    2012-06-09 08:46:54.000000000 +0800
+++++ wireshark-1.8.2/epan/Makefile.am  2012-06-25 21:51:55.394186002 +0800
++@@ -209,6 +209,8 @@
++ -include ../plugins/Custom.make
++ plugin_src = \
++      ../plugins/asn1/packet-asn1.c \
+++     ../plugins/btbb/packet-btbb.c \
+++     ../plugins/btbb/packet-btlmp.c \
++      ../plugins/docsis/packet-bintrngreq.c \
++      ../plugins/docsis/packet-bpkmattr.c \
++      ../plugins/docsis/packet-bpkmreq.c \
++diff -urN wireshark-1.8.2.orig//packaging/nsis/Makefile.nmake wireshark-1.8.2/packaging/nsis/Makefile.nmake
++--- wireshark-1.8.2.orig//packaging/nsis/Makefile.nmake       2012-06-20 01:47:22.000000000 +0800
+++++ wireshark-1.8.2/packaging/nsis/Makefile.nmake     2012-06-25 21:52:34.248186002 +0800
++@@ -46,6 +46,7 @@
++ 
++ PLUGINS= \
++      ../../plugins/asn1/asn1.dll \
+++     ../../plugins/btbb/btbb.dll \
++      ../../plugins/docsis/docsis.dll \
++      ../../plugins/ethercat/ethercat.dll \
++      ../../plugins/gryphon/gryphon.dll \
++diff -urN wireshark-1.8.2.orig//packaging/nsis/wireshark.nsi wireshark-1.8.2/packaging/nsis/wireshark.nsi
++--- wireshark-1.8.2.orig//packaging/nsis/wireshark.nsi        2012-06-20 01:47:22.000000000 +0800
+++++ wireshark-1.8.2/packaging/nsis/wireshark.nsi      2012-06-25 21:54:50.288185993 +0800
++@@ -806,6 +806,7 @@
++ ;-------------------------------------------
++ SetOutPath '$INSTDIR\plugins\${VERSION}'
++ File "${STAGING_DIR}\plugins\${VERSION}\asn1.dll"
+++File "${STAGING_DIR}\plugins\${VERSION}\btbb.dll"
++ File "${STAGING_DIR}\plugins\${VERSION}\docsis.dll"
++ File "${STAGING_DIR}\plugins\${VERSION}\ethercat.dll"
++ File "${STAGING_DIR}\plugins\${VERSION}\gryphon.dll"
++diff -urN wireshark-1.8.2.orig//plugins/Makefile.am wireshark-1.8.2/plugins/Makefile.am
++--- wireshark-1.8.2.orig//plugins/Makefile.am 2012-06-06 00:33:17.000000000 +0800
+++++ wireshark-1.8.2/plugins/Makefile.am       2012-06-25 21:55:15.766186001 +0800
++@@ -24,6 +24,7 @@
++ -include Custom.make
++ SUBDIRS = $(_CUSTOM_SUBDIRS_) \
++      asn1 \
+++     btbb \
++      docsis \
++      ethercat \
++      gryphon \
++diff -urN wireshark-1.8.2.orig//plugins/Makefile.nmake wireshark-1.8.2/plugins/Makefile.nmake
++--- wireshark-1.8.2.orig//plugins/Makefile.nmake      2012-06-06 00:33:17.000000000 +0800
+++++ wireshark-1.8.2/plugins/Makefile.nmake    2012-06-25 21:55:32.469186000 +0800
++@@ -8,6 +8,7 @@
++ 
++ PLUGIN_LIST = \
++      asn1        \
+++     btbb        \
++      docsis      \
++      ethercat    \
++      gryphon     \
+diff -Naur wireshark-1.8.4/plugins/Makefile.am wireshark/plugins/Makefile.am
+--- wireshark-1.8.4/plugins/Makefile.am        2012-09-27 07:45:19.000000000 -0400
++++ wireshark/plugins/Makefile.am      2013-01-26 15:22:38.052499164 -0500
+@@ -25,6 +25,7 @@
+ SUBDIRS = $(_CUSTOM_SUBDIRS_) \
+       asn1 \
+       docsis \
++        btbb \
+       ethercat \
+       gryphon \
+       irda \
+diff -Naur wireshark-1.8.4/plugins/Makefile.nmake wireshark/plugins/Makefile.nmake
+--- wireshark-1.8.4/plugins/Makefile.nmake     2012-06-05 12:33:17.000000000 -0400
++++ wireshark/plugins/Makefile.nmake   2013-01-26 15:22:10.272361410 -0500
+@@ -9,6 +9,7 @@
+ PLUGIN_LIST = \
+       asn1        \
+       docsis      \
++        btbb        \
+       ethercat    \
+       gryphon     \
+       irda        \
index 604a562..78ed126 100644 (file)
@@ -6,3 +6,4 @@
 06_release-version.patch
 09_idl2wrs.patch
 16_licence_about_location.patch
+99_wireshark-1.8.4-ubertooth.patch