Logo Search packages:      
Sourcecode: ethereal version File versions

sigcomp-udvm.c

/* sigcomp-udvm.c
 * Routines making up the Universal Decompressor Virtual Machine (UDVM) used for
 * Signaling Compression (SigComp) dissection.
 * Copyright 2004, Anders Broman <anders.broman@ericsson.com>
 *
 * $Id: sigcomp-udvm.c 12613 2004-11-28 19:39:19Z etxrab $
 *
 * Ethereal - Network traffic analyzer
 * By Gerald Combs <gerald@ethereal.com>
 * Copyright 1998 Gerald Combs
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 * References:
 * http://www.ietf.org/rfc/rfc3320.txt?number=3320
 * http://www.ietf.org/rfc/rfc3321.txt?number=3321
 * Useful links :
 * http://www.ietf.org/internet-drafts/draft-ietf-rohc-sigcomp-impl-guide-03.txt
 * http://www.ietf.org/internet-drafts/draft-ietf-rohc-sigcomp-sip-01.txt
 */

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <glib.h>

#ifdef NEED_SNPRINTF_H
# include "snprintf.h"
#endif

#include "packet.h"
#include "strutil.h"
#include "sigcomp-udvm.h"
#include "sigcomp_state_hdlr.h"
#include "sha1.h"

#define     SIGCOMP_INSTR_DECOMPRESSION_FAILURE     0
#define SIGCOMP_INSTR_AND                       1
#define SIGCOMP_INSTR_OR                        2
#define SIGCOMP_INSTR_NOT                       3
#define SIGCOMP_INSTR_LSHIFT                    4
#define SIGCOMP_INSTR_RSHIFT                    5
#define SIGCOMP_INSTR_ADD                       6
#define SIGCOMP_INSTR_SUBTRACT                  7
#define SIGCOMP_INSTR_MULTIPLY                  8
#define SIGCOMP_INSTR_DIVIDE                    9
#define SIGCOMP_INSTR_REMAINDER                 10
#define SIGCOMP_INSTR_SORT_ASCENDING            11
#define SIGCOMP_INSTR_SORT_DESCENDING           12
#define SIGCOMP_INSTR_SHA_1                     13
#define SIGCOMP_INSTR_LOAD                      14
#define SIGCOMP_INSTR_MULTILOAD                 15
#define SIGCOMP_INSTR_PUSH                      16
#define SIGCOMP_INSTR_POP                       17
#define SIGCOMP_INSTR_COPY                      18
#define SIGCOMP_INSTR_COPY_LITERAL              19
#define SIGCOMP_INSTR_COPY_OFFSET               20
#define SIGCOMP_INSTR_MEMSET                    21
#define SIGCOMP_INSTR_JUMP                      22
#define SIGCOMP_INSTR_COMPARE                   23
#define SIGCOMP_INSTR_CALL                      24
#define SIGCOMP_INSTR_RETURN                    25
#define SIGCOMP_INSTR_SWITCH                    26
#define SIGCOMP_INSTR_CRC                       27
#define SIGCOMP_INSTR_INPUT_BYTES               28
#define SIGCOMP_INSTR_INPUT_BITS                29
#define SIGCOMP_INSTR_INPUT_HUFFMAN             30
#define SIGCOMP_INSTR_STATE_ACCESS              31
#define SIGCOMP_INSTR_STATE_CREATE              32
#define SIGCOMP_INSTR_STATE_FREE                33
#define SIGCOMP_INSTR_OUTPUT                    34
#define SIGCOMP_INSTR_END_MESSAGE               35


static gboolean print_level_1;
static gboolean print_level_2;
static gboolean print_level_3;

/* Internal result code values of decompression failures */
const value_string result_code_vals[] = {
      { 0,  "No decomprssion failure" },
      { 1,  "Partial state length less than 6 or greater than 20 bytes long" },
      { 2,  "No state match" },
      { 3,  "state_begin + state_length > size of state" },
      { 4,  "Operand_2 is Zero" },
      { 5,  "Switch statement failed j >= n" },
      { 6,  "Atempt to jump outside of UDVM memory" },
      { 7,  "L in input-bits > 16" },
      { 8,  "input_bit_order > 7" },
      { 9,  "Instruction Decompression failure encounterd" },
      {10,  "Input huffman failed j > n" },
      {11,  "Input bits requested beond end of message" },
      {12,  "more than four state creation requests are made before the END-MESSAGE instruction" },
      {13,  "state_retention_priority is 65535" },
      {14,  "Input bytes requested beond end of message" },
      {15,  "Maximum number of UDVM cycles reached" },
      { 255,      "This branch isn't coded yet" },
      { 0,    NULL }
};

static int decode_udvm_literal_operand(guint8 *buff,guint operand_address, guint16 *value);
static int dissect_udvm_reference_operand(guint8 *buff,guint operand_address, guint16 *value, guint *result_dest);
static int decode_udvm_multitype_operand(guint8 *buff,guint operand_address,guint16 *value);
static int decode_udvm_address_operand(guint8 *buff,guint operand_address, guint16 *value,guint current_address);
static int decomp_dispatch_get_bits(tvbuff_t *message_tvb,proto_tree *udvm_tree,guint8 bit_order, 
                  guint8 *buff,guint16 *old_input_bit_order, guint16 *remaining_bits,
                  guint16     *input_bits, guint *input_address, guint16 length, guint16 *result_code,guint msg_end);


