git-svn-id: http://svn.eurecom.fr/openair4G/trunk@4233 818b1a75-f10b-46b9-bf7c-635c3b92a50f

common/utils/itti_analyzer/INSTALL

+Installation Instructions
+*************************
+
+Copyright (C) 1994-1996, 1999-2002, 2004-2011 Free Software Foundation,
+Inc.
+
+   Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.  This file is offered as-is,
+without warranty of any kind.
+
+Basic Installation
+==================
+
+   Briefly, the shell commands `./configure; make; make install' should
+configure, build, and install this package.  The following
+more-detailed instructions are generic; see the `README' file for
+instructions specific to this package.  Some packages provide this
+`INSTALL' file but do not implement all of the features documented
+below.  The lack of an optional feature in a given package is not
+necessarily a bug.  More recommendations for GNU packages can be found
+in *note Makefile Conventions: (standards)Makefile Conventions.
+
+   The `configure' shell script attempts to guess correct values for
+various system-dependent variables used during compilation.  It uses
+those values to create a `Makefile' in each directory of the package.
+It may also create one or more `.h' files containing system-dependent
+definitions.  Finally, it creates a shell script `config.status' that
+you can run in the future to recreate the current configuration, and a
+file `config.log' containing compiler output (useful mainly for
+debugging `configure').
+
+   It can also use an optional file (typically called `config.cache'
+and enabled with `--cache-file=config.cache' or simply `-C') that saves
+the results of its tests to speed up reconfiguring.  Caching is
+disabled by default to prevent problems with accidental use of stale
+cache files.
+
+   If you need to do unusual things to compile the package, please try
+to figure out how `configure' could check whether to do them, and mail
+diffs or instructions to the address given in the `README' so they can
+be considered for the next release.  If you are using the cache, and at
+some point `config.cache' contains results you don't want to keep, you
+may remove or edit it.
+
+   The file `configure.ac' (or `configure.in') is used to create
+`configure' by a program called `autoconf'.  You need `configure.ac' if
+you want to change it or regenerate `configure' using a newer version
+of `autoconf'.
+
+   The simplest way to compile this package is:
+
+  1. `cd' to the directory containing the package's source code and type
+     `./configure' to configure the package for your system.
+
+     Running `configure' might take a while.  While running, it prints
+     some messages telling which features it is checking for.
+
+  2. Type `make' to compile the package.
+
+  3. Optionally, type `make check' to run any self-tests that come with
+     the package, generally using the just-built uninstalled binaries.
+
+  4. Type `make install' to install the programs and any data files and
+     documentation.  When installing into a prefix owned by root, it is
+     recommended that the package be configured and built as a regular
+     user, and only the `make install' phase executed with root
+     privileges.
+
+  5. Optionally, type `make installcheck' to repeat any self-tests, but
+     this time using the binaries in their final installed location.
+     This target does not install anything.  Running this target as a
+     regular user, particularly if the prior `make install' required
+     root privileges, verifies that the installation completed
+     correctly.
+
+  6. You can remove the program binaries and object files from the
+     source code directory by typing `make clean'.  To also remove the
+     files that `configure' created (so you can compile the package for
+     a different kind of computer), type `make distclean'.  There is
+     also a `make maintainer-clean' target, but that is intended mainly
+     for the package's developers.  If you use it, you may have to get
+     all sorts of other programs in order to regenerate files that came
+     with the distribution.
+
+  7. Often, you can also type `make uninstall' to remove the installed
+     files again.  In practice, not all packages have tested that
+     uninstallation works correctly, even though it is required by the
+     GNU Coding Standards.
+
+  8. Some packages, particularly those that use Automake, provide `make
+     distcheck', which can by used by developers to test that all other
+     targets like `make install' and `make uninstall' work correctly.
+     This target is generally not run by end users.
+
+Compilers and Options
+=====================
+
+   Some systems require unusual options for compilation or linking that
+the `configure' script does not know about.  Run `./configure --help'
+for details on some of the pertinent environment variables.
+
+   You can give `configure' initial values for configuration parameters
+by setting variables in the command line or in the environment.  Here
+is an example:
+
+     ./configure CC=c99 CFLAGS=-g LIBS=-lposix
+
+   *Note Defining Variables::, for more details.
+
+Compiling For Multiple Architectures
+====================================
+
+   You can compile the package for more than one kind of computer at the
+same time, by placing the object files for each architecture in their
+own directory.  To do this, you can use GNU `make'.  `cd' to the
+directory where you want the object files and executables to go and run
+the `configure' script.  `configure' automatically checks for the
+source code in the directory that `configure' is in and in `..'.  This
+is known as a "VPATH" build.
+
+   With a non-GNU `make', it is safer to compile the package for one
+architecture at a time in the source code directory.  After you have
+installed the package for one architecture, use `make distclean' before
+reconfiguring for another architecture.
+
+   On MacOS X 10.5 and later systems, you can create libraries and
+executables that work on multiple system types--known as "fat" or
+"universal" binaries--by specifying multiple `-arch' options to the
+compiler but only a single `-arch' option to the preprocessor.  Like
+this:
+
+     ./configure CC="gcc -arch i386 -arch x86_64 -arch ppc -arch ppc64" \
+                 CXX="g++ -arch i386 -arch x86_64 -arch ppc -arch ppc64" \
+                 CPP="gcc -E" CXXCPP="g++ -E"
+
+   This is not guaranteed to produce working output in all cases, you
+may have to build one architecture at a time and combine the results
+using the `lipo' tool if you have problems.
+
+Installation Names
+==================
+
+   By default, `make install' installs the package's commands under
+`/usr/local/bin', include files under `/usr/local/include', etc.  You
+can specify an installation prefix other than `/usr/local' by giving
+`configure' the option `--prefix=PREFIX', where PREFIX must be an
+absolute file name.
+
+   You can specify separate installation prefixes for
+architecture-specific files and architecture-independent files.  If you
+pass the option `--exec-prefix=PREFIX' to `configure', the package uses
+PREFIX as the prefix for installing programs and libraries.
+Documentation and other data files still use the regular prefix.
+
+   In addition, if you use an unusual directory layout you can give
+options like `--bindir=DIR' to specify different values for particular
+kinds of files.  Run `configure --help' for a list of the directories
+you can set and what kinds of files go in them.  In general, the
+default for these options is expressed in terms of `${prefix}', so that
+specifying just `--prefix' will affect all of the other directory
+specifications that were not explicitly provided.
+
+   The most portable way to affect installation locations is to pass the
+correct locations to `configure'; however, many packages provide one or
+both of the following shortcuts of passing variable assignments to the
+`make install' command line to change installation locations without
+having to reconfigure or recompile.
+
+   The first method involves providing an override variable for each
+affected directory.  For example, `make install
+prefix=/alternate/directory' will choose an alternate location for all
+directory configuration variables that were expressed in terms of
+`${prefix}'.  Any directories that were specified during `configure',
+but not in terms of `${prefix}', must each be overridden at install
+time for the entire installation to be relocated.  The approach of
+makefile variable overrides for each directory variable is required by
+the GNU Coding Standards, and ideally causes no recompilation.
+However, some platforms have known limitations with the semantics of
+shared libraries that end up requiring recompilation when using this
+method, particularly noticeable in packages that use GNU Libtool.
+
+   The second method involves providing the `DESTDIR' variable.  For
+example, `make install DESTDIR=/alternate/directory' will prepend
+`/alternate/directory' before all installation names.  The approach of
+`DESTDIR' overrides is not required by the GNU Coding Standards, and
+does not work on platforms that have drive letters.  On the other hand,
+it does better at avoiding recompilation issues, and works well even
+when some directory options were not specified in terms of `${prefix}'
+at `configure' time.
+
+Optional Features
+=================
+
+   If the package supports it, you can cause programs to be installed
+with an extra prefix or suffix on their names by giving `configure' the
+option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
+
+   Some packages pay attention to `--enable-FEATURE' options to
+`configure', where FEATURE indicates an optional part of the package.
+They may also pay attention to `--with-PACKAGE' options, where PACKAGE
+is something like `gnu-as' or `x' (for the X Window System).  The
+`README' should mention any `--enable-' and `--with-' options that the
+package recognizes.
+
+   For packages that use the X Window System, `configure' can usually
+find the X include and library files automatically, but if it doesn't,
+you can use the `configure' options `--x-includes=DIR' and
+`--x-libraries=DIR' to specify their locations.
+
+   Some packages offer the ability to configure how verbose the
+execution of `make' will be.  For these packages, running `./configure
+--enable-silent-rules' sets the default to minimal output, which can be
+overridden with `make V=1'; while running `./configure
+--disable-silent-rules' sets the default to verbose, which can be
+overridden with `make V=0'.
+
+Particular systems
+==================
+
+   On HP-UX, the default C compiler is not ANSI C compatible.  If GNU
+CC is not installed, it is recommended to use the following options in
+order to use an ANSI C compiler:
+
+     ./configure CC="cc -Ae -D_XOPEN_SOURCE=500"
+
+and if that doesn't work, install pre-built binaries of GCC for HP-UX.
+
+   HP-UX `make' updates targets which have the same time stamps as
+their prerequisites, which makes it generally unusable when shipped
+generated files such as `configure' are involved.  Use GNU `make'
+instead.
+
+   On OSF/1 a.k.a. Tru64, some versions of the default C compiler cannot
+parse its `<wchar.h>' header file.  The option `-nodtk' can be used as
+a workaround.  If GNU CC is not installed, it is therefore recommended
+to try
+
+     ./configure CC="cc"
+
+and if that doesn't work, try
+
+     ./configure CC="cc -nodtk"
+
+   On Solaris, don't put `/usr/ucb' early in your `PATH'.  This
+directory contains several dysfunctional programs; working variants of
+these programs are available in `/usr/bin'.  So, if you need `/usr/ucb'
+in your `PATH', put it _after_ `/usr/bin'.
+
+   On Haiku, software installed for all users goes in `/boot/common',
+not `/usr/local'.  It is recommended to use the following options:
+
+     ./configure --prefix=/boot/common
+
+Specifying the System Type
+==========================
+
+   There may be some features `configure' cannot figure out
+automatically, but needs to determine by the type of machine the package
+will run on.  Usually, assuming the package is built to be run on the
+_same_ architectures, `configure' can figure that out, but if it prints
+a message saying it cannot guess the machine type, give it the
+`--build=TYPE' option.  TYPE can either be a short name for the system
+type, such as `sun4', or a canonical name which has the form:
+
+     CPU-COMPANY-SYSTEM
+
+where SYSTEM can have one of these forms:
+
+     OS
+     KERNEL-OS
+
+   See the file `config.sub' for the possible values of each field.  If
+`config.sub' isn't included in this package, then this package doesn't
+need to know the machine type.
+
+   If you are _building_ compiler tools for cross-compiling, you should
+use the option `--target=TYPE' to select the type of system they will
+produce code for.
+
+   If you want to _use_ a cross compiler, that generates code for a
+platform different from the build platform, you should specify the
+"host" platform (i.e., that on which the generated programs will
+eventually be run) with `--host=TYPE'.
+
+Sharing Defaults
+================
+
+   If you want to set default values for `configure' scripts to share,
+you can create a site shell script called `config.site' that gives
+default values for variables like `CC', `cache_file', and `prefix'.
+`configure' looks for `PREFIX/share/config.site' if it exists, then
+`PREFIX/etc/config.site' if it exists.  Or, you can set the
+`CONFIG_SITE' environment variable to the location of the site script.
+A warning: not all `configure' scripts look for a site script.
+
+Defining Variables
+==================
+
+   Variables not defined in a site shell script can be set in the
+environment passed to `configure'.  However, some packages may run
+configure again during the build, and the customized values of these
+variables may be lost.  In order to avoid this problem, you should set
+them in the `configure' command line, using `VAR=value'.  For example:
+
+     ./configure CC=/usr/local2/bin/gcc
+
+causes the specified `gcc' to be used as the C compiler (unless it is
+overridden in the site shell script).
+
+Unfortunately, this technique does not work for `CONFIG_SHELL' due to
+an Autoconf bug.  Until the bug is fixed you can use this workaround:
+
+     CONFIG_SHELL=/bin/bash /bin/bash ./configure CONFIG_SHELL=/bin/bash
+
+`configure' Invocation
+======================
+
+   `configure' recognizes the following options to control how it
+operates.
+
+`--help'
+`-h'
+     Print a summary of all of the options to `configure', and exit.
+
+`--help=short'
+`--help=recursive'
+     Print a summary of the options unique to this package's
+     `configure', and exit.  The `short' variant lists options used
+     only in the top level, while the `recursive' variant lists options
+     also present in any nested packages.
+
+`--version'
+`-V'
+     Print the version of Autoconf used to generate the `configure'
+     script, and exit.
+
+`--cache-file=FILE'
+     Enable the cache: use and save the results of the tests in FILE,
+     traditionally `config.cache'.  FILE defaults to `/dev/null' to
+     disable caching.
+
+`--config-cache'
+`-C'
+     Alias for `--cache-file=config.cache'.
+
+`--quiet'
+`--silent'
+`-q'
+     Do not print messages saying which checks are being made.  To
+     suppress all normal output, redirect it to `/dev/null' (any error
+     messages will still be shown).
+
+`--srcdir=DIR'
+     Look for the package's source code in directory DIR.  Usually
+     `configure' can determine that directory automatically.
+
+`--prefix=DIR'
+     Use DIR as the installation prefix.  *note Installation Names::
+     for more details, including other options available for fine-tuning
+     the installation locations.
+
+`--no-create'
+`-n'
+     Run the configure checks, but stop before creating any output
+     files.
+
+`configure' also accepts some other, not widely useful, options.  Run
+`configure --help' for more details.
+

