diff options
Diffstat (limited to 'tools/dissectors')
| -rw-r--r-- | tools/dissectors/.gitignore | 2 | ||||
| -rw-r--r-- | tools/dissectors/CMakeLists.txt | 106 | ||||
| -rw-r--r-- | tools/dissectors/cmake/Modules/FindGLIB2.cmake | 238 | ||||
| -rw-r--r-- | tools/dissectors/cmake/Modules/FindWireshark.cmake | 28 | ||||
| -rwxr-xr-x | tools/dissectors/make-dissector-reg.py | 305 | ||||
| -rw-r--r-- | tools/dissectors/moduleinfo.h.in | 10 | ||||
| -rw-r--r-- | tools/dissectors/packet-chdr.c | 477 | ||||
| -rw-r--r-- | tools/dissectors/packet-octoclock.c | 212 | ||||
| -rw-r--r-- | tools/dissectors/packet-zpu.c | 242 | ||||
| -rw-r--r-- | tools/dissectors/plugin.rc.in | 34 | ||||
| -rw-r--r-- | tools/dissectors/zpu_addr_names.h | 38 |
11 files changed, 1692 insertions, 0 deletions
diff --git a/tools/dissectors/.gitignore b/tools/dissectors/.gitignore new file mode 100644 index 000000000..257f20c8c --- /dev/null +++ b/tools/dissectors/.gitignore @@ -0,0 +1,2 @@ +build +moduleinfo.h diff --git a/tools/dissectors/CMakeLists.txt b/tools/dissectors/CMakeLists.txt new file mode 100644 index 000000000..9f63a356a --- /dev/null +++ b/tools/dissectors/CMakeLists.txt @@ -0,0 +1,106 @@ +# Copyright 2010-2013 Ettus Research LLC +# +# GNU Radio 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 3, or (at your option) +# any later version. +# +# GNU Radio 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 GNU Radio; see the file COPYING. If not, write to +# the Free Software Foundation, Inc., 51 Franklin Street, +# Boston, MA 02110-1301, USA. + + +######################################################################## +# Project setup +######################################################################## +cmake_minimum_required(VERSION 2.8) +project(ettus-dissector C) +enable_testing() + +#select the release build type by default to get optimization flags +if(NOT CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE "Release") + message(STATUS "Build type not specified: defaulting to release.") +endif(NOT CMAKE_BUILD_TYPE) +set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE} CACHE STRING "") + +list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/Modules) + +######################################################################## +# Compiler specific setup +######################################################################## +#if(CMAKE_COMPILER_IS_GNUC AND NOT WIN32) +# #http://gcc.gnu.org/wiki/Visibility +# add_definitions(-fvisibility=visible) +#endif() + +find_package(GLIB2) +if(NOT GLIB2_FOUND) + message(FATAL_ERROR "Glib not found") +endif() + +find_package(Wireshark) +if(NOT WIRESHARK_FOUND) + message(FATAL_ERROR "Wireshark dev package not found") +endif() + + +######################################################################## +# Setup the include and linker paths +######################################################################## +include_directories( + ${CMAKE_BINARY_DIR} + ${CMAKE_SOURCE_DIR} + ${GLIB2_INCLUDE_DIRS} + ${WIRESHARK_INCLUDE_DIRS} +) + +set(CMAKE_INSTALL_LIBDIR ~/.wireshark) + +# Set component parameters +set(ETTUS_DISSECTOR_INCLUDE_DIRS ${CMAKE_SOURCE_DIR} CACHE INTERNAL "" FORCE) +set(ETTUS_DISSECTOR_NAME "chdr" CACHE STRING "Select a dissector to build") + +function(generate_ettus_dissector DISSECTOR_NAME) + + set(ETTUS_PLUGIN_SRC ${CMAKE_SOURCE_DIR}/packet-${DISSECTOR_NAME}.c) + + configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/moduleinfo.h.in + ${CMAKE_BINARY_DIR}/moduleinfo.h + ) + + set(PLUGIN_C_GENERATOR ${CMAKE_SOURCE_DIR}/make-dissector-reg.py) + set(PLUGIN_C plugin.c) + + add_custom_command( + OUTPUT ${PLUGIN_C} + DEPENDS ${ETTUS_PLUGIN_SRC} + COMMAND ${PLUGIN_C_GENERATOR} ${CMAKE_SOURCE_DIR} plugin ${ETTUS_PLUGIN_SRC} + COMMENT "Generating ${PLUGIN_C}" + ) + + set(ETTUS_TARGET_NAME "${DISSECTOR_NAME}-plugin") + add_library(${ETTUS_TARGET_NAME} MODULE + ${PLUGIN_C} + moduleinfo.h + ${ETTUS_PLUGIN_SRC} + ) + set_target_properties(${ETTUS_TARGET_NAME} PROPERTIES PREFIX "") + set_target_properties(${ETTUS_TARGET_NAME} PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}") + target_link_libraries(${ETTUS_TARGET_NAME} wireshark) + + install(TARGETS ${ETTUS_TARGET_NAME} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}/plugins NAMELINK_SKIP + ) + +endfunction(generate_ettus_dissector) + +generate_ettus_dissector("${ETTUS_DISSECTOR_NAME}") + diff --git a/tools/dissectors/cmake/Modules/FindGLIB2.cmake b/tools/dissectors/cmake/Modules/FindGLIB2.cmake new file mode 100644 index 000000000..ae7baddbb --- /dev/null +++ b/tools/dissectors/cmake/Modules/FindGLIB2.cmake @@ -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 --git a/tools/dissectors/cmake/Modules/FindWireshark.cmake b/tools/dissectors/cmake/Modules/FindWireshark.cmake new file mode 100644 index 000000000..276201245 --- /dev/null +++ b/tools/dissectors/cmake/Modules/FindWireshark.cmake @@ -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.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 --git a/tools/dissectors/make-dissector-reg.py b/tools/dissectors/make-dissector-reg.py new file mode 100755 index 000000000..44972909b --- /dev/null +++ b/tools/dissectors/make-dissector-reg.py @@ -0,0 +1,305 @@ +#!/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 30447 2009-10-09 20:47:18Z krj $ + +import os +import sys +import re +import pickle +from stat import * + +VERSION_KEY = '_VERSION' +CUR_VERSION = '$Id: make-dissector-reg.py 30447 2009-10-09 20:47:18Z krj $' + +# +# 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 not cache.has_key(VERSION_KEY) or cache[VERSION_KEY] != CUR_VERSION: + cache = {VERSION_KEY: CUR_VERSION} + except: + cache = {VERSION_KEY: CUR_VERSION} + +# Grep +for filename in filenames: + file = open(filename) + cur_mtime = os.fstat(file.fileno())[ST_MTIME] + if cache and cache.has_key(filename): + cdict = cache[filename] + if cur_mtime == cdict['mtime']: +# 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[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() + +# 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 --git a/tools/dissectors/moduleinfo.h.in b/tools/dissectors/moduleinfo.h.in new file mode 100644 index 000000000..7910c56a3 --- /dev/null +++ b/tools/dissectors/moduleinfo.h.in @@ -0,0 +1,10 @@ +#ifdef PACKAGE +#undef PACKAGE +#endif +#define PACKAGE "@ETTUS_DISSECTOR_NAME@" + +#ifdef VERSION +#undef VERSION +#endif +#define VERSION "0.0.0.2" + diff --git a/tools/dissectors/packet-chdr.c b/tools/dissectors/packet-chdr.c new file mode 100644 index 000000000..ba85a016f --- /dev/null +++ b/tools/dissectors/packet-chdr.c @@ -0,0 +1,477 @@ +/* + * Dissector for UHD CVITA (CHDR) packets + * + * Copyright 2010-2014 Ettus Research LLC + * + * 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 3 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, see <http://www.gnu.org/licenses/>. + * + */ + +#include "config.h" + +#include <glib.h> +#include <epan/packet.h> +#include <ctype.h> +#include <stdio.h> + +#include "../../host/lib/usrp/x300/x300_fw_common.h" + +#define LOG_HEADER "[UHD CHDR] " + +#ifndef min +#define min(a,b) ((a<b)?a:b) +#endif // min + +const unsigned int CHDR_PORT = X300_VITA_UDP_PORT; + +static int proto_chdr = -1; +static int hf_chdr_hdr = -1; +static int hf_chdr_type = -1; +static int hf_chdr_has_time = -1; +static int hf_chdr_eob = -1; +static int hf_chdr_error = -1; +static int hf_chdr_sequence = -1; +static int hf_chdr_packet_size = -1; +static int hf_chdr_stream_id = -1; +static int hf_chdr_src_dev = -1; +static int hf_chdr_src_ep = -1; +static int hf_chdr_src_blockport = -1; +static int hf_chdr_dst_dev = -1; +static int hf_chdr_dst_ep = -1; +static int hf_chdr_dst_blockport = -1; +static int hf_chdr_timestamp = -1; +static int hf_chdr_payload = -1; +static int hf_chdr_ext_response = -1; +static int hf_chdr_ext_status_code = -1; +static int hf_chdr_ext_seq_num = -1; +static int hf_chdr_cmd = -1; +static int hf_chdr_cmd_address = -1; +static int hf_chdr_cmd_value = -1; + +static const value_string CHDR_PACKET_TYPES[] = { + { 0, "Data" }, + { 1, "Data (End-of-Burst)" }, + { 4, "Flow Control" }, + { 8, "Command" }, + { 12, "Response" }, + { 13, "Error Response" }, +}; + +static const value_string CHDR_PACKET_TYPES_SHORT[] = { + { 0, "data" }, + { 1, "data" }, + { 4, "fc" }, + { 8, "cmd" }, + { 12, "resp" }, + { 13, "resp" }, +}; + +/* the heuristic dissector is called on every packet with payload. + * The warning printed for this should only be printed once. + */ +static int heur_warning_printed = 0; + +/* Subtree handles: set by register_subtree_array */ +static gint ett_chdr = -1; +static gint ett_chdr_header = -1; +static gint ett_chdr_id = -1; +static gint ett_chdr_response = -1; +static gint ett_chdr_cmd = -1; + +/* Forward-declare the dissector functions */ +void proto_register_chdr(void); +void proto_reg_handoff_chdr(void); +static void dissect_chdr(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); + +/* heuristic dissector call. Will always return. */ +static gboolean heur_dissect_chdr(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* whatislove) +{ + if(heur_warning_printed < 1){ + printf(LOG_HEADER"heuristic dissector always returns true!\n"); + heur_warning_printed++; + } + dissect_chdr(tvb, pinfo, tree); + return (TRUE); +} + +static void byte_swap(guint8 *bytes, gint len) +{ + guint8 tmp[4]; + + if(len != sizeof(tmp)){ + printf(LOG_HEADER"FATAL! number of bytes don't match 32 bit!\n"); + return; + } + + memcpy(tmp, bytes, sizeof(tmp)); + bytes[0] = tmp[3]; + bytes[1] = tmp[2]; + bytes[2] = tmp[1]; + bytes[3] = tmp[0]; +} + +static unsigned long long get_timestamp(guint8 *bytes, gint len) +{ + unsigned long long ts; + unsigned long long trans; + int it; + + if(len != sizeof(unsigned long long)){ + printf(LOG_HEADER"FATAL! timestamps always consist of 64 bits!\n"); + } + + byte_swap(bytes + 0, 4); + byte_swap(bytes + 4, 4); + + ts = 0; + for(it = 0; it < 8; it++){ + ts = ts << 8; + trans = (guint64) bytes[it]; + ts = ts | trans; + } + + return (ts); +} + +/* The dissector itself */ +static void dissect_chdr(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) +{ + // Here are all the variables + proto_item *item; + proto_item *stream_item; + proto_tree *chdr_tree; + proto_item *header_item; + proto_tree *header_tree; + proto_tree *stream_tree; + proto_item *response_item; + proto_tree *response_tree; + proto_item *cmd_item; + proto_tree *cmd_tree; + gint len; + + gint flag_offset; + guint8 *bytes; + guint8 hdr_bits = 0; + guint8 pkt_type = 0; + gboolean flag_has_time = 0; + gboolean flag_is_data = 0; + gboolean flag_is_fc = 0; + gboolean flag_is_cmd = 0; + gboolean flag_is_resp = 0; + gboolean flag_is_eob = 0; + gboolean flag_is_error = 0; + unsigned long long timestamp; + gboolean is_network; + gint endianness; + gint id_pos_usb[4] = {7, 6, 5, 4}; + gint id_pos_net[4] = {4, 5, 6, 7}; + gint id_pos[4] = {7, 6, 5, 4}; + + if(pinfo->match_uint == CHDR_PORT){ + is_network = TRUE; + flag_offset = 0; + endianness = ENC_BIG_ENDIAN; + memcpy(id_pos, id_pos_net, 4 * sizeof(gint)); + } + else{ // Parsing a USB capture + is_network = FALSE; + flag_offset = 3; + endianness = ENC_LITTLE_ENDIAN; + memcpy(id_pos, id_pos_usb, 4 * sizeof(gint)); + } + + len = tvb_reported_length(tvb); + + col_append_str(pinfo->cinfo, COL_PROTOCOL, "/CHDR"); + /* This throws a warning: */ + /*col_append_sep_fstr(pinfo->cinfo, COL_INFO, NULL, "CHDR", tvb_format_text_wsp(tvb, 0, len));*/ + col_append_sep_fstr(pinfo->cinfo, COL_INFO, NULL, "CHDR"); + + if (tree){ + int chdr_size = -1; + + if (len >= 4){ + chdr_size = 8; + bytes = tvb_get_string(wmem_packet_scope(), tvb, 0, 4); + hdr_bits = (bytes[flag_offset] & 0xF0) >> 4; + pkt_type = hdr_bits >> 2; + flag_is_data = (pkt_type == 0); + flag_is_fc = (pkt_type == 1); + flag_is_cmd = (pkt_type == 2); + flag_is_resp = (pkt_type == 3); + flag_is_eob = flag_is_data && (hdr_bits & 0x1); + flag_is_error = flag_is_resp && (hdr_bits & 0x1); + flag_has_time = hdr_bits & 0x2; + if (flag_has_time) + chdr_size += 8; // 64-bit timestamp + } + + /* Start with a top-level item to add everything else to */ + item = proto_tree_add_item(tree, proto_chdr, tvb, 0, min(len, chdr_size), ENC_NA); + + if (len >= 4) { + chdr_tree = proto_item_add_subtree(item, ett_chdr); + + /* Header info. First, a top-level header tree item: */ + header_item = proto_tree_add_item(chdr_tree, hf_chdr_hdr, tvb, flag_offset, 1, endianness); + header_tree = proto_item_add_subtree(header_item, ett_chdr_header); + proto_item_append_text(header_item, ", Packet type: %s", + val_to_str(hdr_bits & 0xD, CHDR_PACKET_TYPES, "Unknown (0x%x)") + ); + /* Let us query hdr.type */ + proto_tree_add_string( + header_tree, hf_chdr_type, tvb, flag_offset, 1, + val_to_str(hdr_bits & 0xD, CHDR_PACKET_TYPES_SHORT, "invalid") + ); + /* And other flags */ + proto_tree_add_boolean(header_tree, hf_chdr_has_time, tvb, flag_offset, 1, flag_has_time); + if (flag_is_data) { + proto_tree_add_boolean(header_tree, hf_chdr_eob, tvb, flag_offset, 1, flag_is_eob); + } + if (flag_is_resp) { + proto_tree_add_boolean(header_tree, hf_chdr_error, tvb, flag_offset, 1, flag_is_error); + } + + /* These lines add sequence, packet_size and stream ID */ + proto_tree_add_item(chdr_tree, hf_chdr_sequence, tvb, (is_network ? 0:2), 2, endianness); + proto_tree_add_item(chdr_tree, hf_chdr_packet_size, tvb, (is_network ? 2:0), 2, endianness); + + if (len >= 8){ + /* stream id can be broken down to 4 sections. these are collapsed in a subtree */ + stream_item = proto_tree_add_item(chdr_tree, hf_chdr_stream_id, tvb, 4, 4, endianness); + stream_tree = proto_item_add_subtree(stream_item, ett_chdr_id); + proto_tree_add_item(stream_tree, hf_chdr_src_dev, tvb, id_pos[0], 1, ENC_NA); + proto_tree_add_item(stream_tree, hf_chdr_src_ep, tvb, id_pos[1], 1, ENC_NA); + proto_tree_add_item(stream_tree, hf_chdr_dst_dev, tvb, id_pos[2], 1, ENC_NA); + proto_tree_add_item(stream_tree, hf_chdr_dst_ep, tvb, id_pos[3], 1, ENC_NA); + + /* Block ports (only add them if address points to a device) */ + bytes = tvb_get_string(wmem_packet_scope(), tvb, 0, 8); + if (bytes[id_pos[0]] != 0) { + proto_tree_add_item(stream_tree, hf_chdr_src_blockport, tvb, id_pos[1], 1, ENC_NA); + } + if (bytes[id_pos[2]] != 0) { + proto_tree_add_item(stream_tree, hf_chdr_dst_blockport, tvb, id_pos[3], 1, ENC_NA); + } + + /* Append SID in sid_t hex format */ + proto_item_append_text(stream_item, " (%02X:%02X>%02X:%02X)", + bytes[id_pos[0]], + bytes[id_pos[1]], + bytes[id_pos[2]], + bytes[id_pos[3]] + ); + + /* if has_time flag is present interpret timestamp */ + if ((flag_has_time) && (len >= 16)){ + if (is_network) + item = proto_tree_add_item(chdr_tree, hf_chdr_timestamp, tvb, 8, 8, endianness); + else{ + bytes = (guint8*) tvb_get_string(wmem_packet_scope(), tvb, 8, sizeof(unsigned long long)); + timestamp = get_timestamp(bytes, sizeof(unsigned long long)); + proto_tree_add_uint64(chdr_tree, hf_chdr_timestamp, tvb, 8, 8, timestamp); + } + } + + int remaining_bytes = (len - chdr_size); + int show_raw_payload = (remaining_bytes > 0); + + if (flag_is_cmd && remaining_bytes == 8) { + cmd_item = proto_tree_add_item(chdr_tree, hf_chdr_cmd, tvb, chdr_size, 8, endianness); + cmd_tree = proto_item_add_subtree(cmd_item, ett_chdr_cmd); + proto_tree_add_item(cmd_tree, hf_chdr_cmd_address, tvb, chdr_size, 4, endianness); + proto_tree_add_item(cmd_tree, hf_chdr_cmd_value, tvb, chdr_size + 4, 4, endianness); + } else if (flag_is_resp) { + response_item = proto_tree_add_item(chdr_tree, hf_chdr_ext_response, tvb, chdr_size, 8, endianness); + response_tree = proto_item_add_subtree(response_item, ett_chdr_response); + + proto_tree_add_item(response_tree, hf_chdr_ext_status_code, tvb, chdr_size, 4, endianness); + /* This will show the 12-bits of sequence ID in the last 2 bytes */ + proto_tree_add_item(response_tree, hf_chdr_ext_seq_num, tvb, (chdr_size + 4 + (is_network ? 2 : 0)), 2, endianness); + } else if (show_raw_payload) { + proto_tree_add_item(chdr_tree, hf_chdr_payload, tvb, chdr_size, -1, ENC_NA); + } + } + } + } +} + +void proto_register_chdr(void) +{ + static hf_register_info hf[] = { + { &hf_chdr_hdr, + { "Header bits", "chdr.hdr", + FT_UINT8, BASE_HEX, + NULL, 0xF0, + NULL, HFILL } + }, + { &hf_chdr_type, + { "Packet Type", "chdr.hdr.type", + FT_STRINGZ, BASE_NONE, + NULL, 0x00, + "Packet Type", HFILL } + }, + { &hf_chdr_has_time, + { "Time present", "chdr.hdr.has_time", + FT_BOOLEAN, BASE_NONE, + NULL, 0x20, + NULL, HFILL } + }, + { &hf_chdr_eob, + { "End Of Burst", "chdr.hdr.eob", + FT_BOOLEAN, BASE_NONE, + NULL, 0x10, + NULL, HFILL } + }, + { &hf_chdr_error, + { "Error Flag", "chdr.hdr.error", + FT_BOOLEAN, BASE_NONE, + NULL, 0x10, + NULL, HFILL } + }, + { &hf_chdr_sequence, + { "Sequence ID", "chdr.seq", + FT_UINT16, BASE_DEC, + NULL, 0x0FFF, + NULL, HFILL } + }, + { &hf_chdr_packet_size, + { "Packet size", "chdr.size", + FT_UINT16, BASE_DEC, + NULL, 0x0, + NULL, HFILL } + }, + { &hf_chdr_stream_id, + { "Stream ID", "chdr.sid", + FT_IPv4, BASE_NONE, + NULL, 0x0, + NULL, HFILL } + }, + { &hf_chdr_src_dev, + { "Source device", "chdr.src_dev", + FT_UINT8, BASE_DEC, + NULL, 0x0, + NULL, HFILL } + }, + { &hf_chdr_src_ep, + { "Source endpoint", "chdr.src_ep", + FT_UINT8, BASE_DEC, + NULL, 0x0, + NULL, HFILL } + }, + { &hf_chdr_src_blockport, + { "Source block port", "chdr.src_bp", + FT_UINT8, BASE_DEC, + NULL, 0xF, + NULL, HFILL } + }, + { &hf_chdr_dst_dev, + { "Destination device", "chdr.dst_dev", + FT_UINT8, BASE_DEC, + NULL, 0x0, + NULL, HFILL } + }, + { &hf_chdr_dst_ep, + { "Destination endpoint", "chdr.dst_ep", + FT_UINT8, BASE_DEC, + NULL, 0x0, + NULL, HFILL } + }, + { &hf_chdr_dst_blockport, + { "Destination block port", "chdr.dst_bp", + FT_UINT8, BASE_DEC, + NULL, 0xF, + NULL, HFILL } + }, + { &hf_chdr_timestamp, + { "Time", "chdr.time", + FT_UINT64, BASE_DEC, + NULL, 0x0, + NULL, HFILL } + }, + { &hf_chdr_payload, + { "Payload", "chdr.payload", + FT_BYTES, BASE_NONE, + NULL, 0x0, + NULL, HFILL + } + }, + { &hf_chdr_ext_response, + { "Response", "chdr.res", + FT_BYTES, BASE_NONE, + NULL, 0x0, + NULL, HFILL } + }, + { &hf_chdr_ext_status_code, + { "Status code", "chdr.res.status", + FT_UINT32, BASE_DEC, + NULL, 0x0, + NULL, HFILL } + }, + { &hf_chdr_ext_seq_num, + { "Response to sequence ID", "chdr.res.seq", + FT_UINT16, BASE_DEC, + NULL, 0x0FFF, + NULL, HFILL } + }, + { &hf_chdr_cmd, + { "Command", "chdr.cmd", + FT_BYTES, BASE_NONE, + NULL, 0x0, + NULL, HFILL } + }, + { &hf_chdr_cmd_address, + { "Register Address", "chdr.cmd.addr", + FT_UINT32, BASE_DEC, + NULL, 0x0, + NULL, HFILL } + }, + { &hf_chdr_cmd_value, + { "Command Value", "chdr.cmd.val", + FT_UINT32, BASE_HEX, + NULL, 0x0, + NULL, HFILL } + }, + }; + + static gint *ett[] = { + &ett_chdr, + &ett_chdr_header, + &ett_chdr_id, + &ett_chdr_response, + &ett_chdr_cmd + }; + + proto_chdr = proto_register_protocol("UHD CHDR", "CHDR", "chdr"); + proto_register_field_array(proto_chdr, hf, array_length(hf)); + proto_register_subtree_array(ett, array_length(ett)); + register_dissector("chdr", dissect_chdr, proto_chdr); +} + +/* Handler registration */ +void proto_reg_handoff_chdr(void) +{ + /* register heuristic dissector for use with USB */ +#if VERSION_MAJOR == 1 + heur_dissector_add("usb.bulk", heur_dissect_chdr, proto_chdr); +#elif VERSION_MAJOR == 2 + heur_dissector_add("usb.bulk", heur_dissect_chdr, "USB dissector", "usb_bulk", proto_chdr, HEURISTIC_ENABLE); +#else +#error Wireshark version not found or not compatible +#endif + /* register dissector for UDP packets */ + static dissector_handle_t chdr_handle; + chdr_handle = create_dissector_handle(dissect_chdr, proto_chdr); + dissector_add_uint("udp.port", CHDR_PORT, chdr_handle); +} diff --git a/tools/dissectors/packet-octoclock.c b/tools/dissectors/packet-octoclock.c new file mode 100644 index 000000000..453c325d7 --- /dev/null +++ b/tools/dissectors/packet-octoclock.c @@ -0,0 +1,212 @@ +/* + * Dissector for Ettus Octoclock packets + * + * Copyright 2016 Ettus Research + * + * 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 3 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, see <http://www.gnu.org/licenses/>. + * + */ + +#include "config.h" + +#include <glib.h> +#include <epan/packet.h> +#include <ctype.h> +#include <stdio.h> +#include <stddef.h> + +#include "../../host/lib/usrp_clock/octoclock/common.h" + +#define LOG_HEADER "[Octoclock] " +#define size_mem(t,m) sizeof(((t*)0)->m) +#define packet_elem_size(m) (size_mem(octoclock_packet_t,m)) +#define packet_offset(m) (offsetof(octoclock_packet_t, m)) +const unsigned int OCTOCLOCK_PORT = OCTOCLOCK_UDP_CTRL_PORT; + +static int proto_octo = -1; +static int hf_octo_proto_version = -1; +static int hf_octo_proto_sequence = -1; +static int hf_octo_proto_code = -1; +static int hf_octo_proto_poolsize = -1; +static int hf_octo_proto_data = -1; +static int hf_octo_proto_payload = -1; +static int hf_octo_proto_len = -1; +static gint ett_octo = -1; +static const value_string packetcodes[] = { + {1, "OCTOCLOCK_QUERY_CMD"}, + {2, "OCTOCLOCK_QUERY_ACK"}, + {3, "SEND_EEPROM_CMD"}, + {4, "SEND_EEPROM_ACK"}, + {5, "BURN_EEPROM_CMD"}, + {6, "BURN_EEPROM_SUCCESS_ACK"}, + {7, "BURN_EEPROM_FAILURE_ACK"}, + {8, "CLEAR_EEPROM_CMD"}, + {9, "CLEAR_EEPROM_ACK"}, + {10, "SEND_STATE_CMD"}, + {11, "SEND_STATE_ACK"}, + {12, "RESET_CMD"}, + {13, "RESET_ACK"}, + {14, "HOST_SEND_TO_GPSDO_CMD"}, + {15, "HOST_SEND_TO_GPSDO_ACK"}, + {16, "SEND_POOLSIZE_CMD"}, + {17, "SEND_POOLSIZE_ACK"}, + {18, "SEND_CACHE_STATE_CMD"}, + {19, "SEND_CACHE_STATE_ACK"}, + {20, "SEND_GPSDO_CACHE_CMD"}, + {21, "SEND_GPSDO_CACHE_ACK"}, + {22, "PREPARE_FW_BURN_CMD"}, + {23, "FW_BURN_READY_ACK"}, + {24, "FILE_TRANSFER_CMD"}, + {25, "FILE_TRANSFER_ACK"}, + {26, "READ_FW_CMD"}, + {27, "READ_FW_ACK"}, + {28, "FINALIZE_BURNING_CMD"}, + {29, "FINALIZE_BURNING_ACK"}, + { 0, NULL } +}; +/* Forward-declare the dissector functions */ +void proto_register_octo(void); +void proto_reg_handoff_octo(void); +static void dissect_octo(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); + +static void dissect_octo(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) +{ + col_set_str(pinfo->cinfo, COL_PROTOCOL, "OCTO"); + col_clear(pinfo->cinfo, COL_INFO); + proto_item *ti = proto_tree_add_item(tree, proto_octo, tvb, 0, -1, ENC_NA); + proto_tree *octo_tree = proto_item_add_subtree(ti, ett_octo); + proto_tree_add_item(octo_tree, + hf_octo_proto_version, + tvb, + packet_offset(proto_ver), + packet_elem_size(proto_ver), + ENC_LITTLE_ENDIAN); + guint32 rev = tvb_get_letohl(tvb, packet_offset(proto_ver)); + if(rev==3) + { + proto_tree_add_item(octo_tree, + hf_octo_proto_sequence, + tvb, + packet_offset(sequence), + packet_elem_size(sequence), + ENC_LITTLE_ENDIAN); + proto_tree_add_item(octo_tree, + hf_octo_proto_code, + tvb, + packet_offset(code), + packet_elem_size(code), + ENC_LITTLE_ENDIAN); + proto_tree_add_item(octo_tree, + hf_octo_proto_poolsize, + tvb, + packet_offset(poolsize), + packet_elem_size(poolsize), + ENC_LITTLE_ENDIAN); + + //packet_code_t code = (packet_code_t)(tvb_get_guint8(tvb, packet_offset(code))); + + guint16 len = tvb_get_letohs(tvb, packet_offset(len)); + if(len && len <= packet_elem_size(data)) + { + proto_tree_add_item(octo_tree, + hf_octo_proto_payload, + tvb, + packet_offset(data), + len, + ENC_LITTLE_ENDIAN); + } + proto_tree_add_item(octo_tree, + hf_octo_proto_data, + tvb, + packet_offset(data), + packet_elem_size(data), + ENC_LITTLE_ENDIAN); + proto_tree_add_item(octo_tree, + hf_octo_proto_len, + tvb, + packet_offset(len), + packet_elem_size(len), + ENC_LITTLE_ENDIAN); + } +} + + +void proto_register_octo(void) +{ + static hf_register_info hf[] = { + { &hf_octo_proto_version, + { "version", "octo.rev", + FT_UINT32, BASE_DEC, + NULL, 0x0, + "Protocol Revision", HFILL } + }, + { &hf_octo_proto_sequence, + { "sequence number", "octo.seq", + FT_UINT32, BASE_DEC, + NULL, 0x0, + NULL, HFILL } + }, + { &hf_octo_proto_code, + { "code", "octo.code", + FT_UINT8, BASE_DEC, + VALS(packetcodes), 0x0, + NULL, HFILL } + }, + { &hf_octo_proto_poolsize, + { "poolsize", "octo.poolsize", + FT_UINT16, BASE_DEC, + NULL, 0x0, + NULL, HFILL } + }, + { &hf_octo_proto_payload, + { "payload", "octo.payload", + FT_STRING, BASE_NONE, + NULL, 0x0, + NULL, HFILL } + }, + { &hf_octo_proto_data, + { "data", "octo.data", + FT_BYTES, BASE_NONE, + NULL, 0x0, + NULL, HFILL } + }, + { &hf_octo_proto_len, + { "length", "octo.len", + FT_UINT16, BASE_DEC, + NULL, 0x0, + NULL, HFILL } + } + }; + //protocol subtree array + static gint *ett[] = { + &ett_octo + }; + proto_octo = proto_register_protocol( + "Octoclock", + "Octoclock", + "octo" + ); + + proto_register_field_array(proto_octo, hf, array_length(hf)); + proto_register_subtree_array(ett, array_length(ett)); + register_dissector("octo", dissect_octo, proto_octo); +} + +void proto_reg_handoff_octo(void) +{ + static dissector_handle_t octo_handle; + octo_handle = create_dissector_handle(dissect_octo, proto_octo); + dissector_add_uint("udp.port", OCTOCLOCK_PORT, octo_handle); + dissector_add_uint("udp.port", OCTOCLOCK_UDP_GPSDO_PORT, octo_handle); +} diff --git a/tools/dissectors/packet-zpu.c b/tools/dissectors/packet-zpu.c new file mode 100644 index 000000000..39507165e --- /dev/null +++ b/tools/dissectors/packet-zpu.c @@ -0,0 +1,242 @@ +/* + * Dissector for ZPU packets (communication with X300 firmware) + * + * Copyright 2013-2014 Ettus Research LLC + * + * 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 3 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, see <http://www.gnu.org/licenses/>. + * + */ + +/* Format of ZPU packets is defined in x300_fw_commons.h, + * x300_fw_comms_t. + * + * Reminder: + * + * uint32_t flags; (ack, error, peek, poke) + * uint32_t sequence; + * uint32_t addr; + * uint32_t data; + */ + +#include "config.h" + +#include <glib.h> +#include <epan/packet.h> +#include <ctype.h> +#include <stdio.h> +#include <endian.h> + +#include "../../host/lib/usrp/x300/x300_fw_common.h" +#include "zpu_addr_names.h" + +#define LOG_HEADER "[ZPU] " + +#ifndef min +#define min(a,b) ((a<b)?a:b) +#endif // min + +const unsigned int FW_PORT = X300_FW_COMMS_UDP_PORT; + +static int proto_zpu = -1; +static int hf_zpu_flags = -1; +static int hf_zpu_flags_ack = -1; +static int hf_zpu_flags_error = -1; +static int hf_zpu_flags_poke = -1; +static int hf_zpu_flags_peek = -1; +static int hf_zpu_seq = -1; +static int hf_zpu_addr = -1; +static int hf_zpu_data = -1; +static int hf_zpu_shmem_addr = -1; +static int hf_zpu_shmem_addr_name = -1; + +/* Subtree handles: set by register_subtree_array */ +static gint ett_zpu = -1; +static gint ett_zpu_flags = -1; +//static gint ett_zpu_shmem = -1; + +/* Forward-declare the dissector functions */ +void proto_register_zpu(void); +void proto_reg_handoff_zpu(void); +static void dissect_zpu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); + +/* The dissector itself */ +static void dissect_zpu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) +{ + proto_item *item; + proto_tree *zpu_tree; + proto_item *flags_item; + proto_tree *flags_tree; + gint len; + + gboolean is_network; + gint endianness; + + if (pinfo->match_uint == FW_PORT) { + is_network = TRUE; + endianness = ENC_BIG_ENDIAN; + } + else { + is_network = FALSE; + endianness = ENC_LITTLE_ENDIAN; + } + + len = tvb_reported_length(tvb); + + col_append_str(pinfo->cinfo, COL_PROTOCOL, "/ZPU"); + /*col_append_sep_fstr(pinfo->cinfo, COL_INFO, NULL, "ZPU", tvb_format_text_wsp(tvb, 0, len));*/ + col_append_sep_fstr(pinfo->cinfo, COL_INFO, NULL, "ZPU"); + + if (tree) + { + item = proto_tree_add_item(tree, proto_zpu, tvb, 0, min(16, len), ENC_NA); + + // Dissect 'flags' + if (len >= 4) + { + zpu_tree = proto_item_add_subtree(item, ett_zpu); + + flags_item = proto_tree_add_item(zpu_tree, hf_zpu_flags, tvb, 0, 4, endianness); + flags_tree = proto_item_add_subtree(flags_item, ett_zpu_flags); + + proto_tree_add_item(flags_tree, hf_zpu_flags_ack, tvb, 0, 4, ENC_NA); + proto_tree_add_item(flags_tree, hf_zpu_flags_error, tvb, 0, 4, ENC_NA); + proto_tree_add_item(flags_tree, hf_zpu_flags_poke, tvb, 0, 4, ENC_NA); + proto_tree_add_item(flags_tree, hf_zpu_flags_peek, tvb, 0, 4, ENC_NA); + + // Dissect 'sequence number' + if (len >= 8) + { + proto_tree_add_item(zpu_tree, hf_zpu_seq, tvb, 4, 4, ENC_NA); + + // Dissect 'address' + if (len >= 12) + { + proto_tree_add_item(zpu_tree, hf_zpu_addr, tvb, 8, 4, ENC_NA); +#if VERSION_MAJOR == 1 + guint8 *bytes = tvb_get_string(tvb, 8, 4); +#elif VERSION_MAJOR == 2 + guint8 *bytes = tvb_get_string(wmem_packet_scope(), tvb, 8, 4); +#else +#error Wireshark version not found or not compatible +#endif + unsigned int addr = 0; + memcpy(&addr, bytes, 4); + /* TODO proper endianness handling */ + addr = (addr >> 24) | ((addr & 0x00FF0000) >> 8) | ((addr & 0x0000FF00) << 8) | ((addr & 0x000000FF) << 24); + /* TODO check the actual size of shmem instead of this constant */ + if (addr >= X300_FW_SHMEM_BASE && addr <= X300_FW_SHMEM_BASE + 0x2000) + { + proto_item *shmem_addr_item = NULL; + + // Convert the address to a register number (32-bit registers == 4-byte registers) + addr -= X300_FW_SHMEM_BASE; + addr /= 4; + + shmem_addr_item = proto_tree_add_uint(zpu_tree, hf_zpu_shmem_addr, tvb, 8, 4, addr); + proto_item_append_text(shmem_addr_item, ", Register name: %s", + val_to_str(addr, X300_SHMEM_NAMES, "Unknown (0x%04x)") + ); + + } + + // Dissect 'data' + if (len >= 16) + { + proto_tree_add_item(zpu_tree, hf_zpu_data, tvb, 12, 4, ENC_NA); + } + } + } + } + } +} + +void proto_register_zpu(void) +{ + static hf_register_info hf[] = { + { &hf_zpu_flags, + { "Flags", "zpu.flags", + FT_UINT32, BASE_HEX, + NULL, 0x0, + NULL, HFILL } + }, + { &hf_zpu_flags_ack, + { "ACK", "zpu.flags.ack", + FT_BOOLEAN, BASE_NONE, + NULL, 0x1, + NULL, HFILL } + }, + { &hf_zpu_flags_error, + { "Error", "zpu.flags.error", + FT_BOOLEAN, BASE_NONE, + NULL, 0x2, + NULL, HFILL } + }, + { &hf_zpu_flags_poke, + { "Poke", "zpu.flags.poke", + FT_BOOLEAN, BASE_NONE, + NULL, 0x4, + NULL, HFILL } + }, + { &hf_zpu_flags_peek, + { "Peek", "zpu.flags.peek", + FT_BOOLEAN, BASE_NONE, + NULL, 0x8, + NULL, HFILL } + }, + { &hf_zpu_seq, + { "Sequence ID", "zpu.seq", + FT_UINT32, BASE_HEX, + NULL, 0x0, + NULL, HFILL } + }, + { &hf_zpu_addr, + { "Address", "zpu.addr", + FT_UINT32, BASE_HEX, + NULL, 0x0, + NULL, HFILL } + }, + { &hf_zpu_shmem_addr, + { "SHMEM section", "zpu.shmem", + FT_UINT32, BASE_DEC, + NULL, 0x0, + NULL, HFILL } + }, + { &hf_zpu_data, + { "Data", "zpu.data", + FT_UINT32, BASE_HEX, + NULL, 0x0, + NULL, HFILL } + }, + }; + + static gint *ett[] = { + &ett_zpu, + &ett_zpu_flags, + //&ett_zpu_shmem + }; + + proto_zpu = proto_register_protocol("ZPU FW", "ZPU", "zpu"); + proto_register_field_array(proto_zpu, hf, array_length(hf)); + proto_register_subtree_array(ett, array_length(ett)); + register_dissector("zpu", dissect_zpu, proto_zpu); +} + +/* Handler registration */ +void proto_reg_handoff_zpu(void) +{ + /* register dissector for UDP packets */ + static dissector_handle_t zpu_handle; + zpu_handle = create_dissector_handle(dissect_zpu, proto_zpu); + dissector_add_uint("udp.port", FW_PORT, zpu_handle); +} diff --git a/tools/dissectors/plugin.rc.in b/tools/dissectors/plugin.rc.in new file mode 100644 index 000000000..29fcfdc33 --- /dev/null +++ b/tools/dissectors/plugin.rc.in @@ -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", "Ettus Research (National Instruments)\0" + VALUE "FileDescription", "@PACKAGE@ dissector\0" + VALUE "FileVersion", "@MODULE_VERSION@\0" + VALUE "InternalName", "@PACKAGE@ @MODULE_VERSION@\0" + VALUE "LegalCopyright", "Copyright © 2013 Ettus Research (National Instruments)\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 --git a/tools/dissectors/zpu_addr_names.h b/tools/dissectors/zpu_addr_names.h new file mode 100644 index 000000000..ebbf423ed --- /dev/null +++ b/tools/dissectors/zpu_addr_names.h @@ -0,0 +1,38 @@ +/* + * Dissector for ZPU packets (communication with X300 firmware) + * + * Copyright 2013-2014 Ettus Research LLC + * + * 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 3 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, see <http://www.gnu.org/licenses/>. + * + */ + +/* TODO: autogenerate this file */ + +/* Names of SHMEM registers: */ +static const value_string X300_SHMEM_NAMES[] = { + { 0, "X300_FW_SHMEM_COMPAT_NUM" }, + { 1, "X300_FW_SHMEM_GPSDO_STATUS" }, + { 2, "X300_FW_SHMEM_UART_RX_INDEX" }, + { 3, "X300_FW_SHMEM_UART_TX_INDEX" }, + { 5, "X300_FW_SHMEM_CLAIM_STATUS" }, + { 6, "X300_FW_SHMEM_CLAIM_TIME" }, + { 7, "X300_FW_SHMEM_CLAIM_SRC" }, + { 8, "X300_FW_SHMEM_UART_RX_ADDR" }, + { 9, "X300_FW_SHMEM_UART_TX_ADDR" }, + { 10, "X300_FW_SHMEM_UART_WORDS32" }, + { 11, "X300_FW_SHMEM_ROUTE_MAP_ADDR" }, + { 12, "X300_FW_SHMEM_ROUTE_MAP_LEN" } +}; + |