tvbuff_t*
decompress_sigcomp_message(tvbuff_t *bytecode_tvb, tvbuff_t *message_tvb, packet_info *pinfo,
                                       proto_tree *udvm_tree, gint udvm_mem_dest, gint print_flags, gint hf_id)
{
      tvbuff_t    *decomp_tvb;
      guint8            buff[UDVM_MEMORY_SIZE];
      char        string[2],*strp;
      guint8            *out_buff;        /* Largest allowed size for a message is 65535  */
      guint32           i = 0;
      guint16           n = 0;
      guint16           m = 0;
      guint16           x;
      guint       k = 0;
      guint16           H;
      guint16           oldH;
      guint       offset = 0;
      guint       result_dest;
      guint       code_length =0;
      guint8            current_instruction;
      guint       current_address;
      guint       operand_address;
      guint       input_address;
      guint16           output_address = 0;
      guint       next_operand_address;
      guint8            octet;
      guint8            msb;
      guint8            lsb;
      guint16           byte_copy_right;
      guint16           byte_copy_left;
      guint16           input_bit_order;
      guint16           result;
      guint             msg_end = tvb_reported_length_remaining(message_tvb, 0);
      guint16           result_code;
      guint16           old_input_bit_order = 0;
      guint16           remaining_bits = 0;
      guint16           input_bits = 0;
      guint8            bit_order = 0;
      gboolean    outside_huffman_boundaries = TRUE;
      gboolean    print_in_loop = FALSE;
      guint16           instruction_address;
      guint8            no_of_state_create = 0;
      guint16           state_length_buff[5];
      guint16           state_address_buff[5];
      guint16           state_instruction_buff[5];
      guint16           state_minimum_access_length_buff[5];
      guint16           state_state_retention_priority_buff[5];
      guint32           used_udvm_cycles = 0;
      guint       cycles_per_bit;
      guint       maximum_UDVM_cycles;
      guint8            *sha1buff;
      unsigned char sha1_digest_buf[20];
      sha1_context ctx;


      /* UDVM operand variables */
      guint16 length;
      guint16 at_address;
      guint16 destination;
      guint16 address;
      guint16 value;
      guint16 p_id_start;
      guint16 p_id_length;
      guint16 state_begin;
      guint16 state_length;
      guint16 state_address;
      guint16 state_instruction;
      guint16 operand_1;
      guint16 operand_2;
      guint16 value_1;
      guint16 value_2;
      guint16 at_address_1;
      guint16 at_address_2;
      guint16 at_address_3;
      guint16 j;
      guint16 bits_n;
      guint16 lower_bound_n;
      guint16 upper_bound_n;
      guint16 uncompressed_n;
      guint16 position;
      guint16 ref_destination; /* could I have used $destination ? */
      guint16 multy_offset;
      guint16 output_start;
      guint16 output_length;
      guint16 minimum_access_length;
      guint16 state_retention_priority;
      guint16 requested_feedback_location;
      guint16 returned_parameters_location;
      guint16 start_value;

      /* Set print parameters */
      print_level_1 = FALSE;
      print_level_2 = FALSE;
      print_level_3 = FALSE;


      switch( print_flags ) {
            case 0:
                  break;

            case 1:
                  print_level_1 = TRUE;
                  break;
            case 2:
                  print_level_1 = TRUE;
                  print_level_2 = TRUE;
                  break;
            case 3:
                  print_level_1 = TRUE;
                  print_level_2 = TRUE;
                  print_level_3 = TRUE;
                  break;
            default:
                  print_level_1 = TRUE;
                  break;
      }






      /* UDVM memory must be initialised to zero */
      while ( i < UDVM_MEMORY_SIZE ) {
            buff[i] = 0;
            i++;
      }
      /* Set initial UDVM data 
       *  The first 32 bytes of UDVM memory are then initialized to special
       *  values as illustrated in Figure 5.
       *
       *                      0             7 8            15
       *                     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       *                     |       UDVM_memory_size        |  0 - 1
       *                     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       *                     |        cycles_per_bit         |  2 - 3
       *                     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       *                     |        SigComp_version        |  4 - 5
       *                     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       *                     |    partial_state_ID_length    |  6 - 7
       *                     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       *                     |         state_length          |  8 - 9
       *                     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       *                     |                               |
       *                     :           reserved            :  10 - 31
       *                     |                               |
       *                     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       *
       *            Figure 5: Initializing Useful Values in UDVM memory
       */
      /* UDVM_memory_size  */
      buff[0] = 0;
      buff[1] = 0;
      /* cycles_per_bit */
      buff[2] = 0;
      buff[3] = 16;
      /* SigComp_version */
      buff[4] = 0;
      buff[5] = 1;
      /* partial_state_ID_length */
      buff[6] = 0;
      buff[7] = 0;
      /* state_length  */
      buff[8] = 0;
      buff[9] = 0;
      code_length = tvb_reported_length_remaining(bytecode_tvb, 0);

      cycles_per_bit = buff[2] << 8;
      cycles_per_bit = cycles_per_bit | buff[3];
      /* 
       * maximum_UDVM_cycles = (8 * n + 1000) * cycles_per_bit
       */
      maximum_UDVM_cycles = (( 8 * msg_end ) + 1000) * cycles_per_bit;

      proto_tree_add_text(udvm_tree, bytecode_tvb, offset, 1,"maximum_UDVM_cycles(%u) = (( 8 * msg_end(%u) ) + 1000) * cycles_per_bit(%u)",maximum_UDVM_cycles,msg_end,cycles_per_bit);
      proto_tree_add_text(udvm_tree, bytecode_tvb, offset, 1,"Message Length: %u,Byte code length: %u, Maximum UDVM cycles: %u",msg_end,code_length,maximum_UDVM_cycles);

      /* Load bytecode into UDVM starting at "udvm_mem_dest" */
      i = udvm_mem_dest;
      if ( print_level_3 )
            proto_tree_add_text(udvm_tree, bytecode_tvb, offset, 1,"Load bytecode into UDVM starting at %u",i);
      while ( code_length > offset ) {
            buff[i] = tvb_get_guint8(bytecode_tvb, offset);
            if ( print_level_3 )
                  proto_tree_add_text(udvm_tree, bytecode_tvb, offset, 1,
                                    "              Addr: %u Instruction code(0x%0x) ", i, buff[i]);

            i++;
            offset++;

      }
      /* Largest allowed size for a message is 65535  */
      out_buff = g_malloc(65535);
      /* Start executing code */
      current_address = udvm_mem_dest;
      input_address = 0;
      operand_address = 0;
      
      proto_tree_add_text(udvm_tree, bytecode_tvb, offset, 1,"UDVM EXECUTION STARTED at Address: %u Message size %u",
            udvm_mem_dest,msg_end);

execute_next_instruction:

      if ( used_udvm_cycles > maximum_UDVM_cycles ){
            result_code = 15;
            goto decompression_failure;
      }
      current_instruction = buff[current_address];

      switch ( current_instruction ) {
      case SIGCOMP_INSTR_DECOMPRESSION_FAILURE:
            used_udvm_cycles++;
            if ( result_code == 0 )
                  result_code = 9;
            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                  "Addr: %u ## DECOMPRESSION-FAILURE(0)",
                  current_address);
            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Ethereal UDVM diagnostic: %s.",
                            val_to_str(result_code, result_code_vals,"Unknown (%u)"));
            if ( output_address > 0 ){
                  /* At least something got decompressed, show it */
                  decomp_tvb = tvb_new_real_data(out_buff,output_address,output_address);
                  /* Arrange that the allocated packet data copy be freed when the
                   * tvbuff is freed. 
                   */
                  tvb_set_free_cb( decomp_tvb, g_free );
                  /* Add the tvbuff to the list of tvbuffs to which the tvbuff we
                   * were handed refers, so it'll get cleaned up when that tvbuff
                   * is cleaned up. 
                   */
                  tvb_set_child_real_data_tvbuff(message_tvb,decomp_tvb);
                  add_new_data_source(pinfo, decomp_tvb, "Decompressed SigComp message(Incomplete)");
                  proto_tree_add_text(udvm_tree, decomp_tvb, 0, -1,"SigComp message Decompression failure");
            return decomp_tvb;
            }
            g_free(out_buff);
            return NULL;
            break;

      case SIGCOMP_INSTR_AND: /* 1 AND ($operand_1, %operand_2) */
            used_udvm_cycles++;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## AND(1) (operand_1, operand_2)",
                        current_address);
            }
            /* $operand_1*/
            operand_address = current_address + 1;
            next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &operand_1, &result_dest);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
                        operand_address, operand_1);
            }
            operand_address = next_operand_address; 
            /* %operand_2*/
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
                        operand_address, operand_2);
            }
            /* execute the instruction */
            result = operand_1 & operand_2;
            lsb = result & 0xff;
            msb = result >> 8;            
            buff[result_dest] = msb;
            buff[result_dest+1] = lsb;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
                        result, result_dest);
            }
            current_address = next_operand_address; 
            goto execute_next_instruction;

            break;

      case SIGCOMP_INSTR_OR: /* 2 OR ($operand_1, %operand_2) */
            used_udvm_cycles++;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## OR(2) (operand_1, operand_2)",
                        current_address);
            }
            /* $operand_1*/
            operand_address = current_address + 1;
            next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &operand_1, &result_dest);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
                        operand_address, operand_1);
            }
            operand_address = next_operand_address; 
            /* %operand_2*/
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
                        operand_address, operand_2);
            }
            /* execute the instruction */
            result = operand_1 | operand_2;
            lsb = result & 0xff;
            msb = result >> 8;            
            buff[result_dest] = msb;
            buff[result_dest+1] = lsb;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
                        result, result_dest);
            }
            current_address = next_operand_address; 
            goto execute_next_instruction;

            break;

      case SIGCOMP_INSTR_NOT: /* 3 NOT ($operand_1) */
            used_udvm_cycles++;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## NOT(3) ($operand_1)",
                        current_address);
            }
            /* $operand_1*/
            operand_address = current_address + 1;
            next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &operand_1, &result_dest);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
                        operand_address, operand_1);
            }
            /* execute the instruction */
            result = operand_1 ^ 0xffff;
            lsb = result & 0xff;
            msb = result >> 8;            
            buff[result_dest] = msb;
            buff[result_dest+1] = lsb;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
                        result, result_dest);
            }
            current_address = next_operand_address; 
            goto execute_next_instruction;
            break;

      case SIGCOMP_INSTR_LSHIFT: /* 4 LSHIFT ($operand_1, %operand_2) */
            used_udvm_cycles++;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## LSHIFT(4) ($operand_1, operand_2)",
                        current_address);
            }
            /* $operand_1*/
            operand_address = current_address + 1;
            next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &operand_1, &result_dest);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
                        operand_address, operand_1);
            }
            operand_address = next_operand_address; 
            /* %operand_2*/
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
                        operand_address, operand_2);
            }
            /* execute the instruction */
            result = operand_1 << operand_2;
            lsb = result & 0xff;
            msb = result >> 8;            
            buff[result_dest] = msb;
            buff[result_dest+1] = lsb;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
                        result, result_dest);
            }
            current_address = next_operand_address; 
            goto execute_next_instruction;

            break;
            case SIGCOMP_INSTR_RSHIFT: /* 5 RSHIFT ($operand_1, %operand_2) */
            used_udvm_cycles++;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## RSHIFT(5) (operand_1, operand_2)",
                        current_address);
            }
            /* $operand_1*/
            operand_address = current_address + 1;
            next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &operand_1, &result_dest);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
                        operand_address, operand_1);
            }
            operand_address = next_operand_address; 
            /* %operand_2*/
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
                        operand_address, operand_2);
            }
            /* execute the instruction */
            result = operand_1 >> operand_2;
            lsb = result & 0xff;
            msb = result >> 8;            
            buff[result_dest] = msb;
            buff[result_dest+1] = lsb;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
                        result, result_dest);
            }
            current_address = next_operand_address; 
            goto execute_next_instruction;
            break;
            case SIGCOMP_INSTR_ADD: /* 6 ADD ($operand_1, %operand_2) */
            used_udvm_cycles++;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## ADD(6) (operand_1, operand_2)",
                        current_address);
            }
            /* $operand_1*/
            operand_address = current_address + 1;
            next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &operand_1, &result_dest);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
                        operand_address, operand_1);
            }
            operand_address = next_operand_address; 
            /* %operand_2*/
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
                        operand_address, operand_2);
            }
            /* execute the instruction */
            result = operand_1 + operand_2;
            lsb = result & 0xff;
            msb = result >> 8;            
            buff[result_dest] = msb;
            buff[result_dest+1] = lsb;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"               Loading result %u at %u",
                        result, result_dest);
            }
            current_address = next_operand_address; 
            goto execute_next_instruction;

            case SIGCOMP_INSTR_SUBTRACT: /* 7 SUBTRACT ($operand_1, %operand_2) */
            used_udvm_cycles++;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## SUBTRACT(7) (operand_1, operand_2)",
                        current_address);
            }
            /* $operand_1*/
            operand_address = current_address + 1;
            next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &operand_1, &result_dest);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
                        operand_address, operand_1);
            }
            operand_address = next_operand_address; 
            /* %operand_2*/
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
                        operand_address, operand_2);
            }
            /* execute the instruction */
            result = operand_1 - operand_2;
            lsb = result & 0xff;
            msb = result >> 8;            
            buff[result_dest] = msb;
            buff[result_dest+1] = lsb;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"               Loading result %u at %u",
                        result, result_dest);
            }
            current_address = next_operand_address; 
            goto execute_next_instruction;
            break;

      case SIGCOMP_INSTR_MULTIPLY: /* 8 MULTIPLY ($operand_1, %operand_2) */
            used_udvm_cycles++;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ##MULTIPLY(8) (operand_1, operand_2)",
                        current_address);
            }
            /* $operand_1*/
            operand_address = current_address + 1;
            next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &operand_1, &result_dest);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
                        operand_address, operand_1);
            }
            operand_address = next_operand_address; 
            /* %operand_2*/
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
                        operand_address, operand_2);
            }
            /* 
             * execute the instruction
             * MULTIPLY (m, n)  := m * n (modulo 2^16)
             */
            if ( operand_2 == 0){
                  result_code = 4;
                  goto decompression_failure;
            }
            result = operand_1 * operand_2;
            lsb = result & 0xff;
            msb = result >> 8;            
            buff[result_dest] = msb;
            buff[result_dest+1] = lsb;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
                        result, result_dest);
            }
            current_address = next_operand_address; 
            goto execute_next_instruction;
            break;

      case SIGCOMP_INSTR_DIVIDE: /* 9 DIVIDE ($operand_1, %operand_2) */
            used_udvm_cycles++;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## DIVIDE(9) (operand_1, operand_2)",
                        current_address);
            }
            /* $operand_1*/
            operand_address = current_address + 1;
            next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &operand_1, &result_dest);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
                        operand_address, operand_1);
            }
            operand_address = next_operand_address; 
            /* %operand_2*/
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
                        operand_address, operand_2);
            }
            /* 
             * execute the instruction
             * DIVIDE (m, n)    := floor(m / n)
             * Decompression failure occurs if a DIVIDE or REMAINDER instruction
             * encounters an operand_2 that is zero.
             */
            if ( operand_2 == 0){
                  result_code = 4;
                  goto decompression_failure;
            }
            result = (guint16)floor(operand_1/operand_2);
            lsb = result & 0xff;
            msb = result >> 8;            
            buff[result_dest] = msb;
            buff[result_dest+1] = lsb;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
                        result, result_dest);
            }
            current_address = next_operand_address; 
            goto execute_next_instruction;
            break;

      case SIGCOMP_INSTR_REMAINDER: /* 10 REMAINDER ($operand_1, %operand_2) */
            used_udvm_cycles++;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## REMAINDER(10) (operand_1, operand_2)",
                        current_address);
            }
            /* $operand_1*/
            operand_address = current_address + 1;
            next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &operand_1, &result_dest);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
                        operand_address, operand_1);
            }
            operand_address = next_operand_address; 
            /* %operand_2*/
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
                        operand_address, operand_2);
            }
            /* 
             * execute the instruction
             * REMAINDER (m, n) := m - n * floor(m / n)
             * Decompression failure occurs if a DIVIDE or REMAINDER instruction
             * encounters an operand_2 that is zero.
             */
            if ( operand_2 == 0){
                  result_code = 4;
                  goto decompression_failure;
            }
            result = operand_1 - operand_2 * (guint16)floor(operand_1/operand_2);
            lsb = result & 0xff;
            msb = result >> 8;            
            buff[result_dest] = msb;
            buff[result_dest+1] = lsb;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
                        result, result_dest);
            }
            current_address = next_operand_address; 
            goto execute_next_instruction;
            break;
      case SIGCOMP_INSTR_SORT_ASCENDING: /* 11 SORT-ASCENDING (%start, %n, %k) */
            /*
             *    used_udvm_cycles =  1 + k * (ceiling(log2(k)) + n)
             */
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## SORT-ASCENDING(11) (start, n, k))",
                        current_address);
            }
            operand_address = current_address + 1;
            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Execution of this instruction is NOT implemented");
            /*
             *    used_udvm_cycles =  1 + k * (ceiling(log2(k)) + n)
             */
            break;

      case SIGCOMP_INSTR_SORT_DESCENDING: /* 12 SORT-DESCENDING (%start, %n, %k) */
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## SORT-DESCENDING(12) (start, n, k))",
                        current_address);
            }
            operand_address = current_address + 1;
            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Execution of this instruction is NOT implemented");
            /*
             *    used_udvm_cycles =  1 + k * (ceiling(log2(k)) + n)
             */
            break;
      case SIGCOMP_INSTR_SHA_1: /* 13 SHA-1 (%position, %length, %destination) */
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## SHA-1(13) (position, length, destination)",
                        current_address);
            }
            operand_address = current_address + 1;
            /* %position */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &position);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      position %u",
                        operand_address, position);
            }
            operand_address = next_operand_address; 

            /* %length */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Length %u",
                        operand_address, length);
            }
            operand_address = next_operand_address;

            /* $destination */
            next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &ref_destination, &result_dest);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      $destination %u",
                        operand_address, ref_destination);
            }
            current_address = next_operand_address; 
            used_udvm_cycles = used_udvm_cycles + 1 + length;
            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Execution of this instruction is NOT implemented");
            break;

      case SIGCOMP_INSTR_LOAD: /* 14 LOAD (%address, %value) */
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## LOAD(14) (%%address, %%value)",
                        current_address);
            }
            operand_address = current_address + 1;
            /* %address */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &address);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Address %u",
                        operand_address, address);
            }
            operand_address = next_operand_address; 
            /* %value */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &value);
            lsb = value & 0xff;
            msb = value >> 8;

            buff[address] = msb;
            buff[address + 1] = lsb;

            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Value %u",
                        operand_address, value);
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading bytes at %u Value %u 0x%x",
                              address, value, value);
            }
            used_udvm_cycles++;
            current_address = next_operand_address;
            goto execute_next_instruction;
            break;

      case SIGCOMP_INSTR_MULTILOAD: /* 15 MULTILOAD (%address, #n, %value_0, ..., %value_n-1) */
            /* RFC 3320:
             * The MULTILOAD instruction sets a contiguous block of 2-byte words in
             * the UDVM memory to specified values.
             * Hmm what if the value to load only takes one byte ? Chose to always load two bytes.
             */
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## MULTILOAD(15) (%%address, #n, value_0, ..., value_n-1)",
                        current_address);
            }
            operand_address = current_address + 1;
            /* %address */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &address);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Address %u",
                        operand_address, address);
            }
            operand_address = next_operand_address; 

            /* #n */
            next_operand_address = decode_udvm_literal_operand(buff,operand_address, &n);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      n %u",
                        operand_address, n);
            }
            operand_address = next_operand_address; 
            used_udvm_cycles = used_udvm_cycles + 1 + n;
            while ( n > 0) {
                  n = n - 1;
                  /* %value */
                  next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &value);
                  lsb = value & 0xff;
                  msb = value >> 8;

                  buff[address] = msb;
                  buff[address + 1] = lsb;
                  /* debug
                  */
                  length = next_operand_address - operand_address;

                  if (print_level_1 ){
                        proto_tree_add_text(udvm_tree, bytecode_tvb, operand_address - 128, length,"Addr: %u      Value %5u      - Loading bytes at %5u Value %5u 0x%x",
                              operand_address, value, address, value, value);
                  }
                  address = address + 2;
                  operand_address = next_operand_address; 
            }
            current_address = next_operand_address;
            goto execute_next_instruction;

            break;
                   
      case SIGCOMP_INSTR_PUSH: /* 16 PUSH (%value) */
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## PUSH(16) (value)",
                        current_address);
            }
            operand_address = current_address + 1;
            /* %value */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &value);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Value %u",
                        operand_address, value);
            }
            used_udvm_cycles++;
            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Execution of this instruction is NOT implemented");
            break;

      case SIGCOMP_INSTR_POP: /* 17 POP (%address) */
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## POP(17) (address)",
                        current_address);
            }
            operand_address = current_address + 1;
            /* %address */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &address);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Address %u",
                        operand_address, address);
            }
            operand_address = next_operand_address; 
            used_udvm_cycles++;
            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Execution of this instruction is NOT implemented");
            break;

      case SIGCOMP_INSTR_COPY: /* 18 COPY (%position, %length, %destination) */
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## COPY(18) (position, length, destination)",
                        current_address);
            }
            operand_address = current_address + 1;
            /* %position */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &position);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      position %u",
                        operand_address, position);
            }
            operand_address = next_operand_address; 

            /* %length */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Length %u",
                        operand_address, length);
            }
            operand_address = next_operand_address;

            /* %destination */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &destination);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Destination %u",
                        operand_address, destination);
            }
            current_address = next_operand_address;
            /*
             * 8.4.  Byte copying
             * :
             * The string of bytes is copied in ascending order of memory address,
             * respecting the bounds set by byte_copy_left and byte_copy_right.
             * More precisely, if a byte is copied from/to Address m then the next
             * byte is copied from/to Address n where n is calculated as follows:
             *
             * Set k := m + 1 (modulo 2^16)
             * If k = byte_copy_right then set n := byte_copy_left, else set n := k
             *
             */ 

            n = 0;
            k = destination; 
            byte_copy_right = buff[66] << 8;
            byte_copy_right = byte_copy_right | buff[67];
            byte_copy_left = buff[64] << 8;
            byte_copy_left = byte_copy_left | buff[65];
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
                                    "               byte_copy_right = %u", byte_copy_right);
            }

            while ( n < length ){
                  if ( k == byte_copy_right ){
                        k = byte_copy_left;
                  }
                  buff[k] = buff[position + n];
                  if (print_level_1 ){
                        proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
                              "               Copying value: %u (0x%x) to Addr: %u", buff[position + n], buff[position + n], k);
                  }
                  k = ( k + 1 ) & 0xffff;
                  n++;
            }
            used_udvm_cycles = used_udvm_cycles + 1 + length;
            goto execute_next_instruction;
            break;

      case SIGCOMP_INSTR_COPY_LITERAL: /* 19 COPY-LITERAL (%position, %length, $destination) */
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## COPY-LITERAL(19) (position, length, $destination)",
                        current_address);
            }
            operand_address = current_address + 1;
            /* %position */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &position);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      position %u",
                        operand_address, address);
            }
            operand_address = next_operand_address; 

            /* %length */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Length %u",
                        operand_address, length);
            }
            operand_address = next_operand_address;


            /* $destination */
            next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &ref_destination, &result_dest);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      destination %u",
                        operand_address, ref_destination);
            }
            current_address = next_operand_address; 


            /*
             * 8.4.  Byte copying
             * :
             * The string of bytes is copied in ascending order of memory address,
             * respecting the bounds set by byte_copy_left and byte_copy_right.
             * More precisely, if a byte is copied from/to Address m then the next
             * byte is copied from/to Address n where n is calculated as follows:
             *
             * Set k := m + 1 (modulo 2^16)
             * If k = byte_copy_right then set n := byte_copy_left, else set n := k
             *
             */ 

            n = 0;
            k = ref_destination; 
            byte_copy_right = buff[66] << 8;
            byte_copy_right = byte_copy_right | buff[67];
            byte_copy_left = buff[64] << 8;
            byte_copy_left = byte_copy_left | buff[65];
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
                              "               byte_copy_right = %u", byte_copy_right);
            }
            while ( n < length ){

                  if ( k == byte_copy_right ){
                        k = byte_copy_left;
                  }
                  buff[k] = buff[position + n];
                  if (print_level_1 ){
                        proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
                              "               Copying value: %u (0x%x) to Addr: %u", buff[position + n], buff[position + n], k);
                  }
                  k = ( k + 1 ) & 0xffff;
                  n++;
            }
            buff[result_dest] = k >> 8;
            buff[result_dest + 1] = k & 0x00ff;

            used_udvm_cycles = used_udvm_cycles + 1 + length;
            goto execute_next_instruction;
            break;
 
      case SIGCOMP_INSTR_COPY_OFFSET: /* 20 COPY-OFFSET (%offset, %length, $destination) */
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## COPY-OFFSET(20) (offset, length, $destination)",
                        current_address);
            }
            operand_address = current_address + 1;
            /* %offset */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &multy_offset);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      offset %u",
                        operand_address, multy_offset);
            }
            operand_address = next_operand_address; 

            /* %length */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Length %u",
                        operand_address, length);
            }
            operand_address = next_operand_address;


            /* $destination */
            next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &ref_destination, &result_dest);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      $destination %u",
                        operand_address, ref_destination);
            }
            current_address = next_operand_address; 

            /* Execute the instruction:
             * To derive the value of the position operand, starting at the memory
             * address specified by destination, the UDVM counts backwards a total
             * of offset memory addresses.
             * 
             * If the memory address specified in byte_copy_left is reached, the
             * next memory address is taken to be (byte_copy_right - 1) modulo 2^16.
             */
            byte_copy_left = buff[64] << 8;
            byte_copy_left = byte_copy_left | buff[65];
            byte_copy_right = buff[66] << 8;
            byte_copy_right = byte_copy_right | buff[67];

            if ( (byte_copy_left + multy_offset) > ( ref_destination )){
                  /* wrap around */
                  position = byte_copy_right - ( multy_offset - ( ref_destination - byte_copy_left )); 
            }else{
                  position = ref_destination - multy_offset;
            }

            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
                              "               byte_copy_left = %u byte_copy_right = %u position= %u",
                              byte_copy_left, byte_copy_right, position);
                  }
            /* The COPY-OFFSET instruction then behaves as a COPY-LITERAL
             * instruction, taking the value of the position operand to be the last
             * memory address reached in the above step.
             */

            /*
             * 8.4.  Byte copying
             * :
             * The string of bytes is copied in ascending order of memory address,
             * respecting the bounds set by byte_copy_left and byte_copy_right.
             * More precisely, if a byte is copied from/to Address m then the next
             * byte is copied from/to Address n where n is calculated as follows:
             *
             * Set k := m + 1 (modulo 2^16)
             * If k = byte_copy_right then set n := byte_copy_left, else set n := k
             *
             */ 

            n = 0;
            k = ref_destination; 
            byte_copy_right = buff[66] << 8;
            byte_copy_right = byte_copy_right | buff[67];
            byte_copy_left = buff[64] << 8;
            byte_copy_left = byte_copy_left | buff[65];
            if (print_level_2 ){
                  proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
                              "               byte_copy_left = %u byte_copy_right = %u", byte_copy_left, byte_copy_right);
            }
            while ( n < length ){
                  if ( k == byte_copy_right ){
                        k = byte_copy_left;
                  }
                  if ( position == byte_copy_right ){
                        position = byte_copy_left;
                  }
                  buff[k] = buff[position];
                  if (print_level_1 ){
                        proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
                              "               Copying value: %5u (0x%x) from Addr: %u to Addr: %u",
                              buff[position + n], buff[position + n],(position + n), k);
                  }
                  k = ( k + 1 ) & 0xffff;
                  n++;
                  position++;
            }
            buff[result_dest] = k >> 8;
            buff[result_dest + 1] = k & 0x00ff;
            used_udvm_cycles = used_udvm_cycles + 1 + length;
            goto execute_next_instruction;

            break;
      case SIGCOMP_INSTR_MEMSET: /* 21 MEMSET (%address, %length, %start_value, %offset) */
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## MEMSET(21) (address, length, start_value, offset)",
                        current_address);
            }
            operand_address = current_address + 1;

            /* %address */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &address);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Address %u",
                        operand_address, address);
            }
            operand_address = next_operand_address; 

            /*  %length, */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Length %u",
                        operand_address, length);
            }
            operand_address = next_operand_address;
            /* %start_value */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &start_value);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      start_value %u",
                        operand_address, start_value);
            }
            operand_address = next_operand_address; 

            /* %offset */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &multy_offset);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      offset %u",
                        operand_address, multy_offset);
            }
            current_address = next_operand_address; 
            /* exetute the instruction
             * The sequence of values used by the MEMSET instruction is specified by
             * the following formula:
             * 
             * Seq[n] := (start_value + n * offset) modulo 256
             */
            n = 0;
            k = address; 
            byte_copy_right = buff[66] << 8;
            byte_copy_right = byte_copy_right | buff[67];
            byte_copy_left = buff[64] << 8;
            byte_copy_left = byte_copy_left | buff[65];
            if (print_level_2 ){
                  proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
                              "               byte_copy_left = %u byte_copy_right = %u", byte_copy_left, byte_copy_right);
            }
            while ( n < length ){
                  if ( k == byte_copy_right ){
                        k = byte_copy_left;
                  }
                  buff[k] = (start_value + ( n * multy_offset)) & 0xff;
                  if (print_level_2 ){
                        proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
                              "     Storing value: %u (0x%x) at Addr: %u",
                              buff[k], buff[k], k);
                  }
                  k = ( k + 1 ) & 0xffff;
                  n++;
            }/* end while */
            used_udvm_cycles = used_udvm_cycles + 1 + length;
            goto execute_next_instruction;
            break;


      case SIGCOMP_INSTR_JUMP: /* 22 JUMP (@address) */
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## JUMP(22) (@address)",
                        current_address);
            }
            operand_address = current_address + 1;
            /* @address */
             /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
            next_operand_address = decode_udvm_address_operand(buff,operand_address, &at_address, current_address);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
                        operand_address, at_address);
            }
            current_address = at_address;
            used_udvm_cycles++;
            goto execute_next_instruction;
            break;

      case SIGCOMP_INSTR_COMPARE: /* 23 */
            /* COMPARE (%value_1, %value_2, @address_1, @address_2, @address_3)
             */
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## COMPARE(23) (value_1, value_2, @address_1, @address_2, @address_3)",
                        current_address);
            }
            operand_address = current_address + 1;

            /* %value_1 */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &value_1);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Value %u",
                              operand_address, value_1);
            }
            operand_address = next_operand_address;

            /* %value_2 */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &value_2);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Value %u",
                              operand_address, value_2);
            }
            operand_address = next_operand_address;

            /* @address_1 */
             /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &at_address_1);
            at_address_1 = ( current_address + at_address_1) & 0xffff;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
                        operand_address, at_address_1);
            }
            operand_address = next_operand_address;


            /* @address_2 */
             /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &at_address_2);
            at_address_2 = ( current_address + at_address_2) & 0xffff;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
                        operand_address, at_address_2);
            }
            operand_address = next_operand_address;

            /* @address_3 */
             /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &at_address_3);
            at_address_3 = ( current_address + at_address_3) & 0xffff;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
                        operand_address, at_address_3);
            }
            /* execute the instruction
             * If value_1 < value_2 then the UDVM continues instruction execution at
             * the memory address specified by address 1. If value_1 = value_2 then
             * it jumps to the address specified by address_2. If value_1 > value_2
             * then it jumps to the address specified by address_3.
             */
            if ( value_1 < value_2 )
                  current_address = at_address_1;
            if ( value_1 == value_2 )
                  current_address = at_address_2;
            if ( value_1 > value_2 )
                  current_address = at_address_3;
            used_udvm_cycles++;
            goto execute_next_instruction;
            break;

      case SIGCOMP_INSTR_CALL: /* 24 CALL (@address) (PUSH addr )*/
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## CALL(24) (@address) (PUSH addr )",
                        current_address);
            }
            operand_address = current_address + 1;
            /* @address */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &at_address);
            at_address = ( current_address + at_address) & 0xffff;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
                        operand_address, at_address);
             /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
            }
            used_udvm_cycles++;
            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Execution of this instruction is NOT implemented");
            break;

      case SIGCOMP_INSTR_RETURN: /* 25 POP and return */
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## POP(25) and return",
                        current_address);
            }
            operand_address = current_address + 1;
            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Execution of this instruction is NOT implemented");
            used_udvm_cycles++;
            break;

      case SIGCOMP_INSTR_SWITCH: /* 26 SWITCH (#n, %j, @address_0, @address_1, ... , @address_n-1) */
            /*
             * When a SWITCH instruction is encountered the UDVM reads the value of
             * j. It then continues instruction execution at the address specified
             * by address j.
             * 
             * Decompression failure occurs if j specifies a value of n or more, or
             * if the address lies beyond the overall UDVM memory size.
             */
            instruction_address = current_address;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## SWITCH (#n, j, @address_0, @address_1, ... , @address_n-1))",
                        current_address);
            }
            operand_address = current_address + 1;
            /* #n 
             * Number of addresses in the instruction
             */
            next_operand_address = decode_udvm_literal_operand(buff,operand_address, &n);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      n %u",
                        operand_address, n);
            }
            operand_address = next_operand_address; 
            /* %j */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &j);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      j %u",
                              operand_address, j);
            }
            operand_address = next_operand_address;
            m = 0;
            while ( m < n ){
                  /* @address_n-1 */
                  /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
                  next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &at_address_1);
                  at_address_1 = ( instruction_address + at_address_1) & 0xffff;
                  if (print_level_1 ){
                        proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
                              operand_address, at_address_1);
                  }
                  if ( j == m ){
                        current_address = at_address_1;
                  }
                  operand_address = next_operand_address;
                  m++;
            }
            /* Check decompression failure */
            if ( ( j == n ) || ( j > n )){
                  result_code = 5;
                  goto decompression_failure;
            }
            if ( current_address > UDVM_MEMORY_SIZE ){
                  result_code = 6;
                  goto decompression_failure;
            }
            used_udvm_cycles = used_udvm_cycles + 1 + n;