common/utils/itti_analyzer/Makefile.am

+AM_CFLAGS =	\
+	@ADD_CFLAGS@	\
+	-I$(top_srcdir)/libparser	\
+	-I$(top_srcdir)/libresolver	\
+	-I$(top_srcdir)/libbuffers	\
+	-I$(top_srcdir)/libui
+
+SUBDIRS = libparser libresolver libbuffers libui .
+
+itti_analyzer_LDADD = \
+	$(top_builddir)/libui/libui.la	\
+	$(top_builddir)/libparser/libparser.la	\
+	$(top_builddir)/libresolver/libresolver.la	\
+	$(top_builddir)/libbuffers/libbuffers.la
+
+bin_PROGRAMS = itti_analyzer

common/utils/itti_analyzer/autogen.sh

+#! /bin/sh
+
+aclocal \
+&& autoheader \
+&& automake --add-missing \
+&& autoconf
\ No newline at end of file

common/utils/itti_analyzer/configure.ac

+AC_PREREQ([2.68])
+
+define([svnversion], esyscmd([sh -c "svnversion ..|tr -d '\n'"]))
+
+AC_DEFINE(SVN_REVISION, "svnversion", [SVN Revision])
+
+AC_INIT([itti_debugger], [0.1.svnversion], [openair_admin@eurecom.fr])
+AC_CANONICAL_BUILD
+AC_CANONICAL_TARGET
+AM_INIT_AUTOMAKE([1.11 silent-rules])
+
+AC_CONFIG_MACRO_DIR([m4])
+
+AC_CONFIG_HEADERS([config.h])
+
+AM_MAINTAINER_MODE
+
+AM_SILENT_RULES([yes])
+
+AM_PROG_LIBTOOL
+
+AC_PROG_RANLIB
+AC_PROG_CXX
+
+AC_FUNC_ALLOCA
+AC_FUNC_MALLOC
+AC_FUNC_REALLOC
+
+AC_TYPE_SIZE_T
+AC_TYPE_SSIZE_T
+AC_TYPE_INT8_T
+AC_TYPE_INT16_T
+AC_TYPE_INT32_T
+AC_TYPE_INT64_T
+AC_TYPE_UINT8_T
+AC_TYPE_UINT16_T
+AC_TYPE_UINT32_T
+AC_TYPE_UINT64_T
+
+AC_CHECK_FUNCS([memset])
+AC_CHECK_FUNCS([socket])
+AC_CHECK_FUNCS([strdup])
+AC_CHECK_FUNCS([strerror])
+
+AC_CHECK_HEADERS([arpa/inet.h])
+AC_CHECK_HEADERS([fcntl.h])
+AC_CHECK_HEADERS([libintl.h])
+AC_CHECK_HEADERS([malloc.h])
+AC_CHECK_HEADERS([stddef.h])
+AC_CHECK_HEADERS([netinet/in.h])
+
+PKG_CHECK_MODULES(XML2, [libxml-2.0 >= 2.7.8], [HAVE_XML2=true], [AC_MSG_ERROR(lixml-2.0 not installed)])
+CFLAGS="$CFLAGS $XML2_CFLAGS"
+LIBS="$LIBS $XML2_LIBS"
+
+AM_PATH_GTK_3_0(3.0.0, [], AC_MSG_ERROR(Requirement not met: gtk >= 3.0.0))
+CFLAGS="$CFLAGS $GTK_CFLAGS"
+LIBS="$LIBS $GTK_LIBS"
+
+dnl Add these flags
+CFLAGS="$CFLAGS -Wall"
+CFLAGS="$CFLAGS -Wshadow"
+CFLAGS="$CFLAGS -Wcast-align"
+CFLAGS="$CFLAGS -Wchar-subscripts"
+CFLAGS="$CFLAGS -Wmissing-prototypes"
+CFLAGS="$CFLAGS -Wmissing-declarations"
+CFLAGS="$CFLAGS -Werror=implicit-function-declaration"
+
+AC_SUBST([AM_CFLAGS])
+AC_SUBST(ADD_CFLAGS)
+
+dnl *** Autoconf support ***
+AC_ARG_ENABLE(autoconf,
+  [  --disable-autoconf      disable automatic generation of configure script ],
+  enable_autoconf=$enableval, enable_autoconf=yes
+)
+AC_PATH_PROG(AUTOCONF, autoconf, @echo autoconf not available)
+AC_PATH_PROG(AUTOHEADER, autoheader, @echo autoheader not available)
+if test -z "$AUTOCONF"; then enable_autoconf=no ; fi
+if test -z "$AUTOHEADER"; then enable_autoconf=no ; fi
+if test x$enable_autoconf = xyes; then
+  CONFIGURE_DEPENDS="configure.in aclocal.m4"
+fi
+AC_SUBST(CONFIGURE_DEPENDS)
+
+AC_CONFIG_FILES(
+    libbuffers/Makefile             \
+    libparser/Makefile              \
+    libresolver/Makefile            \
+    libui/Makefile                  \
+    Makefile                        \
+)
+AC_OUTPUT
\ No newline at end of file

common/utils/itti_analyzer/itti_analyzer.c

+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+
+#include <gtk/gtk.h>
+
+#include "xml_parse.h"
+#include "resolvers.h"
+#include "locate_root.h"
+#include "file.h"
+#include "ui_main_screen.h"
+
+#include "rc.h"
+
+int debug_buffers = 1;
+int debug_parser = 0;
+
+int main(int argc, char *argv[])
+{
+    int ret = 0;
+
+    CHECK_FCT(ui_gtk_initialize(argc, argv));
+
+    return ret;
+}

common/utils/itti_analyzer/libbuffers/Makefile.am

+AM_CFLAGS =	\
+	@ADD_CFLAGS@	\
+	-I$(top_srcdir)	\
+	-I$(top_srcdir)/libparser	\
+	-I$(top_srcdir)/libui
+
+noinst_LTLIBRARIES = libbuffers.la
+
+libbuffers_la_LDFLAGS = -all-static
+libbuffers_la_SOURCES = \
+	buffers.c	buffers.h	\
+	file.c	file.h	\
+	socket.c	socket.h

common/utils/itti_analyzer/libbuffers/buffers.c

+#include <pthread.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "../rc.h"
+#include "buffers.h"
+
+extern int debug_buffers;
+
+buffer_list_t list = {
+    .head = NULL,
+    .tail = NULL,
+    .count = 0,
+};
+pthread_mutex_t buffer_list_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static
+int buffer_fetch(buffer_t *buffer, uint32_t offset, int size, void *value);
+
+/* Try to fetch 8 bits unsigned from the buffer */
+uint8_t buffer_get_uint8_t(buffer_t *buffer, uint32_t offset)
+{
+    uint8_t value;
+
+    buffer_fetch(buffer, offset, 1, &value);
+
+    return value;
+}
+
+/* Try to fetch 16 bits unsigned from the buffer */
+uint16_t buffer_get_uint16_t(buffer_t *buffer, uint32_t offset)
+{
+    uint16_t value;
+
+    buffer_fetch(buffer, offset, 2, &value);
+
+    return value;
+}
+
+/* Try to fetch 32 bits unsigned from the buffer */
+uint32_t buffer_get_uint32_t(buffer_t *buffer, uint32_t offset)
+{
+    uint32_t value;
+
+    buffer_fetch(buffer, offset, 4, &value);
+
+    return value;
+}
+
+static
+int buffer_fetch(buffer_t *buffer, uint32_t offset, int size, void *value)
+{
+    if (buffer == NULL || value == NULL)
+        return -1;
+    if (size <= 0)
+        return -1;
+
+    if (buffer->size_bytes < ((offset >> 3) + size)) {
+        printf("Not enough data to fetch\n");
+        return -1;
+    }
+
+    memcpy(value, &buffer->data[offset >> 3], size);
+    buffer->buffer_current = &buffer->data[(offset >> 3) + size];
+
+    return 0;
+}
+
+int buffer_fetch_bits(buffer_t *buffer, uint32_t offset, int nbits, uint32_t *value)
+{
+    uint32_t temp = 0;
+    int i;
+
+    if (buffer == NULL || value == NULL)
+        return RC_BAD_PARAM;
+
+    /* We cannot fetch more than 32 bits */
+    if (nbits > 32)
+        return RC_BAD_PARAM;
+
+    for (i = 0; i < nbits; i++)
+    {
+        temp |= ((buffer->data[(offset + i) / 8] >> ((offset + i) % 8)) & 1) << i;
+    }
+
+    *value = temp;
+
+    return RC_OK;
+}
+
+/**
+ * @brief Create a new buffer from data
+ * @param buffer caller reference where created buffer will be stored
+ * @param data Data to attach to the new buffer
+ * @param length Length of data buffer
+ * @param data_static flag that indicates if data pointer has been statically (= 0) or not (!= 0)
+ */
+int buffer_new_from_data(buffer_t **buffer, uint8_t *data, const uint32_t length,
+                         int data_static)
+{
+    buffer_t *new;
+
+    if (!buffer)
+        return RC_BAD_PARAM;
+
+    new = malloc(sizeof(buffer_t));
+
+    new->size_bytes = length;
+    if (data && length > 0) {
+        if (data_static == 0) {
+            new->data = malloc(sizeof(uint8_t) * new->size_bytes);
+            memcpy(new->data, data, new->size_bytes);
+        } else {
+            new->data = data;
+        }
+        new->buffer_current = &new->data[0];
+    } else {
+        new->buffer_current = NULL;
+    }
+
+    new->next = NULL;
+
+    *buffer = new;
+
+    return 0;
+}
+
+#define INDENTED(fILE, x, y)            \
+do {                                    \
+    int indentation = x;                \
+    while(indentation--) fprintf(fILE, " ");  \
+    y;                                  \
+} while(0)
+
+#define INDENT_BREAK    20
+
+void buffer_dump(buffer_t *buffer, FILE *to)
+{
+    FILE *file = to;
+    uint32_t i;
+
+    if (!buffer)
+        return;
+    if (!to)
+        to = stdout;
+
+    fprintf(file, "<Buffer>\n");
+    INDENTED(file, 4, fprintf(file, "<Length>%u<Length>\n", buffer->size_bytes));
+    INDENTED(file, 4, fprintf(file, "<Bytes>\n"));
+    for (i = 0; i < buffer->size_bytes; i++)
+    {
+        if ((i % INDENT_BREAK) == 0)
+            fprintf(file, "        ");
+        fprintf(file, "0x%02x ", buffer->data[i]);
+        if ((i % INDENT_BREAK) == (INDENT_BREAK - 1))
+            fprintf(file, "\n");
+    }
+    if ((i % INDENT_BREAK) != (INDENT_BREAK - 1))
+        fprintf(file, "\n");
+    INDENTED(file, 4, fprintf(file, "</Bytes>\n"));
+    fprintf(file, "</Buffer>\n");
+}
+
+int buffer_append_data(buffer_t *buffer, const uint8_t *data, const uint32_t length)
+{
+    if (!buffer)
+        return -1;
+
+    if (data && length > 0) {
+        if (!buffer->data) {
+            buffer->size_bytes = length;
+            buffer->data = malloc(sizeof(uint8_t) * buffer->size_bytes);
+            memcpy(buffer->data, data, buffer->size_bytes);
+        } else {
+            buffer->data = realloc(buffer->data, sizeof(uint8_t) * (buffer->size_bytes + length));
+            memcpy(&buffer->data[buffer->size_bytes], data, length);
+            buffer->size_bytes += length;
+        }
+        buffer->buffer_current = &buffer->data[0];
+    }
+
+    return 0;
+}
+
+int buffer_has_enouch_data(buffer_t *buffer, uint32_t offset, uint32_t to_get)
+{
+    int underflow;
+    if (!buffer)
+        return -1;
+    underflow = (buffer->size_bytes >= ((offset + to_get) / 8)) ? 0 : -1;
+    if (underflow && debug_buffers)
+        printf("Detected Underflow offset %u, to_get %u, buffer size %u\n",
+               offset, to_get, buffer->size_bytes);
+    return underflow;
+}
+
+int buffer_get_from_mn(const uint32_t message_number, buffer_t **buffer)
+{
+    buffer_t *temp_buf;
+
+    if (!buffer)
+        return RC_BAD_PARAM;
+
+    for (temp_buf = list.head; temp_buf; temp_buf = temp_buf->next) {
+        if (temp_buf->message_number == message_number) {
+            break;
+        }
+    }
+
+    *buffer = temp_buf;
+
+    return RC_OK;
+}
+
+int buffer_add_to_list(buffer_t *new_buf)
+{
+    if (!new_buf)
+        return RC_BAD_PARAM;
+
+    pthread_mutex_lock(&buffer_list_mutex);
+
+    /* No element at tail */
+    if (list.tail == NULL) {
+        if (list.head == NULL) {
+            list.head = new_buf;
+            list.tail = list.head;
+        } else {
+            return RC_FAIL;
+        }
+    } else {
+        list.tail->next = new_buf;
+        new_buf->previous = list.tail;
+        list.tail = new_buf;
+    }
+
+    list.count++;
+
+    pthread_mutex_unlock(&buffer_list_mutex);
+
+    return RC_OK;
+}