;
            goto execute_next_instruction;

            break;
      case SIGCOMP_INSTR_CRC: /* 27 CRC (%value, %position, %length, @address) */
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## CRC (value, position, length, @address)",
                        current_address);
            }
            /* %value */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &value);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Value %u",
                        operand_address, value);
            }
            /* %position */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &position);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      position %u",
                        operand_address, position);
            }
            operand_address = next_operand_address; 

            /* %length */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Length %u",
                        operand_address, length);
            }
            operand_address = next_operand_address;

            /* @address */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &at_address);
            at_address = ( current_address + at_address) & 0xffff;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
                        operand_address, at_address);
            }
             /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
            used_udvm_cycles = used_udvm_cycles + 1 + length;

            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Execution of this instruction is NOT implemented");
            break;


      case SIGCOMP_INSTR_INPUT_BYTES: /* 28 INPUT-BYTES (%length, %destination, @address) */
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u ## INPUT-BYTES(28) length, destination, @address)",
                        current_address);
            }
            operand_address = current_address + 1;
            /* %length */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Length %u",
                        operand_address, length);
            }
            operand_address = next_operand_address;

            /* %destination */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &destination);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Destination %u",
                        operand_address, destination);
            }
            operand_address = next_operand_address;

            /* @address */
             /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &at_address);
            at_address = ( current_address + at_address) & 0xffff;
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
                        operand_address, at_address);
            }
            /* execute the instruction TODO insert checks 
             * RFC 3320 :
             *
         *    0             7 8            15
         *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
         *   |        byte_copy_left         |  64 - 65
         *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
         *   |        byte_copy_right        |  66 - 67
         *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
         *   |        input_bit_order        |  68 - 69
         *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
         *   |        stack_location         |  70 - 71
         *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
             * 
             * Figure 7: Memory addresses of the UDVM registers
             * :
             * 8.4.  Byte copying
             * :
             * The string of bytes is copied in ascending order of memory address,
             * respecting the bounds set by byte_copy_left and byte_copy_right.
             * More precisely, if a byte is copied from/to Address m then the next
             * byte is copied from/to Address n where n is calculated as follows:
             *
             * Set k := m + 1 (modulo 2^16)
             * If k = byte_copy_right then set n := byte_copy_left, else set n := k
             *
             */ 

            n = 0;
            k = destination; 
            byte_copy_right = buff[66] << 8;
            byte_copy_right = byte_copy_right | buff[67];
            byte_copy_left = buff[64] << 8;
            byte_copy_left = byte_copy_left | buff[65];
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
                              "               byte_copy_right = %u", byte_copy_right);
            }
            /* clear out remaining bits if any */
            remaining_bits = 0;
            input_bits=0;
            /* operand_address used as dummy */
            while ( n < length ){
                  if (input_address > ( msg_end - 1)){
                        current_address = at_address;
                        result_code = 14;
                        goto execute_next_instruction;
                  }

                  if ( k == byte_copy_right ){
                        k = byte_copy_left;
                  }
                  octet = tvb_get_guint8(message_tvb, input_address);
                  buff[k] = octet;
                  if (print_level_1 ){
                        proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
                              "               Loading value: %u (0x%x) at Addr: %u", octet, octet, k);
                  }
                  input_address++;
                  /*
                   * If the instruction requests data that lies beyond the end of the
                   * SigComp message, no data is returned.  Instead the UDVM moves program
                   * execution to the address specified by the address operand.
                   */

                  
                  k = ( k + 1 ) & 0xffff;
                  n++;
            }
            used_udvm_cycles = used_udvm_cycles + 1 + length;
            current_address = next_operand_address;
            goto execute_next_instruction;
            break;
      case SIGCOMP_INSTR_INPUT_BITS:/* 29   INPUT-BITS (%length, %destination, @address) */
            /*
             * The length operand indicates the requested number of bits.
             * Decompression failure occurs if this operand does not lie between 0
             * and 16 inclusive.
             * 
             * The destination operand specifies the memory address to which the
             * compressed data should be copied.  Note that the requested bits are
             * interpreted as a 2-byte integer ranging from 0 to 2^length - 1, as
             * explained in Section 8.2.
             *
             * If the instruction requests data that lies beyond the end of the
             * SigComp message, no data is returned.  Instead the UDVM moves program
             * execution to the address specified by the address operand.
             */

            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## INPUT-BITS(29) (length, destination, @address)",
                        current_address);
            }
            operand_address = current_address + 1;

            /* %length */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      length %u",
                        operand_address, length);
            }
            operand_address = next_operand_address;
            /* %destination */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &destination);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Destination %u",
                        operand_address, destination);
            }
            operand_address = next_operand_address;

            /* @address */
             /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
            next_operand_address = decode_udvm_address_operand(buff,operand_address, &at_address, current_address);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
                        operand_address, at_address);
            }
            current_address = next_operand_address;

            /*
             * Execute actual instr.
             * The input_bit_order register contains the following three flags:
             * 
             *            0             7 8            15
             *           +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
             *           |         reserved        |F|H|P|  68 - 69
             *           +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
             */
            input_bit_order = buff[68] << 8;
            input_bit_order = input_bit_order | buff[69];
            /*
             * If the instruction requests data that lies beyond the end of the
             * SigComp message, no data is returned.  Instead the UDVM moves program
             * execution to the address specified by the address operand.
             */
            if ((input_address > ( msg_end -1)) && (remaining_bits == 0 )){
                  result_code = 11;
                  current_address = at_address;
                  goto execute_next_instruction;
            }

            if ( length > 16 ){
                  result_code = 7;
                  goto decompression_failure;
            }
            if ( input_bit_order > 7 ){
                  result_code = 8;
                  goto decompression_failure;
            }
            if ( length > 0 ){
                  /* If lengt = 0 ignore the instruction - derived from torture test 12
                   * Transfer F bit to bit_order to tell decomp dispatcher which bit order to use 
                   */
                  bit_order = ( input_bit_order & 0x0004 ) >> 2;
                  value = decomp_dispatch_get_bits( message_tvb, udvm_tree, bit_order, 
                              buff, &old_input_bit_order, &remaining_bits,
                              &input_bits, &input_address, length, &result_code, msg_end);
                  if ( result_code == 11 ){
                        current_address = at_address;
                        goto execute_next_instruction;
                  }
                  msb = value >> 8;
                  lsb = value & 0x00ff;
                  buff[destination] = msb;
                  buff[destination + 1]=lsb;
                  if (print_level_1 ){
                        proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
                        "               Loading value: %u (0x%x) at Addr: %u, remaining_bits: %u", value, value, destination, remaining_bits);
                  }
            }

            used_udvm_cycles = used_udvm_cycles + 1 + length;
            goto execute_next_instruction;
            break;
      case SIGCOMP_INSTR_INPUT_HUFFMAN: /* 30 */
            /*
             * INPUT-HUFFMAN (%destination, @address, #n, %bits_1, %lower_bound_1,
             *  %upper_bound_1, %uncompressed_1, ... , %bits_n, %lower_bound_n,
             *  %upper_bound_n, %uncompressed_n)
             */
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## INPUT-HUFFMAN (destination, @address, #n, bits_1, lower_bound_1,upper_bound_1, uncompressed_1, ... , bits_n, lower_bound_n,upper_bound_n, uncompressed_n)",
                        current_address);
            }
            operand_address = current_address + 1;

            /* %destination */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &destination);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Destination %u",
                        operand_address, destination);
            }
            operand_address = next_operand_address;

            /* @address */
             /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
            next_operand_address = decode_udvm_address_operand(buff,operand_address, &at_address, current_address);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
                        operand_address, at_address);
            }
            operand_address = next_operand_address;

            /* #n */
            next_operand_address = decode_udvm_literal_operand(buff,operand_address, &n);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      n %u",
                        operand_address, n);
            }
            operand_address = next_operand_address; 
            /*
             * Note that if n = 0 then the INPUT-HUFFMAN instruction is ignored and
             * program execution resumes at the following instruction.
             * Decompression failure occurs if (bits_1 + ... + bits_n) > 16.
             * 
             * In all other cases, the behavior of the INPUT-HUFFMAN instruction is
             * defined below:
             * 
             * 1. Set j := 1 and set H := 0.
             * 
             * 2. Request bits_j compressed bits.  Interpret the returned bits as an
             * integer k from 0 to 2^bits_j - 1, as explained in Section 8.2.
             * 
             * 3. Set H := H * 2^bits_j + k.
             * 
             * 4. If data is requested that lies beyond the end of the SigComp
             * message, terminate the INPUT-HUFFMAN instruction and move program
             * execution to the memory address specified by the address operand.
             * 
             * 5. If (H < lower_bound_j) or (H > upper_bound_j) then set j := j + 1.
             * Then go back to Step 2, unless j > n in which case decompression
             * failure occurs.
             * 
             * 6. Copy (H + uncompressed_j - lower_bound_j) modulo 2^16 to the
             * memory address specified by the destination operand.
             * 
             */
            /*
             * The input_bit_order register contains the following three flags:
             * 
             *            0             7 8            15
             *           +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
             *           |         reserved        |F|H|P|  68 - 69
             *           +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
             *
             * Transfer H bit to bit_order to tell decomp dispatcher which bit order to use 
             */
            input_bit_order = buff[68] << 8;
            input_bit_order = input_bit_order | buff[69];
            bit_order = ( input_bit_order & 0x0002 ) >> 1;

            j = 1;
            H = 0;
            m = n;
            outside_huffman_boundaries = TRUE;
            print_in_loop = print_level_1;
            while ( m > 0 ){
                  /* %bits_n */
                  next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &bits_n);
                  if (print_in_loop ){
                        proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      bits_n %u",
                              operand_address, bits_n);
                  }
                  operand_address = next_operand_address; 

                  /* %lower_bound_n */
                  next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &lower_bound_n);
                  if (print_in_loop ){
                        proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      lower_bound_n %u",
                              operand_address, lower_bound_n);
                  }
                  operand_address = next_operand_address; 
                  /* %upper_bound_n */
                  next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &upper_bound_n);
                  if (print_in_loop ){
                        proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      upper_bound_n %u",
                              operand_address, upper_bound_n);
                  }
                  operand_address = next_operand_address; 
                  /* %uncompressed_n */
                  next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &uncompressed_n);
                  if (print_in_loop ){
                        proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      uncompressed_n %u",
                              operand_address, uncompressed_n);
                  }
                  operand_address = next_operand_address;
                  /* execute instruction */
                  if ( outside_huffman_boundaries ) {
                        /*
                         * 3. Set H := H * 2^bits_j + k.
                         */
                        k = decomp_dispatch_get_bits( message_tvb, udvm_tree, bit_order, 
                                    buff, &old_input_bit_order, &remaining_bits,
                                    &input_bits, &input_address, bits_n, &result_code, msg_end);
                        if ( result_code == 11 ){
                              current_address = at_address;
                              goto execute_next_instruction;
                        }
                        /* ldexp Returns x multiplied by 2 raised to the power of exponent.
                         * x*2^exponent
                         */
                        oldH = H;
                        H = ( (guint16)ldexp( H, bits_n) + k );
                        if (print_level_3 ){
                              proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"               Set H(%u) := H(%u) * 2^bits_j(%u) + k(%u)",
                                     H ,oldH,((guint16)pow(2,bits_n)),k);
                        }

                        /*
                         * 4. If data is requested that lies beyond the end of the SigComp
                         * message, terminate the INPUT-HUFFMAN instruction and move program
                         * execution to the memory address specified by the address operand.
                         */
                        if ( input_address > msg_end ){
                              current_address = at_address;
                              goto execute_next_instruction;
                        }
                        /*
                         * 5. If (H < lower_bound_j) or (H > upper_bound_j) then set j := j + 1.
                         * Then go back to Step 2, unless j > n in which case decompression
                         * failure occurs.
                         */
                        if ((H < lower_bound_n) || (H > upper_bound_n)){
                              outside_huffman_boundaries = TRUE;
                        }else{
                              outside_huffman_boundaries = FALSE;
                              print_in_loop = FALSE;
                              /*
                               * 6. Copy (H + uncompressed_j - lower_bound_j) modulo 2^16 to the
                               * memory address specified by the destination operand.
                               */
                              if (print_level_2 ){
                                    proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                                          "               H(%u) = H(%u) + uncompressed_n(%u) - lower_bound_n(%u)",
                                    (H + uncompressed_n - lower_bound_n ),H, uncompressed_n, lower_bound_n);
                              }
                              H = H + uncompressed_n - lower_bound_n;
                              msb = H >> 8;
                              lsb = H & 0x00ff;
                              buff[destination] = msb;
                              buff[destination + 1]=lsb;
                              if (print_level_1 ){
                                    proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
                              "               Loading H: %u (0x%x) at Addr: %u,j = %u remaining_bits: %u", 
                                    H, H, destination,( n - m + 1 ), remaining_bits);
                              }
                              
                        }


                  }
                  m = m - 1;
            }
            if ( outside_huffman_boundaries ) {
                  result_code = 10;
                  goto decompression_failure;
            }

            current_address = next_operand_address;
            used_udvm_cycles = used_udvm_cycles + 1 + n;
            goto execute_next_instruction;
            break;

      case SIGCOMP_INSTR_STATE_ACCESS: /* 31 */
            /*   STATE-ACCESS (%partial_identifier_start, %partial_identifier_length,
             * %state_begin, %state_length, %state_address, %state_instruction)
             */
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## STATE-ACCESS(31) (partial_identifier_start, partial_identifier_length,state_begin, state_length, state_address, state_instruction)",
                        current_address);
            }
            operand_address = current_address + 1;

            /* 
             * %partial_identifier_start
             */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &p_id_start);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       partial_identifier_start %u",
                        operand_address, p_id_start);
            }
            operand_address = next_operand_address;

            /*
             * %partial_identifier_length
             */
            operand_address = next_operand_address;
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &p_id_length);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       partial_identifier_length %u",
                        operand_address, p_id_length);
            }
            /*
             * %state_begin
             */
            operand_address = next_operand_address;
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_begin);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_begin %u",
                        operand_address, state_begin);
            }
            /*
             * %state_length
             */
            operand_address = next_operand_address;
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_length);           if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_length %u",
                        operand_address, state_length);
            }
            /*
             * %state_address
             */
            operand_address = next_operand_address;
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_address);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_address %u",
                        operand_address, state_address);
            }
            /*
             * %state_instruction
             */
            operand_address = next_operand_address;
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_instruction);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_instruction %u",
                        operand_address, state_instruction);
            }
            current_address = next_operand_address;
            byte_copy_right = buff[66] << 8;
            byte_copy_right = byte_copy_right | buff[67];
            byte_copy_left = buff[64] << 8;
            byte_copy_left = byte_copy_left | buff[65];
            if (print_level_2 ){
                  proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
                              "               byte_copy_right = %u, byte_copy_left = %u", byte_copy_right,byte_copy_left);
            }

            result_code = udvm_state_access(message_tvb, udvm_tree, buff, p_id_start, p_id_length, state_begin, &state_length, 
                  &state_address, state_instruction, TRUE, hf_id);
            if ( result_code != 0 ){
                  goto decompression_failure; 
            }
            used_udvm_cycles = used_udvm_cycles + 1 + state_length;
            goto execute_next_instruction;
            break;
      case SIGCOMP_INSTR_STATE_CREATE: /* 32 */
            /*
             * STATE-CREATE (%state_length, %state_address, %state_instruction,
             * %minimum_access_length, %state_retention_priority)
             */
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## STATE-CREATE(32) (state_length, state_address, state_instruction,minimum_access_length, state_retention_priority)",
                        current_address);
            }
            operand_address = current_address + 1;

            /*
             * %state_length
             */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_length);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_length %u",
                        operand_address, state_length);
            }
            /*
             * %state_address
             */
            operand_address = next_operand_address;
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_address);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_address %u",
                        operand_address, state_address);
            }
            /*
             * %state_instruction
             */
            operand_address = next_operand_address;
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_instruction);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_instruction %u",
                        operand_address, state_instruction);
            }
            operand_address = next_operand_address;
            /*
             * %minimum_access_length
             */
            operand_address = next_operand_address;
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &minimum_access_length);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       minimum_access_length %u",
                        operand_address, minimum_access_length);
            }
            operand_address = next_operand_address;
            /*
             * %state_retention_priority
             */
            operand_address = next_operand_address;
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_retention_priority);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_retention_priority %u",
                        operand_address, state_retention_priority);
            }
            current_address = next_operand_address;
            /* Execute the instruction
             * TODO Implement the instruction
             * RFC3320:
             *    Note that the new state item cannot be created until a valid
             *    compartment identifier has been returned by the application.
             *    Consequently, when a STATE-CREATE instruction is encountered the UDVM
             *    simply buffers the five supplied operands until the END-MESSAGE
             *    instruction is reached.  The steps taken at this point are described
             *    in Section 9.4.9.
             *
             *   Decompression failure MUST occur if more than four state creation
             *   requests are made before the END-MESSAGE instruction is encountered.
             *   Decompression failure also occurs if the minimum_access_length does
             *   not lie between 6 and 20 inclusive, or if the
             *   state_retention_priority is 65535.
             */
            no_of_state_create++;
            if ( no_of_state_create > 4 ){
                  result_code = 12;
                  goto decompression_failure; 
            }
            if (( minimum_access_length < 6 ) || ( minimum_access_length > 20 )){
                  result_code = 1;
                  goto decompression_failure; 
            }
            if ( state_retention_priority == 65535 ){
                  result_code = 13;
                  goto decompression_failure; 
            }
            state_length_buff[no_of_state_create] = state_length;
            state_address_buff[no_of_state_create] = state_address;
            state_instruction_buff[no_of_state_create] = state_instruction;
            state_minimum_access_length_buff[no_of_state_create] = minimum_access_length;
            state_state_retention_priority_buff[no_of_state_create] = state_retention_priority;
            used_udvm_cycles = used_udvm_cycles + 1 + state_length;
            /* Debug */
            byte_copy_right = buff[66] << 8;
            byte_copy_right = byte_copy_right | buff[67];
            byte_copy_left = buff[64] << 8;
            byte_copy_left = byte_copy_left | buff[65];
            n = 0;
            k = state_address;
            while ( n < state_length ){
                  if ( k == byte_copy_right ){
                        k = byte_copy_left;
                  }
                  string[0]= buff[k];
                  string[1]= '\0';
                  if (print_level_3 ){
                        proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                              "               Addr: %5u State value: %u (0x%x) ASCII(%s)",
                              k,buff[k],buff[k],string);
                  }
                  k = ( k + 1 ) & 0xffff;
                  n++;
            }
            /* End debug */

            goto execute_next_instruction;
            break;
      case SIGCOMP_INSTR_STATE_FREE: /* 33 */
            /*
             * STATE-FREE (%partial_identifier_start, %partial_identifier_length)
             */
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## STATE-FREE (partial_identifier_start, partial_identifier_length)",
                        current_address);
            }
            operand_address = current_address + 1;
            /* 
             * %partial_identifier_start
             */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &p_id_start);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       partial_identifier_start %u",
                        operand_address, p_id_start);
            }
            operand_address = next_operand_address;

            /*
             * %partial_identifier_length
             */
            operand_address = next_operand_address;
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &p_id_length);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       partial_identifier_length %u",
                        operand_address, p_id_length);
            }
            current_address = next_operand_address;

            /* Execute the instruction:
             * TODO implement it
             */
            udvm_state_free(buff,p_id_start,p_id_length);
            used_udvm_cycles++;

            goto execute_next_instruction;
            break;
      case SIGCOMP_INSTR_OUTPUT: /* 34 OUTPUT (%output_start, %output_length) */
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## OUTPUT(34) (output_start, output_length)",
                        current_address);
            }
            operand_address = current_address + 1;
            /* 
             * %output_start
             */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &output_start);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      output_start %u",
                        operand_address, output_start);
            }
            operand_address = next_operand_address;
            /* 
             * %output_length
             */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &output_length);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      output_length %u",
                        operand_address, output_length);
            }
            current_address = next_operand_address;

            /* 
             * Execute instruction 
             * 8.4.  Byte copying
             * :
             * The string of bytes is copied in ascending order of memory address,
             * respecting the bounds set by byte_copy_left and byte_copy_right.
             * More precisely, if a byte is copied from/to Address m then the next
             * byte is copied from/to Address n where n is calculated as follows:
             *
             * Set k := m + 1 (modulo 2^16)
             * If k = byte_copy_right then set n := byte_copy_left, else set n := k
             *
             */ 

            n = 0;
            k = output_start; 
            byte_copy_right = buff[66] << 8;
            byte_copy_right = byte_copy_right | buff[67];
            byte_copy_left = buff[64] << 8;
            byte_copy_left = byte_copy_left | buff[65];
            if (print_level_3 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                              "               byte_copy_right = %u", byte_copy_right);
            }
            while ( n < output_length ){

                  if ( k == byte_copy_right ){
                        k = byte_copy_left;
                  }
                  out_buff[output_address] = buff[k];
                  string[0]= buff[k];
                  string[1]= '\0';
                  strp = string;
                  if (print_level_3 ){
                        proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                              "               Output value: %u (0x%x) ASCII(%s) from Addr: %u ,output to dispatcher position %u",
                              buff[k],buff[k],format_text(strp,1), k,output_address);
                  }
                  k = ( k + 1 ) & 0xffff;
                  output_address ++;
                  n++;
            }
            used_udvm_cycles = used_udvm_cycles + 1 + output_length;
            goto execute_next_instruction;
            break;
      case SIGCOMP_INSTR_END_MESSAGE: /* 35 */
            /*
             * END-MESSAGE (%requested_feedback_location,
             * %returned_parameters_location, %state_length, %state_address,
             * %state_instruction, %minimum_access_length,
             * %state_retention_priority)
             */
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
                        "Addr: %u ## END-MESSAGE (requested_feedback_location,state_instruction, minimum_access_length,state_retention_priority)",
                        current_address);
            }
            operand_address = current_address + 1;

            /* %requested_feedback_location */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &requested_feedback_location);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      requested_feedback_location %u",
                        operand_address, requested_feedback_location);
            }
            operand_address = next_operand_address;
            /* returned_parameters_location */
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &returned_parameters_location);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      returned_parameters_location %u",
                        operand_address, returned_parameters_location);
            }
            operand_address = next_operand_address;
            /*
             * %state_length
             */
            operand_address = next_operand_address;
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_length);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      state_length %u",
                        operand_address, state_length);
            }
            /*
             * %state_address
             */
            operand_address = next_operand_address;
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_address);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      state_address %u",
                        operand_address, state_address);
            }
            /*
             * %state_instruction
             */
            operand_address = next_operand_address;
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_instruction);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      state_instruction %u",
                        operand_address, state_instruction);
            }
            operand_address = next_operand_address;
            /*
             * %minimum_access_length
             */
            operand_address = next_operand_address;
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &minimum_access_length);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      minimum_access_length %u",
                        operand_address, minimum_access_length);
            }
            operand_address = next_operand_address;

            /*
             * %state_retention_priority
             */
            operand_address = next_operand_address;
            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_retention_priority);
            if (print_level_1 ){
                  proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      state_retention_priority %u",
                        operand_address, state_retention_priority);
            }
            current_address = next_operand_address;
            /* TODO: This isn't currently totaly correct as END_INSTRUCTION might not create state */
            no_of_state_create++;
            if ( no_of_state_create > 4 ){
                  result_code = 12;
                  goto decompression_failure; 
            }
            state_length_buff[no_of_state_create] = state_length;
            state_address_buff[no_of_state_create] = state_address;
            state_instruction_buff[no_of_state_create] = state_instruction;
            /* Not used ? */
            state_minimum_access_length_buff[no_of_state_create] = minimum_access_length;
            state_state_retention_priority_buff[no_of_state_create] = state_retention_priority;
            
            /* Execute the instruction
             */
            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"no_of_state_create %u",no_of_state_create);
            if ( no_of_state_create != 0 ){
                  for( x=0; x < 20; x++){
                        sha1_digest_buf[x]=0;
                  }
                  n = 1;
                  byte_copy_right = buff[66] << 8;
                  byte_copy_right = byte_copy_right | buff[67];
                  byte_copy_left = buff[64] << 8;
                  byte_copy_left = byte_copy_left | buff[65];
                  while ( n < no_of_state_create + 1 ){
                        sha1buff = g_malloc(state_length_buff[n]+8);
                        sha1buff[0] = state_length_buff[n] >> 8;
                        sha1buff[1] = state_length_buff[n] & 0xff;
                        sha1buff[2] = state_address_buff[n] >> 8;
                        sha1buff[3] = state_address_buff[n] & 0xff;
                        sha1buff[4] = state_instruction_buff[n] >> 8;
                        sha1buff[5] = state_instruction_buff[n] & 0xff; 
                        sha1buff[6] = state_minimum_access_length_buff[n] >> 8;
                        sha1buff[7] = state_minimum_access_length_buff[n] & 0xff;
                        if (print_level_3 ){
                              for( x=0; x < 8; x++){
                                    proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"sha1buff %u 0x%x",
                                          x,sha1buff[x]);
                              }
                        }
                        k = state_address_buff[n];
                        for( x=0; x < state_length_buff[n]; x++)
                              {
                              if ( k == byte_copy_right ){
                                    k = byte_copy_left;
                              }
                              sha1buff[8+x] = buff[k];
                              k = ( k + 1 ) & 0xffff;
                              }

                        sha1_starts( &ctx );
                        sha1_update( &ctx, (guint8 *) sha1buff, state_length_buff[n] + 8);
                        sha1_finish( &ctx, sha1_digest_buf );
                        if (print_level_3 ){
                              proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"SHA1 digest %s",bytes_to_str(sha1_digest_buf, 20));

                        }
                        udvm_state_create(sha1buff, sha1_digest_buf, state_minimum_access_length_buff[n]);
                        proto_tree_add_text(udvm_tree,bytecode_tvb, 0, -1,"### Creating state ###");
                        proto_tree_add_string(udvm_tree,hf_id, bytecode_tvb, 0, 0, bytes_to_str(sha1_digest_buf, state_minimum_access_length_buff[n]));

                        n++;

                  }
            }



            /* At least something got decompressed, show it */
            decomp_tvb = tvb_new_real_data(out_buff,output_address,output_address);
            /* Arrange that the allocated packet data copy be freed when the
             * tvbuff is freed. 
             */
            tvb_set_free_cb( decomp_tvb, g_free );

            tvb_set_child_real_data_tvbuff(message_tvb,decomp_tvb);
            add_new_data_source(pinfo, decomp_tvb, "Decompressed SigComp message");
            /*
            proto_tree_add_text(udvm_tree, decomp_tvb, 0, -1,"SigComp message Decompressed");
            */    
            used_udvm_cycles = used_udvm_cycles + 1 + state_length;
            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"maximum_UDVM_cycles %u used_udvm_cycles %u",
                  maximum_UDVM_cycles, used_udvm_cycles);
            return decomp_tvb;
            break;

      default:
          proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1," ### Addr %u Invalid instruction: %u (0x%x)",
                  current_address,current_instruction,current_instruction);
            break;
            }
            g_free(out_buff);
            return NULL;