common/utils/itti_analyzer/libbuffers/buffers.h

+#include <stdint.h>
+
+#ifndef BUFFERS_H_
+#define BUFFERS_H_
+
+typedef struct buffer_s {
+    /* The size in bytes as read from socket */
+    uint32_t size_bytes;
+
+    /* Current position */
+    uint8_t *buffer_current;
+
+    /* The complete data */
+    uint8_t *data;
+
+    /* The message number as read from socket */
+    uint32_t message_number;
+
+    uint32_t message_id;
+
+    struct buffer_s *previous;
+    struct buffer_s *next;
+} buffer_t;
+
+typedef struct {
+    buffer_t *head;
+    buffer_t *tail;
+
+    uint32_t count;
+} buffer_list_t;
+
+uint8_t buffer_get_uint8_t(buffer_t *buffer, uint32_t offset);
+
+uint16_t buffer_get_uint16_t(buffer_t *buffer, uint32_t offset);
+
+uint32_t buffer_get_uint32_t(buffer_t *buffer, uint32_t offset);
+
+int buffer_fetch_bits(buffer_t *buffer, uint32_t offset, int nbits, uint32_t *value);
+
+void buffer_dump(buffer_t *buffer, FILE *to);
+
+int buffer_append_data(buffer_t *buffer, const uint8_t *data, const uint32_t length);
+
+int buffer_new_from_data(buffer_t **buffer, uint8_t *data, const uint32_t length,
+                         int data_static);
+
+int buffer_has_enouch_data(buffer_t *buffer, uint32_t offset, uint32_t to_get);
+
+int buffer_add_to_list(buffer_t *new_buf);
+
+int buffer_get_from_mn(const uint32_t message_number, buffer_t **buffer);
+
+#endif /* BUFFERS_H_ */

common/utils/itti_analyzer/libbuffers/file.c

+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include "../rc.h"
+#include "buffers.h"
+#include "file.h"
+
+#define READ_BUFFER_SIZE 1024
+
+int file_read_dump(buffer_t **buffer, const char *filename)
+{
+    int fd = -1;
+    buffer_t *new_buf = NULL;
+    uint8_t   data[READ_BUFFER_SIZE];
+    ssize_t   current_read;
+
+    if (!filename)
+        return RC_BAD_PARAM;
+
+    if ((fd = open(filename, O_RDONLY)) == -1) {
+        fprintf(stderr, "Cannot open %s for reading, returned %d:%s\n",
+                filename, errno, strerror(errno));
+        return RC_FAIL;
+    }
+
+    CHECK_FCT(buffer_new_from_data(&new_buf, NULL, 0, 0));
+
+    do {
+        current_read = read(fd, data, READ_BUFFER_SIZE);
+        if (current_read == -1)
+        {
+            fprintf(stderr, "Failed to read data from file, returned %d:%s\n",
+                    errno, strerror(errno));
+            return RC_FAIL;
+        }
+        CHECK_FCT(buffer_append_data(new_buf, data, current_read));
+    } while(current_read == READ_BUFFER_SIZE);
+
+    *buffer = new_buf;
+
+    buffer_dump(new_buf, stdout);
+
+    close(fd);
+
+    return RC_OK;
+}