decompression_failure:
            
            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"DECOMPRESSION FAILURE: %s",
                            val_to_str(result_code, result_code_vals,"Unknown (%u)"));
            g_free(out_buff);
            return NULL;

}
      
 /*  The simplest operand type is the literal (#), which encodes a
  * constant integer from 0 to 65535 inclusive.  A literal operand may
  * require between 1 and 3 bytes depending on its value.
  * Bytecode:                       Operand value:      Range:
  * 0nnnnnnn                        N                   0 - 127
  * 10nnnnnn nnnnnnnn               N                   0 - 16383
  * 11000000 nnnnnnnn nnnnnnnn      N                   0 - 65535
  *
  *            Figure 8: Bytecode for a literal (#) operand
  *
  */
static int
decode_udvm_literal_operand(guint8 *buff,guint operand_address, guint16 *value) 
{
      guint bytecode;
      guint16 operand;
      guint test_bits;
      guint offset = operand_address;
      guint8      temp_data;

      bytecode = buff[operand_address];
      test_bits = bytecode >> 7;
      if (test_bits == 1){
            test_bits = bytecode >> 6;
            if (test_bits == 2){
                  /*
                   * 10nnnnnn nnnnnnnn               N                   0 - 16383
                   */
                  temp_data = buff[operand_address] & 0x1f;
                  operand = temp_data << 8;
                  temp_data = buff[operand_address + 1];
                  operand = operand | temp_data;
                  *value = operand;
                  offset = offset + 2;

            }else{
                  /*
                   * 111000000 nnnnnnnn nnnnnnnn      N                   0 - 65535
                   */
                  offset ++;
                  temp_data = buff[operand_address] & 0x1f;
                  operand = temp_data << 8;
                  temp_data = buff[operand_address + 1];
                  operand = operand | temp_data;
                  *value = operand;
                  offset = offset + 2;

            }
      }else{
            /*
             * 0nnnnnnn                        N                   0 - 127
             */
            operand = ( bytecode & 0x7f);
            *value = operand;
            offset ++;
      }

      return offset;

}

/*
 * The second operand type is the reference ($), which is always used to
 * access a 2-byte value located elsewhere in the UDVM memory.  The
 * bytecode for a reference operand is decoded to be a constant integer
 * from 0 to 65535 inclusive, which is interpreted as the memory address
 * containing the actual value of the operand.
 * Bytecode:                       Operand value:      Range:
 *
 * 0nnnnnnn                        memory[2 * N]       0 - 65535
 * 10nnnnnn nnnnnnnn               memory[2 * N]       0 - 65535
 * 11000000 nnnnnnnn nnnnnnnn      memory[N]           0 - 65535
 *
 *            Figure 9: Bytecode for a reference ($) operand
 */
static int
dissect_udvm_reference_operand(guint8 *buff,guint operand_address, guint16 *value,guint *result_dest) 
{
      guint bytecode;
      guint16 operand;
      guint offset = operand_address;
      guint test_bits;
      guint8      temp_data;
      guint16 temp_data16;

      bytecode = buff[operand_address];
      test_bits = bytecode >> 7;
      if (test_bits == 1){
            test_bits = bytecode >> 6;
            if (test_bits == 2){
                  /*
                   * 10nnnnnn nnnnnnnn               memory[2 * N]       0 - 65535
                   */
                  temp_data = buff[operand_address] & 0x3f;
                  operand = temp_data << 8;
                  temp_data = buff[operand_address + 1];
                  operand = operand | temp_data;
                  operand = (operand * 2);
                  *result_dest = operand;
                  temp_data16 = buff[operand] << 8;
                  temp_data16 = temp_data16 | buff[operand+1];
                  *value = temp_data16;
                  offset = offset + 2;

            }else{
                  /*
                   * 11000000 nnnnnnnn nnnnnnnn      memory[N]           0 - 65535
                   */
                  operand_address++;
                  operand = buff[operand_address] << 8;
                  operand = operand | buff[operand_address + 1];
                  *result_dest = operand;
                  temp_data16 = buff[operand] << 8;
                  temp_data16 = temp_data16 | buff[operand+1];
                  *value = temp_data16;
                  offset = offset + 3;

            }
      }else{
            /*
             * 0nnnnnnn                        memory[2 * N]       0 - 65535
             */
            operand = ( bytecode & 0x7f);
            operand = (operand * 2);
            *result_dest = operand;
            temp_data16 = buff[operand] << 8;
            temp_data16 = temp_data16 | buff[operand+1];
            *value = temp_data16;
            offset ++;
      }

      return offset;
}

      /* RFC3320
       * Figure 10: Bytecode for a multitype (%) operand
       * Bytecode:                       Operand value:      Range:               HEX val
       * 00nnnnnn                        N                   0 - 63                       0x00
       * 01nnnnnn                        memory[2 * N]       0 - 65535              0x40
       * 1000011n                        2 ^ (N + 6)        64 , 128                      0x86  
       * 10001nnn                        2 ^ (N + 8)    256 , ... , 32768                 0x88
       * 111nnnnn                        N + 65504       65504 - 65535              0xe0
       * 1001nnnn nnnnnnnn               N + 61440       61440 - 65535              0x90
       * 101nnnnn nnnnnnnn               N                   0 - 8191                     0xa0
       * 110nnnnn nnnnnnnn               memory[N]           0 - 65535              0xc0
       * 10000000 nnnnnnnn nnnnnnnn      N                   0 - 65535              0x80
       * 10000001 nnnnnnnn nnnnnnnn      memory[N]           0 - 65535              0x81
       */