common/utils/itti_analyzer/libbuffers/file.h

+#ifndef FILE_H_
+#define FILE_H_
+
+int file_read_dump(buffer_t **buffer, const char *filename);
+
+#endif /* FILE_H_ */

common/utils/itti_analyzer/libbuffers/socket.c

+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include <gtk/gtk.h>
+
+#include "../rc.h"
+
+#include "ui_interface.h"
+#include "ui_notifications.h"
+
+#include "socket.h"
+#include "buffers.h"
+
+#include "xml_parse.h"
+
+#define BUFFER_SIZE 3000
+#define MAX_ATTEMPTS    10
+
+socket_data_t socket_data;
+
+typedef struct {
+    char     ip_address[16];
+    uint16_t port;
+} socket_arg_t;
+
+/* Message header is the common part that should never change between
+ * remote process and this one.
+ */
+typedef struct {
+    /* The size of this structure */
+    uint32_t message_size;
+    uint32_t message_type;
+} itti_socket_header_t;
+
+typedef struct {
+    uint32_t message_number;
+    char     signal_name[50];
+} itti_dump_message_t;
+
+void *socket_read_data(void *arg);
+
+void *socket_read_data(void *arg)
+{
+    int ret;
+    int attempts = MAX_ATTEMPTS;
+    int *sd = &socket_data.sd;
+    struct sockaddr_in *si_me = &socket_data.si_me;
+    socket_arg_t *socket_arg;
+
+    socket_arg = (socket_arg_t *)arg;
+
+    memset(&socket_data, 0, sizeof(socket_data_t));
+
+    /* Enable the cancel attribute for the thread.
+     * Set the cancel type to asynchronous. The thread termination is requested
+     * to happen now.
+     */
+    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
+    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+
+    *sd = -1;
+
+    if ((*sd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
+        fprintf(stderr, "socket failed\n");
+        goto fail;
+    }
+    memset((void *)si_me, 0, sizeof(si_me));
+
+    si_me->sin_family = AF_INET;
+    si_me->sin_port = htons(socket_arg->port);
+    if (inet_aton(socket_arg->ip_address, &si_me->sin_addr) == 0) {
+        fprintf(stderr, "inet_aton() failed\n");
+        goto fail;
+    }
+
+    do {
+        ret = connect(*sd, (struct sockaddr *)si_me, sizeof(struct sockaddr_in));
+        if (ret == 0) {
+            break;
+        }
+        attempts --;
+        sleep(1);
+        if (attempts == 0) {
+            printf("Cannot connect to %s with port %u:\n"
+            "Reached maximum retry count\nEnsure host is alive",
+            socket_arg->ip_address, socket_arg->port);
+            /* ????? */
+            ui_interface.ui_notification_dialog(
+                DIALOG_ERROR, "Cannot connect to %s with port %u:\n"
+                "Reached maximum retry count\nEnsure host is alive",
+                socket_arg->ip_address, socket_arg->port);
+            ui_interface.ui_enable_connect_button();
+
+            pthread_exit(NULL);
+        }
+    } while(ret != 0);
+
+    while(1) {
+        uint8_t *data;
+        size_t data_length;
+        itti_socket_header_t message_header;
+        int recv_ret;
+        buffer_t *buffer;
+
+        memset(&message_header, 0, sizeof(itti_socket_header_t));
+
+        /* First run acquire message header
+         * TODO: check for remote endianness when retrieving the structure...
+         */
+        recv_ret = recvfrom(socket_data.sd, &message_header, sizeof(itti_socket_header_t), MSG_WAITALL, NULL, 0);
+        if (recv_ret == -1) {
+            /* Failure case */
+            fprintf(stderr, "recvfrom failed\n");
+            ui_interface.ui_notification_dialog(
+                DIALOG_ERROR, "Unexpected error while reading from socket\n%d:%s",
+                errno, strerror(errno));
+            ui_interface.ui_enable_connect_button();
+            pthread_exit(NULL);
+        } else if (recv_ret == 0) {
+            /* We lost the connection with other peer or shutdown asked */
+            ui_interface.ui_notification_dialog(
+                DIALOG_ERROR, "Connection with remote host has been lost");
+            ui_interface.ui_enable_connect_button();
+            pthread_exit(NULL);
+        }
+
+        switch(message_header.message_type) {
+            case 1: {
+                itti_dump_message_t itti_dump_header;
+
+                memset(&itti_dump_header, 0, sizeof(itti_dump_message_t));
+
+                /* second run: acquire the sub-header for itti dump message type */
+                recv_ret = recvfrom(socket_data.sd, &itti_dump_header, sizeof(itti_dump_message_t), MSG_WAITALL, NULL, 0);
+                if (recv_ret == -1) {
+                    /* Failure case */
+                    fprintf(stderr, "recvfrom failed\n");
+                    ui_interface.ui_notification_dialog(
+                        DIALOG_ERROR, "Unexpected error while reading from socket\n%d:%s",
+                        errno, strerror(errno));
+                    ui_interface.ui_enable_connect_button();
+                    pthread_exit(NULL);
+                } else if (recv_ret == 0) {
+                    /* We lost the connection with other peer or shutdown asked */
+                    ui_interface.ui_notification_dialog(
+                        DIALOG_ERROR, "Connection with remote host has been lost");
+                    ui_interface.ui_enable_connect_button();
+                    pthread_exit(NULL);
+                }
+
+                data_length = message_header.message_size - sizeof(itti_socket_header_t) - sizeof(itti_dump_message_t);
+                data = malloc(sizeof(uint8_t) * data_length);
+
+                /* third run: acquire the MessageDef part */
+                recv_ret = recvfrom(socket_data.sd, data, data_length, MSG_WAITALL, NULL, 0);
+                if (recv_ret == -1) {
+                    /* Failure case */
+                    fprintf(stderr, "recvfrom failed\n");
+                    ui_interface.ui_notification_dialog(
+                        DIALOG_ERROR, "Unexpected error while reading from socket\n%d:%s",
+                        errno, strerror(errno));
+                    ui_interface.ui_enable_connect_button();
+                    pthread_exit(NULL);
+                } else if (recv_ret == 0) {
+                    /* We lost the connection with other peer or shutdown asked */
+                    ui_interface.ui_notification_dialog(
+                        DIALOG_ERROR, "Connection with remote host has been lost");
+                    ui_interface.ui_enable_connect_button();
+                    pthread_exit(NULL);
+                }
+
+                /* Create the new buffer */
+                if (buffer_new_from_data(&buffer, data, data_length, 1) != RC_OK) {
+                    ui_interface.ui_notification_dialog(
+                        DIALOG_ERROR, "Cannot connect to %s with port %u",
+                        socket_arg->ip_address, socket_arg->port);
+                    ui_interface.ui_enable_connect_button();
+                    pthread_exit(NULL);
+                }
+
+                buffer->message_number = itti_dump_header.message_number;
+                buffer_dump(buffer, stdout);
+
+                CHECK_FCT_DO(buffer_add_to_list(buffer), pthread_exit(NULL));
+
+                ui_interface.ui_tree_view_new_signal_ind(itti_dump_header.message_number,
+                                                         itti_dump_header.signal_name);
+            } break;
+            case 2:
+                /* The received message is a statistic signal */
+                break;
+            case 3: {
+                char *xml_definition;
+                uint32_t xml_definition_length;
+
+                xml_definition_length = message_header.message_size - sizeof(message_header);
+
+                xml_definition = malloc(xml_definition_length);
+
+                recv_ret = recvfrom(socket_data.sd, xml_definition, xml_definition_length, MSG_WAITALL, NULL, 0);
+                if (recv_ret == -1) {
+                    /* Failure case */
+                    fprintf(stderr, "recvfrom failed\n");
+                    ui_interface.ui_notification_dialog(
+                        DIALOG_ERROR, "Unexpected error while reading from socket\n%d:%s",
+                        errno, strerror(errno));
+                    ui_interface.ui_enable_connect_button();
+                    pthread_exit(NULL);
+                } else if (recv_ret == 0) {
+                    /* We lost the connection with other peer or shutdown asked */
+                    ui_interface.ui_notification_dialog(
+                        DIALOG_ERROR, "Connection with remote host has been lost");
+                    ui_interface.ui_enable_connect_button();
+                    pthread_exit(NULL);
+                }
+
+                fprintf(stdout, "Received XML definition of length %u\n",
+                        xml_definition_length);
+
+                xml_parse_buffer(xml_definition, xml_definition_length);
+            } break;
+            default:
+                ui_interface.ui_notification_dialog(
+                    DIALOG_ERROR, "Received unknown message type\n");
+                break;
+        }
+    }
+
+    return NULL;
+
+fail:
+    ui_interface.ui_notification_dialog(
+        DIALOG_ERROR, "Cannot connect to %s with port %u",
+        socket_arg->ip_address, socket_arg->port);
+    ui_interface.ui_enable_connect_button();
+    pthread_exit(NULL);
+}
+
+int socket_disconnect_from_remote_host(void)
+{
+    void *ret_val;
+
+    printf("Closing socket %d\n", socket_data.sd);
+
+    /* Cancel the thread */
+    pthread_cancel(socket_data.thread);
+    pthread_join(socket_data.thread, &ret_val);
+
+    /* Send shutdown to remote host */
+    CHECK_FCT_POSIX(shutdown(socket_data.sd, SHUT_RDWR));
+    CHECK_FCT_POSIX(close(socket_data.sd));
+
+    socket_data.sd = -1;
+    ui_interface.ui_enable_connect_button();
+
+    return RC_OK;
+}
+
+int socket_connect_to_remote_host(const char *remote_ip, const uint16_t port)
+{
+    socket_arg_t *socket_arg;
+
+    socket_arg = malloc(sizeof(socket_arg_t));
+
+    ui_interface.ui_disable_connect_button();
+
+    memcpy(socket_arg->ip_address, remote_ip, strlen(remote_ip) + 1);
+    socket_arg->port = port;
+
+    if (pthread_create(&socket_data.thread, NULL, socket_read_data, socket_arg) != 0) {
+        fprintf(stderr, "pthread_create failed\n");
+        ui_interface.ui_enable_connect_button();
+        return RC_FAIL;
+    }
+
+    return RC_OK;
+}

common/utils/itti_analyzer/libbuffers/socket.h

+#include <arpa/inet.h>
+#include <netinet/in.h>
+
+#ifndef SOCKET_H_
+#define SOCKET_H_
+
+typedef struct {
+    pthread_t thread;
+    uint16_t  port;
+    char     *remote_ip;
+    int       sd;
+    struct sockaddr_in si_me;
+} socket_data_t;
+
+int socket_connect_to_remote_host(const char *remote_ip, const uint16_t port);
+
+int socket_disconnect_from_remote_host(void);
+
+#endif /* SOCKET_H_ */

common/utils/itti_analyzer/libparser/Makefile.am

+AM_CFLAGS =	\
+	@ADD_CFLAGS@	\
+	-I$(top_srcdir)	\
+	-I$(top_srcdir)/libbuffers	\
+	-I$(top_srcdir)/libui
+
+noinst_LTLIBRARIES = libparser.la
+
+libparser_la_LDFLAGS = -all-static
+libparser_la_SOURCES = \
+	xml_parse.c	\
+	array_type.c array_type.h	\
+	enum_type.c enum_type.h	\
+	enum_value_type.c enum_value_type.h	\
+	file_type.c file_type.h	\
+	field_type.c field_type.h	\
+	fundamental_type.c fundamental_type.h	\
+	pointer_type.h	pointer_type.c	\
+	reference_type.c	reference_type.h	\
+	struct_type.c struct_type.h	\
+	typedef_type.c	typedef_type.h	\
+	types.h	types.c	\
+	union_type.c	union_type.h

common/utils/itti_analyzer/libparser/array_type.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+
+#include "array_type.h"
+#include "fundamental_type.h"
+#include "ui_interface.h"
+
+int array_dissect_from_buffer(struct types_s *type, buffer_t *buffer, uint32_t offset, uint32_t parent_offset,
+                              int indent) {
+    struct types_s *type_child;
+
+    DISPLAY_PARSE_INFO("array", type->name, offset, parent_offset);
+
+    /* Ignore TYPEDEF children */
+    for (type_child = type->child; type_child != NULL && type_child->type == TYPE_TYPEDEF;
+            type_child = type_child->child) {
+    }
+
+    if (type->name) {
+        INDENTED(stdout, indent, fprintf(stdout, "<%s>\n", type->name));
+    }
+    if (type->child != NULL) {
+        int items = type->size / type_child->size;
+        int i;
+        int zero_counter = 0;
+
+        /* Factorizes trailing 0 */
+        if ((items > 1) && (type_child->type == TYPE_FUNDAMENTAL))
+        {
+            for (i = items - 1; i >= 0; i--)
+            {
+                if (fundamental_read_from_buffer(type_child, buffer, parent_offset, offset + i * type_child->size) == 0)
+                {
+                    zero_counter ++;
+                }
+                else
+                {
+                    break;
+                }
+            }
+            /* Do not factorize if there is only one item */
+            if (zero_counter <= 1)
+            {
+                zero_counter = 0;
+            }
+        }
+        for (i = 0; i < (items - zero_counter); i++)
+            type->child->type_dissect_from_buffer (type->child, buffer, parent_offset, offset + i * type_child->size,
+                                                   type->name == NULL ? indent : indent + 4);
+        if (zero_counter > 0)
+        {
+            int length = 0;
+             char cbuf[50];
+             char *cpy = NULL;
+
+             INDENTED_STRING(cbuf, type->name == NULL ? indent : indent + 4,);
+
+             length = sprintf(cbuf, "[%d .. %d]  ", i, items -1);
+             cpy = malloc(sizeof(char) * length);
+             memcpy(cpy, cbuf, length);
+             ui_interface.ui_signal_set_text(cpy, length);
+             if (cpy)
+                 free(cpy);
+
+             type->child->type_dissect_from_buffer (type->child, buffer, parent_offset, offset + i * type_child->size, 0);
+        }
+    }
+    if (type->name) {
+        INDENTED(stdout, indent, fprintf(stdout, "</%s>\n", type->name));
+    }
+
+    return 0;
+}
+
+int array_type_file_print(struct types_s *type, int indent, FILE *file) {
+    if (type == NULL)
+        return -1;
+    INDENTED(file, indent, fprintf(file, "<Array>\n"));
+    INDENTED(file, indent+4, fprintf(file, "Id .........: %d\n", type->id));
+    INDENTED(file, indent+4, fprintf(file, "Min ........: %d\n", type->min));
+    INDENTED(file, indent+4, fprintf(file, "Max ........: %d\n", type->max));
+    INDENTED(file, indent+4, fprintf(file, "Type .......: %d\n", type->type_xml));
+    INDENTED(file, indent+4, fprintf(file, "Size .......: %d\n", type->size));
+    INDENTED(file, indent+4, fprintf(file, "Align ......: %d\n", type->align));
+    if (type->file_ref != NULL)
+        type->file_ref->type_file_print (type->file_ref, indent + 4, file);
+    if (type->child != NULL)
+        type->child->type_file_print (type->child, indent + 4, file);
+    INDENTED(file, indent, fprintf(file, "</Array>\n"));
+
+    return 0;
+}
+
+int array_type_hr_display(struct types_s *type, int indent) {
+    if (type == NULL)
+        return -1;
+    INDENTED(stdout, indent, printf("<Array>\n"));
+    INDENTED(stdout, indent+4, printf("Id .........: %d\n", type->id));
+    INDENTED(stdout, indent+4, printf("Min ........: %d\n", type->min));
+    INDENTED(stdout, indent+4, printf("Max ........: %d\n", type->max));
+    INDENTED(stdout, indent+4, printf("Type .......: %d\n", type->type_xml));
+    INDENTED(stdout, indent+4, printf("Size .......: %d\n", type->size));
+    INDENTED(stdout, indent+4, printf("Align ......: %d\n", type->align));
+    if (type->file_ref != NULL)
+        type->file_ref->type_hr_display (type->file_ref, indent + 4);
+    if (type->child != NULL)
+        type->child->type_hr_display (type->child, indent + 4);
+    INDENTED(stdout, indent, printf("</Array>\n"));
+
+    return 0;
+}

common/utils/itti_analyzer/libparser/array_type.h

+#include "types.h"
+
+#ifndef ARRAY_TYPE_H_
+#define ARRAY_TYPE_H_
+
+int array_dissect_from_buffer(struct types_s *type, buffer_t *buffer,
+                              uint32_t offset, uint32_t parent_offset, int indent);
+
+int array_type_hr_display(struct types_s *type, int indent);
+
+int array_type_file_print(struct types_s *type, int indent, FILE *file);
+
+#endif /* ARRAY_TYPE_H_ */