static int
decode_udvm_multitype_operand(guint8 *buff,guint operand_address, guint16 *value)
{
      guint test_bits;
      guint bytecode;
      guint offset = operand_address;
      guint16 operand;
      guint32 result;
      guint8 temp_data;
      guint16 temp_data16;
      guint16 memmory_addr = 0;

      bytecode = buff[operand_address];
      test_bits = ( bytecode & 0xc0 ) >> 6;
      switch (test_bits ){
      case 0:
            /*  
             * 00nnnnnn                        N                   0 - 63
             */
            operand =  buff[operand_address];
            /* debug
             *g_warning("Reading 0x%x From address %u",operand,offset);
             */
            *value = operand;
            offset ++;
            break;
      case 1:
            /*  
             * 01nnnnnn                        memory[2 * N]       0 - 65535
             */
            memmory_addr = ( bytecode & 0x3f) * 2;
            temp_data16 = buff[memmory_addr] << 8;
            temp_data16 = temp_data16 | buff[memmory_addr+1];
            *value = temp_data16;
            offset ++;
            break;
      case 2:
            /* Check tree most significant bits */
            test_bits = ( bytecode & 0xe0 ) >> 5;
            if ( test_bits == 5 ){
            /*
             * 101nnnnn nnnnnnnn               N                   0 - 8191
             */
                  temp_data = buff[operand_address] & 0x1f;
                  operand = temp_data << 8;
                  temp_data = buff[operand_address + 1];
                  operand = operand | temp_data;
                  *value = operand;
                  offset = offset + 2;
            }else{
                  test_bits = ( bytecode & 0xf0 ) >> 4;
                  if ( test_bits == 9 ){
            /*
             * 1001nnnn nnnnnnnn               N + 61440       61440 - 65535
             */
                        temp_data = buff[operand_address] & 0x0f;
                        operand = temp_data << 8;
                        temp_data = buff[operand_address + 1];
                        operand = operand | temp_data;
                        operand = operand + 61440;
                        *value = operand;
                        offset = offset + 2;
                  }else{
                        test_bits = ( bytecode & 0x08 ) >> 3;
                        if ( test_bits == 1){
            /*
             * 10001nnn                        2 ^ (N + 8)    256 , ... , 32768
             */

                              result = (guint32)pow(2,( buff[operand_address] & 0x07) + 8);
                              operand = result & 0xffff;
                              *value = operand;
                              offset ++;
                        }else{
                              test_bits = ( bytecode & 0x0e ) >> 1;
                              if ( test_bits == 3 ){
                                    /*
                                     * 1000 011n                        2 ^ (N + 6)        64 , 128
                                     */
                                    result = (guint32)pow(2,( buff[operand_address] & 0x01) + 6);
                                    operand = result & 0xffff;
                                    *value = operand;
                                    offset ++;
                              }else{
                              /*
                               * 1000 0000 nnnnnnnn nnnnnnnn      N                   0 - 65535
                               * 1000 0001 nnnnnnnn nnnnnnnn      memory[N]           0 - 65535
                               */
                                    offset ++;
                                    temp_data16 = buff[operand_address + 1] << 8;
                                    temp_data16 = temp_data16 | buff[operand_address + 2];
                                    /*  debug
                                     * g_warning("Reading 0x%x From address %u",temp_data16,operand_address);
                                     */
                                    if ( (bytecode & 0x01) == 1 ){
                                          memmory_addr = temp_data16;
                                          temp_data16 = buff[memmory_addr] << 8;
                                          temp_data16 = temp_data16 | buff[memmory_addr+1];
                                    }
                                    *value = temp_data16;
                                    offset = offset +2;
                              }


                        }
                  }
            }
            break;

      case 3:
            test_bits = ( bytecode & 0x20 ) >> 5;
            if ( test_bits == 1 ){
            /*
             * 111nnnnn                        N + 65504       65504 - 65535
             */
                  operand = ( buff[operand_address] & 0x1f) + 65504;
                  *value = operand;
                  offset ++;
            }else{
            /*
             * 110nnnnn nnnnnnnn               memory[N]           0 - 65535
             */
                  memmory_addr = buff[operand_address] & 0x1f;
                  memmory_addr = memmory_addr << 8;
                  memmory_addr = memmory_addr | buff[operand_address + 1];
                  temp_data16 = buff[memmory_addr] << 8;
                  temp_data16 = temp_data16 | buff[memmory_addr+1];
                  *value = temp_data16;
                  /*  debug 
                   * g_warning("Reading 0x%x From address %u",temp_data16,memmory_addr);
                   */
                  offset = offset +2;
            }
                  
      default :
            break;
      }
      return offset;
}
      /*
       *
       * The fourth operand type is the address (@).  This operand is decoded
       * as a multitype operand followed by a further step: the memory address
       * of the UDVM instruction containing the address operand is added to
       * obtain the correct operand value.  So if the operand value from
       * Figure 10 is D then the actual operand value of an address is
       * calculated as follows:
       *
       * operand_value = (memory_address_of_instruction + D) modulo 2^16
       *
       * Address operands are always used in instructions that control program
       * flow, because they ensure that the UDVM bytecode is position-
       * independent code (i.e., it will run independently of where it is
       * placed in the UDVM memory).
       */
static int
decode_udvm_address_operand(guint8 *buff,guint operand_address, guint16 *value,guint current_address)
{
      guint32 result;
      guint16 value1;
      guint next_opreand_address;

      next_opreand_address = decode_udvm_multitype_operand(buff, operand_address, &value1);
      result = value1 & 0xffff;
      result = result + current_address;
      *value = result & 0xffff;
      return next_opreand_address;
}

static int
decomp_dispatch_get_bits(tvbuff_t *message_tvb,proto_tree *udvm_tree,guint8 bit_order, 
                  guint8 *buff,guint16 *old_input_bit_order, guint16 *remaining_bits,
                  guint16     *input_bits, guint *input_address, guint16 length, 
                  guint16 *result_code,guint msg_end){

guint16 input_bit_order;
guint16 value;
guint16 mask;
guint8      octet;
guint8      n;
guint8      i;



            input_bit_order = buff[68] << 8;
            input_bit_order = input_bit_order | buff[69];
            *result_code = 0;

            /*
             * Note that after one or more INPUT instructions the dispatcher may
             * hold a fraction of a byte (what used to be the LSBs if P = 0, or, the
             * MSBs, if P = 1).  If an INPUT instruction is encountered and the P-
             * bit has changed since the last INPUT instruction, any fraction of a
             * byte still held by the dispatcher MUST be discarded (even if the
             * INPUT instruction requests zero bits).  The first bit passed to the
             * INPUT instruction is taken from the subsequent byte.
             */
            if (print_level_1 ){
                  if ( *input_address > ( msg_end - 1)){
                        proto_tree_add_text(udvm_tree, message_tvb, (msg_end - 1), 1,
                              "               input_bit_order = 0x%x, old_input_bit_order = 0x%x MSG BUFFER END", input_bit_order, *old_input_bit_order);
                  }else{
                        proto_tree_add_text(udvm_tree, message_tvb, *input_address, 1,
                              "               input_bit_order = 0x%x, old_input_bit_order = 0x%x", input_bit_order,*old_input_bit_order);
                  }
            }

            if ( (*old_input_bit_order & 0x0001 ) != ( input_bit_order & 0x0001 )){
                  /* clear out remaining bits TODO check this further */
                  *remaining_bits = 0;
                  *old_input_bit_order = input_bit_order;
            }

            /*
             * Do we hold a fraction of a byte ?
             */
            if ( *remaining_bits != 0 ){
                  if ( *remaining_bits < length ){
                        if (*remaining_bits > 8 ){
                              proto_tree_add_text(udvm_tree, message_tvb, *input_address, 1,
                              "               Yikes!! haven't coded this case yet!!remaining_bits %u > 8 ", *remaining_bits);
                              return 0xfbad;
                        }
                        if ( *input_address > ( msg_end -1 ) ){
                              *result_code = 11;
                              return 0xfbad;
                        }

                        octet = tvb_get_guint8(message_tvb, *input_address);
                        if (print_level_1 ){
                              proto_tree_add_text(udvm_tree, message_tvb, *input_address , 1,
                              "               Geting value: %u (0x%x) From Addr: %u", octet, octet, *input_address);
                        }
                        *input_address = *input_address + 1;

                        if ((input_bit_order & 0x0001)==0){
                              /* 
                               * P bit = 0
                               */
                              /* borrow value */
                              value = octet & 0x00ff;
                              value = value << ( 8 - (*remaining_bits));
                              *remaining_bits = *remaining_bits + 8;
                        }else{
                              /*
                               * P bit = 1
                               */
                              /* borrow value */
                              value =  ( octet << 7) & 0x80;
                              value = value | (( octet << 5) & 0x40 ); 
                              value = value | (( octet << 3) & 0x20 ); 
                              value = value | (( octet << 1) & 0x10 ); 

                              value = value | (( octet >> 1) & 0x08 ); 
                              value = value | (( octet >> 3) & 0x04 ); 
                              value = value | (( octet >> 5) & 0x02 ); 
                              value = value | (( octet >> 7) & 0x01 );

                              value = value << ( 8 - (*remaining_bits));
                              *remaining_bits = *remaining_bits + 8;
                        }

                        if (print_level_1 ){
                              proto_tree_add_text(udvm_tree, message_tvb, *input_address - 1 , 1,
                              "               Or value 0x%x with 0x%x remaining bits %u, Result 0x%x",
                              value, *input_bits, *remaining_bits, (*input_bits | value));
                        }
                        *input_bits = *input_bits | value;
                  }/* Bits remain */
                  if ( ( bit_order ) == 0 ){
                        /* 
                         * F/H bit = 0
                         */
                        mask = (0xffff >> length)^0xffff;
                        value = *input_bits & mask;
                        value = value >> ( 16 - length);
                        *input_bits = *input_bits << length;
                        *remaining_bits = *remaining_bits - length;
                        if (print_level_1 ){
                              proto_tree_add_text(udvm_tree, message_tvb, *input_address, 1,
                              "               Remaining input_bits 0x%x remaining_bits %u", *input_bits, *remaining_bits);
                        }
                        return value;
                  }
                  else{
                        /* 
                         * F/H bit = 1
                         */
                        n = 15;
                        i = 0;
                        value = 0;
                        while ( i < length ){
                              value =  value | (( *input_bits & 0x8000 ) >> n) ;
                              *input_bits = *input_bits << 1;
                              n--;
                              i++;
                        }
                        *remaining_bits = *remaining_bits - length;
                        if (print_level_1 ){
                              proto_tree_add_text(udvm_tree, message_tvb, *input_address, 1,
                              "               Remaining input_bits 0x%x", *input_bits);
                        }
                        return value;
                  }

            }
            else
            {
                  /*
                   * Do we need one or two bytes ?
                   */
                  if ( *input_address > ( msg_end -1 ) ){
                        *result_code = 11;
                        return 0xfbad;
                  }

                  if ( length < 9 ){
                        octet = tvb_get_guint8(message_tvb, *input_address);
                        if (print_level_1 ){
                              proto_tree_add_text(udvm_tree, message_tvb, *input_address , 1,
                              "               Geting value: %u (0x%x) From Addr: %u", octet, octet, *input_address);
                        }
                        *input_address = *input_address + 1;
                        if (print_level_1 ){
                              proto_tree_add_text(udvm_tree, message_tvb, *input_address , 1,
                              "               Next input from Addr: %u", *input_address);
                        }

                        if ( ( input_bit_order & 0x0001 ) == 0 ){
                              /*
                               * P bit = Zero
                               */
                              *input_bits = octet & 0xff;
                              *input_bits = *input_bits << 8;
                              *remaining_bits = 8;
                        }else{
                              /*
                               * P bit = One
                               */
                              *input_bits =  ( octet << 7) & 0x80;
                              *input_bits = *input_bits | (( octet << 5) & 0x40 ); 
                              *input_bits = *input_bits | (( octet << 3) & 0x20 ); 
                              *input_bits = *input_bits | (( octet << 1) & 0x10 ); 

                              *input_bits = *input_bits | (( octet >> 1) & 0x08 ); 
                              *input_bits = *input_bits | (( octet >> 3) & 0x04 ); 
                              *input_bits = *input_bits | (( octet >> 5) & 0x02 ); 
                              *input_bits = *input_bits | (( octet >> 7) & 0x01 ); 

                              *input_bits = *input_bits << 8;
                              *remaining_bits = 8;
                              proto_tree_add_text(udvm_tree, message_tvb, *input_address -1, 1,
                              "               P bit = 1, input_bits = 0x%x",*input_bits);

                        }

                  }
                  else{
                        /* Length > 9, we need two bytes */
                        octet = tvb_get_guint8(message_tvb, *input_address);
                        if (print_level_1 ){
                              proto_tree_add_text(udvm_tree, message_tvb, *input_address, 1,
                              "              Geting first value: %u (0x%x) From Addr: %u", octet, octet, *input_address);
                        }
                        if ( ( input_bit_order & 0x0001 ) == 0 ){
                              *input_bits = octet & 0xff;
                              *input_bits = *input_bits << 8;
                              *input_address = *input_address + 1;
                        }else{
                              /*
                               * P bit = One
                               */
                              *input_bits =  ( octet << 7) & 0x80;
                              *input_bits = *input_bits | (( octet << 5) & 0x40 ); 
                              *input_bits = *input_bits | (( octet << 3) & 0x20 ); 
                              *input_bits = *input_bits | (( octet << 1) & 0x10 ); 

                              *input_bits = *input_bits | (( octet >> 1) & 0x08 ); 
                              *input_bits = *input_bits | (( octet >> 3) & 0x04 ); 
                              *input_bits = *input_bits | (( octet >> 5) & 0x02 ); 
                              *input_bits = *input_bits | (( octet >> 7) & 0x01 ); 

                              *input_bits = *input_bits << 8;
                              *input_address = *input_address + 1;
                              proto_tree_add_text(udvm_tree, message_tvb, *input_address -1, 1,
                              "               P bit = 1, input_bits = 0x%x",*input_bits);

                        }

                        if ( *input_address > ( msg_end - 1)){
                              *result_code = 11;
                              return 0xfbad;
                        }

                        octet = tvb_get_guint8(message_tvb, *input_address);
                        *input_address = *input_address + 1;
                        if (print_level_1 ){
                              proto_tree_add_text(udvm_tree, message_tvb, *input_address - 2, 2,
                              "               Geting second value: %u (0x%x) From Addr: %u", octet, octet, *input_address);
                        }
                        if ( ( input_bit_order & 0x0001 ) == 0 ){
                        /*
                         * P bit = zero
                         */
                        *input_bits = *input_bits | octet;
                        *remaining_bits = 16;
                        }else{
                              /*
                               * P bit = One
                               */
                              *input_bits =  ( octet << 7) & 0x80;
                              *input_bits = *input_bits | (( octet << 5) & 0x40 ); 
                              *input_bits = *input_bits | (( octet << 3) & 0x20 ); 
                              *input_bits = *input_bits | (( octet << 1) & 0x10 ); 

                              *input_bits = *input_bits | (( octet >> 1) & 0x08 ); 
                              *input_bits = *input_bits | (( octet >> 3) & 0x04 ); 
                              *input_bits = *input_bits | (( octet >> 5) & 0x02 ); 
                              *input_bits = *input_bits | (( octet >> 7) & 0x01 ); 

                              *input_bits = *input_bits << 8;
                              *input_address = *input_address + 1;
                              proto_tree_add_text(udvm_tree, message_tvb, *input_address -1, 1,
                              "               P bit = 1, input_bits = 0x%x",*input_bits);

                        *remaining_bits = 16;
                        }

                  }
                  if ( ( bit_order ) == 0 ){
                        /* 
                         * F/H bit = 0
                         */
                        mask = (0xffff >> length)^0xffff;
                        value = *input_bits & mask;
                        value = value >> ( 16 - length);
                        *input_bits = *input_bits << length;
                        *remaining_bits = *remaining_bits - length;
                        if (print_level_1 ){
                              proto_tree_add_text(udvm_tree, message_tvb, *input_address, 1,
                              "               Remaining input_bits 0x%x", *input_bits);
                        }
                        return value;
                  }
                  else{
                        /* 
                         * F/H bit = 1
                         */
                        n = 15;
                        i = 0;
                        value = 0;
                        while ( i < length ){
                              value =  value | ( *input_bits & 0x8000 ) >> n ;
                              *input_bits = *input_bits << 1;
                              n--;
                              i++;
                        }
                        *remaining_bits = *remaining_bits - length;
                        if (print_level_1 ){
                              proto_tree_add_text(udvm_tree, message_tvb, *input_address, 1,
                              "               Remaining input_bits 0x%x", *input_bits);
                        }
                        return value;
                  }

            }
}
/* end udvm */


Generated by  Doxygen 1.6.0   Back to index