osmocom
/
wireshark
14
0
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity
wireshark/epan/sigcomp-udvm.c

3221 lines
109 KiB
C
Raw Normal View History

Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* 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$
*
name change svn path=/trunk/; revision=18197
2006-05-21 05:12:17 +00:00
* Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 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.
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 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.
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 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 :
udvm: initialise a variable sigcomp: implement RFC 4077 svn path=/trunk/; revision=15640
2005-08-31 19:51:24 +00:00
* http://www.ietf.org/internet-drafts/draft-ietf-rohc-sigcomp-impl-guide-05.txt
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 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 <glib.h>
#include "packet.h"
#include "strutil.h"
#include "sigcomp-udvm.h"
#include "sigcomp_state_hdlr.h"
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
#include "crypt/crypt-sha1.h"
Second try to move crc routines to libwsutil. This time keep the tvb routines in epan. Now we can use common crc routines outside epan. svn path=/trunk/; revision=38810
2011-08-31 09:00:54 +00:00
#include "wsutil/crc16.h"
Throw an exception instead of trying to read past the end of a buffer. Fixes bug 455. svn path=/trunk/; revision=15876
2005-09-19 20:50:10 +00:00
#include "except.h"
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
#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;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
static gint show_instr_detail_level;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* Internal result code values of decompression failures */
const value_string result_code_vals[] = {
Bill Meier: Spelling fixes. svn path=/trunk/; revision=16956
2006-01-05 13:01:08 +00:00
{ 0, "No decompression failure" },
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
{ 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" },
Fix some typos and spelling (mostly in text strings) svn path=/trunk/; revision=27068
2008-12-20 01:01:28 +00:00
{ 6, "Attempt to jump outside of UDVM memory" },
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
{ 7, "L in input-bits > 16" },
{ 8, "input_bit_order > 7" },
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
{ 9, "Instruction Decompression failure encountered" },
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
{10, "Input huffman failed j > n" },
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
{11, "Input bits requested beyond end of message" },
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
{12, "more than four state creation requests are made before the END-MESSAGE instruction" },
{13, "state_retention_priority is 65535" },
Fix some typos and spelling (mostly in text strings) svn path=/trunk/; revision=27068
2008-12-20 01:01:28 +00:00
{14, "Input bytes requested beyond end of message" },
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
{15, "Maximum number of UDVM cycles reached" },
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
{16, "UDVM stack underflow" },
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
{ 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);
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
static int decomp_dispatch_get_bits(tvbuff_t *message_tvb,proto_tree *udvm_tree,guint8 bit_order,
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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,
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
proto_tree *udvm_tree, gint udvm_mem_dest,
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
gint print_flags, gint hf_id,
gint header_len,
From Timo Metsala Changes: o Implemented CRC and SHA-1 (sort operations are still missing) o After state acccess, the execution start is not necessarily the beginning of the bytecode; start IP is now a new parameter to decompress_sigcomp_message() o Removed some hard-coded assumptions about bytecode starting at offset 128 svn path=/trunk/; revision=15531
2005-08-25 19:23:15 +00:00
gint byte_code_state_len, gint byte_code_id_len,
gint udvm_start_ip)
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
{
tvbuff_t *decomp_tvb;
Allocate 64K buffer from heap svn path=/trunk/; revision=30339
2009-10-05 18:07:59 +00:00
/* UDVM memory must be initialised to zero */
guint8 *buff = ep_alloc0(UDVM_MEMORY_SIZE);
Be more paranoid about buffer overruns. svn path=/trunk/; revision=15901
2005-09-20 17:26:43 +00:00
char string[2];
Fix comments. svn path=/trunk/; revision=33090
2010-06-04 19:29:26 +00:00
guint8 *out_buff; /* Largest allowed size for a message is UDVM_MEMORY_SIZE = 65536 */
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
guint16 stack_location;
guint16 stack_fill;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
guint16 result;
guint msg_end = tvb_reported_length_remaining(message_tvb, 0);
udvm: initialise a variable sigcomp: implement RFC 4077 svn path=/trunk/; revision=15640
2005-08-31 19:51:24 +00:00
guint16 result_code = 0;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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];
Fix gcc 4.6 "set but not used [-Wunused-but-set-variable]" warnings svn path=/trunk/; revision=37600
2011-06-07 22:28:55 +00:00
/* guint16 state_state_retention_priority_buff[5]; */
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
guint32 used_udvm_cycles = 0;
guint cycles_per_bit;
guint maximum_UDVM_cycles;
guint8 *sha1buff;
Add bounds checking in several places to the SigComp UDVM. Use memset() instead of while loops to initialize variables. Use a define instead of magic numbers. Don't use guint8s for counters. Add a corresponding entry to the release notes. svn path=/trunk/; revision=15715
2005-09-07 20:09:40 +00:00
unsigned char sha1_digest_buf[STATE_BUFFER_SIZE];
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
sha1_context ctx;
/* UDVM operand variables */
guint16 length;
guint16 at_address;
guint16 destination;
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
guint16 addr;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* Set print parameters */
print_level_1 = FALSE;
print_level_2 = FALSE;
print_level_3 = FALSE;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
show_instr_detail_level = 0;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
switch( print_flags ) {
case 0:
break;
case 1:
print_level_1 = TRUE;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
show_instr_detail_level = 1;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
break;
case 2:
print_level_1 = TRUE;
print_level_2 = TRUE;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
show_instr_detail_level = 1;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
break;
case 3:
print_level_1 = TRUE;
print_level_2 = TRUE;
print_level_3 = TRUE;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
show_instr_detail_level = 2;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
break;
default:
print_level_1 = TRUE;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
show_instr_detail_level = 1;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
break;
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/* Set initial UDVM data
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 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 */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
buff[0] = (UDVM_MEMORY_SIZE >> 8) & 0x00FF;
buff[1] = UDVM_MEMORY_SIZE & 0x00FF;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* cycles_per_bit */
buff[2] = 0;
buff[3] = 16;
/* SigComp_version */
buff[4] = 0;
buff[5] = 1;
/* partial_state_ID_length */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
buff[6] = (byte_code_id_len >> 8) & 0x00FF;
buff[7] = byte_code_id_len & 0x00FF;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* state_length */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
buff[8] = (byte_code_state_len >> 8) & 0x00FF;
buff[9] = byte_code_state_len & 0x00FF;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
code_length = tvb_reported_length_remaining(bytecode_tvb, 0);
cycles_per_bit = buff[2] << 8;
cycles_per_bit = cycles_per_bit | buff[3];
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* maximum_UDVM_cycles = (8 * n + 1000) * cycles_per_bit
*/
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
maximum_UDVM_cycles = (( 8 * (header_len + msg_end) ) + 1000) * cycles_per_bit;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
Be more paranoid about buffer overruns. svn path=/trunk/; revision=15901
2005-09-20 17:26:43 +00:00
while ( code_length > offset && i < UDVM_MEMORY_SIZE ) {
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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++;
}
Fix comments. svn path=/trunk/; revision=33090
2010-06-04 19:29:26 +00:00
/* Largest allowed size for a message is UDVM_MEMORY_SIZE = 65536 */
According to RFC 3220 section 7 the max UDVM message size is 65536, not 65535. Hopefully fixes bug 4837. svn path=/trunk/; revision=33087
2010-06-04 18:28:02 +00:00
out_buff = g_malloc(UDVM_MEMORY_SIZE);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* Start executing code */
From Timo Metsala Changes: o Implemented CRC and SHA-1 (sort operations are still missing) o After state acccess, the execution start is not necessarily the beginning of the bytecode; start IP is now a new parameter to decompress_sigcomp_message() o Removed some hard-coded assumptions about bytecode starting at offset 128 svn path=/trunk/; revision=15531
2005-08-25 19:23:15 +00:00
current_address = udvm_start_ip;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
input_address = 0;
operand_address = 0;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, offset, 1,"UDVM EXECUTION STARTED at Address: %u Message size %u",
From Timo Metsala Changes: o Implemented CRC and SHA-1 (sort operations are still missing) o After state acccess, the execution start is not necessarily the beginning of the bytecode; start IP is now a new parameter to decompress_sigcomp_message() o Removed some hard-coded assumptions about bytecode starting at offset 128 svn path=/trunk/; revision=15531
2005-08-25 19:23:15 +00:00
current_address, msg_end);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
execute_next_instruction:
if ( used_udvm_cycles > maximum_UDVM_cycles ){
result_code = 15;
goto decompression_failure;
}
Increment the cycle count no matter what. Increase the cycle count further when SIGCOMP_INSTR_INPUT_BYTES fails. Fixes the infinite loop found in bug 4826. svn path=/trunk/; revision=33061
2010-06-02 22:16:49 +00:00
used_udvm_cycles++;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
current_instruction = buff[current_address & 0xffff];
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
switch ( current_instruction ) {
case SIGCOMP_INSTR_DECOMPRESSION_FAILURE:
if ( result_code == 0 )
result_code = 9;
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## DECOMPRESSION-FAILURE(0)",
current_address);
Ethereal->Wireshark svn path=/trunk/; revision=18234
2006-05-28 19:49:07 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Wireshark UDVM diagnostic: %s.",
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
val_to_str(result_code, result_code_vals,"Unknown (%u)"));
if ( output_address > 0 ){
/* At least something got decompressed, show it */
Apply some of the patches from: http://wiki.wireshark.org/Development/Optimization svn path=/trunk/; revision=28365
2009-05-14 20:12:43 +00:00
decomp_tvb = tvb_new_child_real_data(message_tvb, out_buff,output_address,output_address);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* Arrange that the allocated packet data copy be freed when the
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
* tvbuff is freed.
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
*/
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
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
* is cleaned up.
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
*/
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) */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u operand_1 %u",
operand_address, operand_1);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* %operand_2*/
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u operand_2 %u",
operand_address, operand_2);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## AND (operand_1=%u, operand_2=%u)",
current_address, operand_1, operand_2);
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* execute the instruction */
result = operand_1 & operand_2;
lsb = result & 0xff;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
msb = result >> 8;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
buff[result_dest] = msb;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
buff[(result_dest+1) & 0xffff] = lsb;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
if (print_level_1 ){
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1," Loading result %u at %u",
result, result_dest);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
current_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
goto execute_next_instruction;
break;
case SIGCOMP_INSTR_OR: /* 2 OR ($operand_1, %operand_2) */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u operand_1 %u",
operand_address, operand_1);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* %operand_2*/
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u operand_2 %u",
operand_address, operand_2);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## OR (operand_1=%u, operand_2=%u)",
current_address, operand_1, operand_2);
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* execute the instruction */
result = operand_1 | operand_2;
lsb = result & 0xff;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
msb = result >> 8;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
buff[result_dest] = msb;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
buff[(result_dest+1) & 0xffff] = lsb;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
if (print_level_1 ){
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1," Loading result %u at %u",
result, result_dest);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
current_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
goto execute_next_instruction;
break;
case SIGCOMP_INSTR_NOT: /* 3 NOT ($operand_1) */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u operand_1 %u",
operand_address, operand_1);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## NOT (operand_1=%u)",
current_address, operand_1);
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* execute the instruction */
result = operand_1 ^ 0xffff;
lsb = result & 0xff;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
msb = result >> 8;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
buff[result_dest] = msb;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
buff[(result_dest+1) & 0xffff] = lsb;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
if (print_level_1 ){
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1," Loading result %u at %u",
result, result_dest);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
current_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
goto execute_next_instruction;
break;
case SIGCOMP_INSTR_LSHIFT: /* 4 LSHIFT ($operand_1, %operand_2) */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u operand_1 %u",
operand_address, operand_1);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* %operand_2*/
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u operand_2 %u",
operand_address, operand_2);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## LSHIFT (operand_1=%u, operand_2=%u)",
current_address, operand_1, operand_2);
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* execute the instruction */
result = operand_1 << operand_2;
lsb = result & 0xff;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
msb = result >> 8;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
buff[result_dest] = msb;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
buff[(result_dest+1) & 0xffff] = lsb;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
if (print_level_1 ){
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1," Loading result %u at %u",
result, result_dest);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
current_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
goto execute_next_instruction;
break;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
case SIGCOMP_INSTR_RSHIFT: /* 5 RSHIFT ($operand_1, %operand_2) */
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u operand_1 %u",
operand_address, operand_1);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* %operand_2*/
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u operand_2 %u",
operand_address, operand_2);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## RSHIFT (operand_1=%u, operand_2=%u)",
current_address, operand_1, operand_2);
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* execute the instruction */
result = operand_1 >> operand_2;
lsb = result & 0xff;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
msb = result >> 8;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
buff[result_dest] = msb;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
buff[(result_dest+1) & 0xffff] = lsb;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
if (print_level_1 ){
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1," Loading result %u at %u",
result, result_dest);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
current_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
goto execute_next_instruction;
break;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
case SIGCOMP_INSTR_ADD: /* 6 ADD ($operand_1, %operand_2) */
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u operand_1 %u",
operand_address, operand_1);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* %operand_2*/
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u operand_2 %u",
operand_address, operand_2);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## ADD (operand_1=%u, operand_2=%u)",
current_address, operand_1, operand_2);
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* execute the instruction */
result = operand_1 + operand_2;
lsb = result & 0xff;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
msb = result >> 8;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
buff[result_dest] = msb;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
buff[(result_dest+1) & 0xffff] = lsb;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
if (print_level_1 ){
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1," Loading result %u at %u",
result, result_dest);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
current_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
goto execute_next_instruction;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
case SIGCOMP_INSTR_SUBTRACT: /* 7 SUBTRACT ($operand_1, %operand_2) */
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u operand_1 %u",
operand_address, operand_1);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* %operand_2*/
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u operand_2 %u",
operand_address, operand_2);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## SUBTRACT (operand_1=%u, operand_2=%u)",
current_address, operand_1, operand_2);
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* execute the instruction */
result = operand_1 - operand_2;
lsb = result & 0xff;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
msb = result >> 8;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
buff[result_dest] = msb;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
buff[(result_dest+1) & 0xffff] = lsb;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
if (print_level_1 ){
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1," Loading result %u at %u",
result, result_dest);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
current_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
goto execute_next_instruction;
break;
case SIGCOMP_INSTR_MULTIPLY: /* 8 MULTIPLY ($operand_1, %operand_2) */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u operand_1 %u",
operand_address, operand_1);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* %operand_2*/
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u operand_2 %u",
operand_address, operand_2);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## MULTIPLY (operand_1=%u, operand_2=%u)",
current_address, operand_1, operand_2);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 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;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
msb = result >> 8;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
buff[result_dest] = msb;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
buff[(result_dest+1) & 0xffff] = lsb;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
if (print_level_1 ){
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1," Loading result %u at %u",
result, result_dest);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
current_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
goto execute_next_instruction;
break;
case SIGCOMP_INSTR_DIVIDE: /* 9 DIVIDE ($operand_1, %operand_2) */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u operand_1 %u",
operand_address, operand_1);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* %operand_2*/
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u operand_2 %u",
operand_address, operand_2);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## DIVIDE (operand_1=%u, operand_2=%u)",
current_address, operand_1, operand_2);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 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;
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
result = operand_1 / operand_2;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
lsb = result & 0xff;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
msb = result >> 8;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
buff[result_dest] = msb;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
buff[(result_dest+1) & 0xffff] = lsb;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
if (print_level_1 ){
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1," Loading result %u at %u",
result, result_dest);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
current_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
goto execute_next_instruction;
break;
case SIGCOMP_INSTR_REMAINDER: /* 10 REMAINDER ($operand_1, %operand_2) */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u operand_1 %u",
operand_address, operand_1);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* %operand_2*/
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u operand_2 %u",
operand_address, operand_2);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## REMAINDER (operand_1=%u, operand_2=%u)",
current_address, operand_1, operand_2);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 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;
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
result = operand_1 - operand_2 * (operand_1 / operand_2);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
lsb = result & 0xff;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
msb = result >> 8;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
buff[result_dest] = msb;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
buff[(result_dest+1) & 0xffff] = lsb;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
if (print_level_1 ){
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1," Loading result %u at %u",
result, result_dest);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
current_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* %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);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
current_address = next_operand_address;
Increment the cycle count no matter what. Increase the cycle count further when SIGCOMP_INSTR_INPUT_BYTES fails. Fixes the infinite loop found in bug 4826. svn path=/trunk/; revision=33061
2010-06-02 22:16:49 +00:00
used_udvm_cycles = used_udvm_cycles + length;
From Timo Metsala Changes: o Implemented CRC and SHA-1 (sort operations are still missing) o After state acccess, the execution start is not necessarily the beginning of the bytecode; start IP is now a new parameter to decompress_sigcomp_message() o Removed some hard-coded assumptions about bytecode starting at offset 128 svn path=/trunk/; revision=15531
2005-08-25 19:23:15 +00:00
n = 0;
k = position;
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, 0, -1,
"byte_copy_right = %u", byte_copy_right);
}
sha1_starts( &ctx );
while (n<length) {
guint16 handle_now = length;
if ( k < byte_copy_right && byte_copy_right <= k + (length-n) ){
handle_now = byte_copy_right - position;
}
Throw an exception instead of trying to read past the end of a buffer. Fixes bug 455. svn path=/trunk/; revision=15876
2005-09-19 20:50:10 +00:00
if (k + handle_now >= UDVM_MEMORY_SIZE)
Be more paranoid about buffer overruns. svn path=/trunk/; revision=15901
2005-09-20 17:26:43 +00:00
goto decompression_failure;
From Timo Metsala Changes: o Implemented CRC and SHA-1 (sort operations are still missing) o After state acccess, the execution start is not necessarily the beginning of the bytecode; start IP is now a new parameter to decompress_sigcomp_message() o Removed some hard-coded assumptions about bytecode starting at offset 128 svn path=/trunk/; revision=15531
2005-08-25 19:23:15 +00:00
sha1_update( &ctx, &buff[k], handle_now );
k = ( k + handle_now ) & 0xffff;
n = ( n + handle_now ) & 0xffff;
if ( k >= byte_copy_right ) {
k = byte_copy_left;
}
}
sha1_finish( &ctx, sha1_digest_buf );
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
k = ref_destination;
From Timo Metsala Changes: o Implemented CRC and SHA-1 (sort operations are still missing) o After state acccess, the execution start is not necessarily the beginning of the bytecode; start IP is now a new parameter to decompress_sigcomp_message() o Removed some hard-coded assumptions about bytecode starting at offset 128 svn path=/trunk/; revision=15531
2005-08-25 19:23:15 +00:00
Add bounds checking in several places to the SigComp UDVM. Use memset() instead of while loops to initialize variables. Use a define instead of magic numbers. Don't use guint8s for counters. Add a corresponding entry to the release notes. svn path=/trunk/; revision=15715
2005-09-07 20:09:40 +00:00
for ( n=0; n< STATE_BUFFER_SIZE; n++ ) {
From Timo Metsala Changes: o Implemented CRC and SHA-1 (sort operations are still missing) o After state acccess, the execution start is not necessarily the beginning of the bytecode; start IP is now a new parameter to decompress_sigcomp_message() o Removed some hard-coded assumptions about bytecode starting at offset 128 svn path=/trunk/; revision=15531
2005-08-25 19:23:15 +00:00
buff[k] = sha1_digest_buf[n];
k = ( k + 1 ) & 0xffff;
n++;
if ( k == byte_copy_right ){
k = byte_copy_left;
}
}
if (print_level_2 ){
proto_tree_add_text(udvm_tree, message_tvb, 0, -1,
"Calculated SHA-1: %s",
Add bounds checking in several places to the SigComp UDVM. Use memset() instead of while loops to initialize variables. Use a define instead of magic numbers. Don't use guint8s for counters. Add a corresponding entry to the release notes. svn path=/trunk/; revision=15715
2005-09-07 20:09:40 +00:00
bytes_to_str(sha1_digest_buf, STATE_BUFFER_SIZE));
From Timo Metsala Changes: o Implemented CRC and SHA-1 (sort operations are still missing) o After state acccess, the execution start is not necessarily the beginning of the bytecode; start IP is now a new parameter to decompress_sigcomp_message() o Removed some hard-coded assumptions about bytecode starting at offset 128 svn path=/trunk/; revision=15531
2005-08-25 19:23:15 +00:00
}
current_address = next_operand_address;
goto execute_next_instruction;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
break;
case SIGCOMP_INSTR_LOAD: /* 14 LOAD (%address, %value) */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## LOAD(14) (%%address, %%value)",
current_address);
}
operand_address = current_address + 1;
/* %address */
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &addr);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u Address %u",
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
operand_address, addr);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* %value */
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &value);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## LOAD (%%address=%u, %%value=%u)",
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
current_address, addr, value);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
lsb = value & 0xff;
msb = value >> 8;
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
buff[addr] = msb;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
buff[(addr + 1) & 0xffff] = lsb;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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",
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
addr, value, value);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
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.
*/
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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 */
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &addr);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u Address %u",
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
operand_address, addr);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* #n */
next_operand_address = decode_udvm_literal_operand(buff,operand_address, &n);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u n %u",
operand_address, n);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## MULTILOAD (%%address=%u, #n=%u, value_0, ..., value_%d)",
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
current_address, addr, n, n-1);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Increment the cycle count no matter what. Increase the cycle count further when SIGCOMP_INSTR_INPUT_BYTES fails. Fixes the infinite loop found in bug 4826. svn path=/trunk/; revision=33061
2010-06-02 22:16:49 +00:00
used_udvm_cycles = used_udvm_cycles + n;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
while ( n > 0) {
n = n - 1;
/* %value */
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &value);
lsb = value & 0xff;
msb = value >> 8;
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
if (addr >= UDVM_MEMORY_SIZE - 1)
Be more paranoid about buffer overruns. svn path=/trunk/; revision=15901
2005-09-20 17:26:43 +00:00
goto decompression_failure;
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
buff[addr] = msb;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
buff[(addr + 1) & 0xffff] = lsb;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* debug
*/
length = next_operand_address - operand_address;
if (print_level_1 ){
From Timo Metsala Changes: o Implemented CRC and SHA-1 (sort operations are still missing) o After state acccess, the execution start is not necessarily the beginning of the bytecode; start IP is now a new parameter to decompress_sigcomp_message() o Removed some hard-coded assumptions about bytecode starting at offset 128 svn path=/trunk/; revision=15531
2005-08-25 19:23:15 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1, "Addr: %u Value %5u - Loading bytes at %5u Value %5u 0x%x",
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
operand_address, value, addr, value, value);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
addr = addr + 2;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
current_address = next_operand_address;
goto execute_next_instruction;
break;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
case SIGCOMP_INSTR_PUSH: /* 16 PUSH (%value) */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u Value %u",
operand_address, value);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## PUSH (value=%u)",
current_address, value);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
current_address = next_operand_address;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/* Push the value address onto the stack */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
stack_location = (buff[70] << 8) | buff[71];
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
stack_fill = (buff[stack_location] << 8)
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
| buff[(stack_location+1) & 0xFFFF];
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
addr = (stack_location + stack_fill * 2 + 2) & 0xFFFF;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
if (addr >= UDVM_MEMORY_SIZE - 1)
Be more paranoid about buffer overruns. svn path=/trunk/; revision=15901
2005-09-20 17:26:43 +00:00
goto decompression_failure;
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
buff[addr] = (value >> 8) & 0x00FF;
buff[(addr+1) & 0xFFFF] = value & 0x00FF;
Be more paranoid about buffer overruns. svn path=/trunk/; revision=15901
2005-09-20 17:26:43 +00:00
if (stack_location >= UDVM_MEMORY_SIZE - 1)
goto decompression_failure;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
stack_fill = (stack_fill + 1) & 0xFFFF;
buff[stack_location] = (stack_fill >> 8) & 0x00FF;
buff[(stack_location+1) & 0xFFFF] = stack_fill & 0x00FF;
goto execute_next_instruction;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
break;
case SIGCOMP_INSTR_POP: /* 17 POP (%address) */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
"Addr: %u ## POP(16) (value)",
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
current_address);
}
operand_address = current_address + 1;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
/* %value */
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &destination);
if (show_instr_detail_level == 2){
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u Value %u",
operand_address, destination);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## POP (address=%u)",
current_address, destination);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
current_address = next_operand_address;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/* Pop value from the top of the stack */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
stack_location = (buff[70] << 8) | buff[71];
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
stack_fill = (buff[stack_location] << 8)
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
| buff[(stack_location+1) & 0xFFFF];
if (stack_fill == 0)
{
result_code = 16;
goto decompression_failure;
}
Be more paranoid about buffer overruns. svn path=/trunk/; revision=15901
2005-09-20 17:26:43 +00:00
if (stack_location >= UDVM_MEMORY_SIZE - 1)
goto decompression_failure;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
stack_fill = (stack_fill - 1) & 0xFFFF;
buff[stack_location] = (stack_fill >> 8) & 0x00FF;
buff[(stack_location+1) & 0xFFFF] = stack_fill & 0x00FF;
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
addr = (stack_location + stack_fill * 2 + 2) & 0xFFFF;
Fix a bug reported by coverity. svn path=/trunk/; revision=17490
2006-03-07 06:15:06 +00:00
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
if (addr >= UDVM_MEMORY_SIZE - 1)
Be more paranoid about buffer overruns. svn path=/trunk/; revision=15901
2005-09-20 17:26:43 +00:00
goto decompression_failure;
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
value = (buff[addr] << 8)
| buff[(addr+1) & 0xFFFF];
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
/* ... and store the popped value. */
Be more paranoid about buffer overruns. svn path=/trunk/; revision=15901
2005-09-20 17:26:43 +00:00
if (destination >= UDVM_MEMORY_SIZE - 1)
goto decompression_failure;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
buff[destination] = (value >> 8) & 0x00FF;
buff[(destination+1) & 0xFFFF] = value & 0x00FF;
goto execute_next_instruction;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
break;
case SIGCOMP_INSTR_COPY: /* 18 COPY (%position, %length, %destination) */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u position %u",
operand_address, position);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* %length */
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u Destination %u",
operand_address, destination);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## COPY (position=%u, length=%u, destination=%u)",
current_address, position, length, destination);
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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
*
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*/
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
n = 0;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
k = destination;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
byte_copy_right = buff[66] << 8;
byte_copy_right = byte_copy_right | buff[67];
Bugfixes svn path=/trunk/; revision=12613
2004-11-28 19:39:19 +00:00
byte_copy_left = buff[64] << 8;
byte_copy_left = byte_copy_left | buff[65];
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (print_level_2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
" byte_copy_right = %u", byte_copy_right);
}
while ( n < length ){
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
buff[k] = buff[position];
if (print_level_2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
" Copying value: %u (0x%x) to Addr: %u",
buff[position], buff[position], k);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
position = ( position + 1 ) & 0xffff;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
k = ( k + 1 ) & 0xffff;
n++;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
/*
* Check for circular buffer wrapping after the positions are
* incremented. If either started at BCR then they should continue
* to increment beyond BCR.
*/
if ( k == byte_copy_right ){
k = byte_copy_left;
}
if ( position == byte_copy_right ){
position = byte_copy_left;
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
Increment the cycle count no matter what. Increase the cycle count further when SIGCOMP_INSTR_INPUT_BYTES fails. Fixes the infinite loop found in bug 4826. svn path=/trunk/; revision=33061
2010-06-02 22:16:49 +00:00
used_udvm_cycles = used_udvm_cycles + length;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
goto execute_next_instruction;
break;
case SIGCOMP_INSTR_COPY_LITERAL: /* 19 COPY-LITERAL (%position, %length, $destination) */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u position %u",
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
operand_address, position);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* %length */
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u destination %u",
operand_address, ref_destination);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## COPY-LITERAL (position=%u, length=%u, $destination=%u)",
Print correct destination for SIGCOMP_INSTR_COPY_LITERAL. svn path=/trunk/; revision=30206
2009-09-29 20:59:30 +00:00
current_address, position, length, ref_destination);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
current_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/*
* 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
*
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*/
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
n = 0;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
k = ref_destination;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
byte_copy_right = buff[66] << 8;
byte_copy_right = byte_copy_right | buff[67];
Bugfixes svn path=/trunk/; revision=12613
2004-11-28 19:39:19 +00:00
byte_copy_left = buff[64] << 8;
byte_copy_left = byte_copy_left | buff[65];
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (print_level_2 ){
Bugfixes svn path=/trunk/; revision=12613
2004-11-28 19:39:19 +00:00
proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
" byte_copy_right = %u", byte_copy_right);
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
while ( n < length ){
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
buff[k] = buff[position];
if (print_level_2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
" Copying value: %u (0x%x) to Addr: %u",
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
buff[position], buff[position], k);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
position = ( position + 1 ) & 0xffff;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
k = ( k + 1 ) & 0xffff;
n++;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
/*
* Check for circular buffer wrapping after the positions are
* incremented. It is important that k cannot be left set
* to BCR. Also, if either started at BCR then they should continue
* to increment beyond BCR.
*/
if ( k == byte_copy_right ){
k = byte_copy_left;
}
if ( position == byte_copy_right ){
position = byte_copy_left;
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
buff[result_dest] = k >> 8;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
buff[(result_dest + 1) & 0xffff] = k & 0x00ff;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
Increment the cycle count no matter what. Increase the cycle count further when SIGCOMP_INSTR_INPUT_BYTES fails. Fixes the infinite loop found in bug 4826. svn path=/trunk/; revision=33061
2010-06-02 22:16:49 +00:00
used_udvm_cycles = used_udvm_cycles + length;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
goto execute_next_instruction;
break;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
case SIGCOMP_INSTR_COPY_OFFSET: /* 20 COPY-OFFSET (%offset, %length, $destination) */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u offset %u",
operand_address, multy_offset);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* %length */
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u $destination %u",
operand_address, ref_destination);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## COPY-OFFSET (offset=%u, length=%u, $destination=%u)",
current_address, multy_offset, length, result_dest);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
current_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* 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.
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 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];
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
/*
* In order to work out the position, simple arithmetic is tricky
* to apply because there some nasty corner cases. A simple loop
* is inefficient but the logic is simple.
*
* FUTURE: This could be optimised.
*/
for (position = ref_destination, i = 0; i < multy_offset; i++)
{
if ( position == byte_copy_left )
{
position = (byte_copy_right - 1) & 0xffff;
}
else
{
position = (position - 1) & 0xffff;
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (print_level_2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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
*
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*/
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
n = 0;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
k = ref_destination;
Bugfixes svn path=/trunk/; revision=12613
2004-11-28 19:39:19 +00:00
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);
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
while ( n < length ){
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
buff[k] = buff[position];
if (print_level_2 ){
proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
" Copying value: %5u (0x%x) from Addr: %u to Addr: %u",
buff[position], buff[position],(position), k);
}
n++;
k = ( k + 1 ) & 0xffff;
position = ( position + 1 ) & 0xffff;
/*
* Check for circular buffer wrapping after the positions are
* incremented. It is important that k cannot be left set
* to BCR. Also, if either started at BCR then they should continue
* to increment beyond BCR.
*/
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
if ( k == byte_copy_right ){
k = byte_copy_left;
}
if ( position == byte_copy_right ){
position = byte_copy_left;
}
}
buff[result_dest] = k >> 8;
buff[result_dest + 1] = k & 0x00ff;
Increment the cycle count no matter what. Increase the cycle count further when SIGCOMP_INSTR_INPUT_BYTES fails. Fixes the infinite loop found in bug 4826. svn path=/trunk/; revision=33061
2010-06-02 22:16:49 +00:00
used_udvm_cycles = used_udvm_cycles + length;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
goto execute_next_instruction;
break;
case SIGCOMP_INSTR_MEMSET: /* 21 MEMSET (%address, %length, %start_value, %offset) */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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 */
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &addr);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u Address %u",
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
operand_address, addr);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* %length, */
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u start_value %u",
operand_address, start_value);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* %offset */
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &multy_offset);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u offset %u",
operand_address, multy_offset);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## MEMSET (address=%u, length=%u, start_value=%u, offset=%u)",
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
current_address, addr, length, start_value, multy_offset);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
current_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* exetute the instruction
* The sequence of values used by the MEMSET instruction is specified by
* the following formula:
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* Seq[n] := (start_value + n * offset) modulo 256
*/
n = 0;
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
k = addr;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
byte_copy_right = buff[66] << 8;
byte_copy_right = byte_copy_right | buff[67];
Bugfixes svn path=/trunk/; revision=12613
2004-11-28 19:39:19 +00:00
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);
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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 */
Increment the cycle count no matter what. Increase the cycle count further when SIGCOMP_INSTR_INPUT_BYTES fails. Fixes the infinite loop found in bug 4826. svn path=/trunk/; revision=33061
2010-06-02 22:16:49 +00:00
used_udvm_cycles = used_udvm_cycles + length;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
goto execute_next_instruction;
break;
case SIGCOMP_INSTR_JUMP: /* 22 JUMP (@address) */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u @Address %u",
operand_address, at_address);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## JUMP (@address=%u)",
current_address, at_address);
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
current_address = at_address;
goto execute_next_instruction;
break;
case SIGCOMP_INSTR_COMPARE: /* 23 */
/* COMPARE (%value_1, %value_2, @address_1, @address_2, @address_3)
*/
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u @Address %u",
operand_address, at_address_3);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## COMPARE (value_1=%u, value_2=%u, @address_1=%u, @address_2=%u, @address_3=%u)",
current_address, value_1, value_2, at_address_1, at_address_2, at_address_3);
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* 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;
goto execute_next_instruction;
break;
case SIGCOMP_INSTR_CALL: /* 24 CALL (@address) (PUSH addr )*/
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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 */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
next_operand_address = decode_udvm_address_operand(buff,operand_address, &at_address, current_address);
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u @Address %u",
operand_address, at_address);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## CALL (@address=%u)",
current_address, at_address);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
current_address = next_operand_address;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/* Push the current address onto the stack */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
stack_location = (buff[70] << 8) | buff[71];
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
stack_fill = (buff[stack_location] << 8)
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
| buff[(stack_location+1) & 0xFFFF];
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
addr = (stack_location + stack_fill * 2 + 2) & 0xFFFF;
if (addr >= UDVM_MEMORY_SIZE - 1)
Be more paranoid about buffer overruns. svn path=/trunk/; revision=15901
2005-09-20 17:26:43 +00:00
goto decompression_failure;
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
buff[addr] = (current_address >> 8) & 0x00FF;
buff[(addr+1) & 0xFFFF] = current_address & 0x00FF;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
stack_fill = (stack_fill + 1) & 0xFFFF;
Be more paranoid about buffer overruns. svn path=/trunk/; revision=15901
2005-09-20 17:26:43 +00:00
if (stack_location >= UDVM_MEMORY_SIZE - 1)
goto decompression_failure;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
buff[stack_location] = (stack_fill >> 8) & 0x00FF;
buff[(stack_location+1) & 0xFFFF] = stack_fill & 0x00FF;
/* ... and jump to the destination address */
current_address = at_address;
goto execute_next_instruction;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
break;
case SIGCOMP_INSTR_RETURN: /* 25 POP and return */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (print_level_1 || show_instr_detail_level == 1){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## POP(25) and return",
current_address);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/* Pop value from the top of the stack */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
stack_location = (buff[70] << 8) | buff[71];
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
stack_fill = (buff[stack_location] << 8)
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
| buff[(stack_location+1) & 0xFFFF];
if (stack_fill == 0)
{
result_code = 16;
goto decompression_failure;
}
stack_fill = (stack_fill - 1) & 0xFFFF;
Be more paranoid about buffer overruns. svn path=/trunk/; revision=15901
2005-09-20 17:26:43 +00:00
if (stack_location >= UDVM_MEMORY_SIZE - 1)
goto decompression_failure;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
buff[stack_location] = (stack_fill >> 8) & 0x00FF;
buff[(stack_location+1) & 0xFFFF] = stack_fill & 0x00FF;
Fix various gcc -Wshadow warnings. svn path=/trunk/; revision=31720
2010-01-28 18:45:46 +00:00
addr = (stack_location + stack_fill * 2 + 2) & 0xFFFF;
at_address = (buff[addr] << 8)
| buff[(addr+1) & 0xFFFF];
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
/* ... and set the PC to the popped value */
current_address = at_address;
goto execute_next_instruction;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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.
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 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;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/* #n
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 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);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* %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;
}
Increment the cycle count no matter what. Increase the cycle count further when SIGCOMP_INSTR_INPUT_BYTES fails. Fixes the infinite loop found in bug 4826. svn path=/trunk/; revision=33061
2010-06-02 22:16:49 +00:00
used_udvm_cycles = used_udvm_cycles + n;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
}
From Timo Metsala Changes: o Implemented CRC and SHA-1 (sort operations are still missing) o After state acccess, the execution start is not necessarily the beginning of the bytecode; start IP is now a new parameter to decompress_sigcomp_message() o Removed some hard-coded assumptions about bytecode starting at offset 128 svn path=/trunk/; revision=15531
2005-08-25 19:23:15 +00:00
operand_address = current_address + 1;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* %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);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
From Timo Metsala Changes: o Implemented CRC and SHA-1 (sort operations are still missing) o After state acccess, the execution start is not necessarily the beginning of the bytecode; start IP is now a new parameter to decompress_sigcomp_message() o Removed some hard-coded assumptions about bytecode starting at offset 128 svn path=/trunk/; revision=15531
2005-08-25 19:23:15 +00:00
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* %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);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* %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 */
Increment the cycle count no matter what. Increase the cycle count further when SIGCOMP_INSTR_INPUT_BYTES fails. Fixes the infinite loop found in bug 4826. svn path=/trunk/; revision=33061
2010-06-02 22:16:49 +00:00
used_udvm_cycles = used_udvm_cycles + length;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
From Timo Metsala Changes: o Implemented CRC and SHA-1 (sort operations are still missing) o After state acccess, the execution start is not necessarily the beginning of the bytecode; start IP is now a new parameter to decompress_sigcomp_message() o Removed some hard-coded assumptions about bytecode starting at offset 128 svn path=/trunk/; revision=15531
2005-08-25 19:23:15 +00:00
n = 0;
k = position;
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];
result = 0;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
From Timo Metsala Changes: o Implemented CRC and SHA-1 (sort operations are still missing) o After state acccess, the execution start is not necessarily the beginning of the bytecode; start IP is now a new parameter to decompress_sigcomp_message() o Removed some hard-coded assumptions about bytecode starting at offset 128 svn path=/trunk/; revision=15531
2005-08-25 19:23:15 +00:00
if (print_level_2 ){
proto_tree_add_text(udvm_tree, message_tvb, 0, -1,
"byte_copy_right = %u", byte_copy_right);
}
while (n<length) {
guint16 handle_now = length - n;
if ( k < byte_copy_right && byte_copy_right <= k + (length-n) ){
handle_now = byte_copy_right - k;
}
Throw an exception instead of trying to read past the end of a buffer. Fixes bug 455. svn path=/trunk/; revision=15876
2005-09-19 20:50:10 +00:00
if (k + handle_now >= UDVM_MEMORY_SIZE)
Be more paranoid about buffer overruns. svn path=/trunk/; revision=15901
2005-09-20 17:26:43 +00:00
goto decompression_failure;
Bill Meier: Spelling fixes. svn path=/trunk/; revision=16956
2006-01-05 13:01:08 +00:00
result = crc16_ccitt_seed(&buff[k], handle_now, (guint16) (result ^ 0xffff));
From Timo Metsala Changes: o Implemented CRC and SHA-1 (sort operations are still missing) o After state acccess, the execution start is not necessarily the beginning of the bytecode; start IP is now a new parameter to decompress_sigcomp_message() o Removed some hard-coded assumptions about bytecode starting at offset 128 svn path=/trunk/; revision=15531
2005-08-25 19:23:15 +00:00
k = ( k + handle_now ) & 0xffff;
n = ( n + handle_now ) & 0xffff;
if ( k >= byte_copy_right ) {
k = byte_copy_left;
}
}
result = result ^ 0xffff;
if (print_level_1 ){
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1, "Calculated CRC %u", result);
}
if (result != value){
current_address = at_address;
}
else {
current_address = next_operand_address;
}
goto execute_next_instruction;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
break;
case SIGCOMP_INSTR_INPUT_BYTES: /* 28 INPUT-BYTES (%length, %destination, @address) */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## INPUT-BYTES(28) length, destination, @address)",
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
current_address);
}
operand_address = current_address + 1;
/* %length */
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u @Address %u",
operand_address, at_address);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## INPUT-BYTES length=%u, destination=%u, @address=%u)",
current_address, length, destination, at_address);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/* execute the instruction TODO insert checks
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* RFC 3320 :
*
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
* 0 7 8 15
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | byte_copy_left | 64 - 65
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | byte_copy_right | 66 - 67
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | input_bit_order | 68 - 69
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | stack_location | 70 - 71
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 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
*
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*/
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
n = 0;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
k = destination;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
byte_copy_right = buff[66] << 8;
byte_copy_right = byte_copy_right | buff[67];
Bugfixes svn path=/trunk/; revision=12613
2004-11-28 19:39:19 +00:00
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);
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* 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.
*/
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
k = ( k + 1 ) & 0xffff;
n++;
}
Increment the cycle count no matter what. Increase the cycle count further when SIGCOMP_INSTR_INPUT_BYTES fails. Fixes the infinite loop found in bug 4826. svn path=/trunk/; revision=33061
2010-06-02 22:16:49 +00:00
used_udvm_cycles = used_udvm_cycles + length;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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.
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 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.
*/
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u @Address %u",
operand_address, at_address);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## INPUT-BITS length=%u, destination=%u, @address=%u)",
current_address, length, destination, at_address);
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
current_address = next_operand_address;
/*
* Execute actual instr.
* The input_bit_order register contains the following three flags:
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 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 ( length > 16 ){
result_code = 7;
goto decompression_failure;
}
if ( input_bit_order > 7 ){
result_code = 8;
goto decompression_failure;
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/*
* Transfer F bit to bit_order to tell decomp dispatcher which bit order to use
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
*/
bit_order = ( input_bit_order & 0x0004 ) >> 2;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
value = decomp_dispatch_get_bits( message_tvb, udvm_tree, bit_order,
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
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;
Be more paranoid about buffer overruns. svn path=/trunk/; revision=15901
2005-09-20 17:26:43 +00:00
if (destination >= UDVM_MEMORY_SIZE - 1)
goto decompression_failure;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
buff[destination] = msb;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
buff[(destination + 1) & 0xffff]=lsb;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
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);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
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)
*/
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u n %u",
operand_address, n);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## INPUT-HUFFMAN (destination=%u, @address=%u, #n=%u, bits_1, lower_1,upper_1, unc_1, ... , bits_%d, lower_%d,upper_%d, unc_%d)",
current_address, destination, at_address, n, n, n, n, n);
}
Increment the cycle count no matter what. Increase the cycle count further when SIGCOMP_INSTR_INPUT_BYTES fails. Fixes the infinite loop found in bug 4826. svn path=/trunk/; revision=33061
2010-06-02 22:16:49 +00:00
used_udvm_cycles = used_udvm_cycles + n;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/*
* 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.
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* In all other cases, the behavior of the INPUT-HUFFMAN instruction is
* defined below:
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 1. Set j := 1 and set H := 0.
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 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.
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 3. Set H := H * 2^bits_j + k.
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 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.
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 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.
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 6. Copy (H + uncompressed_j - lower_bound_j) modulo 2^16 to the
* memory address specified by the destination operand.
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
*/
/*
* The input_bit_order register contains the following three flags:
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 0 7 8 15
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | reserved |F|H|P| 68 - 69
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
* Transfer H bit to bit_order to tell decomp dispatcher which bit order to use
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
*/
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;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
print_in_loop = print_level_3;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* %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);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* %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);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
operand_address = next_operand_address;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* %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 ) {
/*
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
* 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.
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
*/
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
k = decomp_dispatch_get_bits( message_tvb, udvm_tree, bit_order,
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
buff, &old_input_bit_order, &remaining_bits,
&input_bits, &input_address, bits_n, &result_code, msg_end);
if ( result_code == 11 ){
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
/*
* 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.
*/
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
current_address = at_address;
goto execute_next_instruction;
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/*
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
* 3. Set H := H * 2^bits_j + k.
* [In practice is a shift+OR operation.]
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
*/
oldH = H;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
H = (H << bits_n) | k;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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)",
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
H ,oldH, 1<<bits_n,k);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
/*
* 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;
Be more paranoid about buffer overruns. svn path=/trunk/; revision=15901
2005-09-20 17:26:43 +00:00
if (destination >= UDVM_MEMORY_SIZE - 1)
goto decompression_failure;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
buff[destination] = msb;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
buff[(destination + 1) & 0xffff]=lsb;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
if (print_level_1 ){
proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
" Loading H: %u (0x%x) at Addr: %u,j = %u remaining_bits: %u",
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
H, H, destination,( n - m + 1 ), remaining_bits);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
}
m = m - 1;
}
if ( outside_huffman_boundaries ) {
result_code = 10;
goto decompression_failure;
}
current_address = next_operand_address;
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)
*/
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* %partial_identifier_start
*/
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &p_id_start);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_length);
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u state_instruction %u",
operand_address, state_instruction);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## STATE-ACCESS(31) (partial_identifier_start=%u, partial_identifier_length=%u,state_begin=%u, state_length=%u, state_address=%u, state_instruction=%u)",
current_address, p_id_start, p_id_length, state_begin, state_length, state_address, state_instruction);
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
result_code = udvm_state_access(message_tvb, udvm_tree, buff, p_id_start, p_id_length, state_begin, &state_length,
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
&state_address, &state_instruction, hf_id);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
if ( result_code != 0 ){
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
goto decompression_failure;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
Increment the cycle count no matter what. Increase the cycle count further when SIGCOMP_INSTR_INPUT_BYTES fails. Fixes the infinite loop found in bug 4826. svn path=/trunk/; revision=33061
2010-06-02 22:16:49 +00:00
used_udvm_cycles = used_udvm_cycles + state_length;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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)
*/
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u state_retention_priority %u",
operand_address, state_retention_priority);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## STATE-CREATE(32) (state_length=%u, state_address=%u, state_instruction=%u,minimum_access_length=%u, state_retention_priority=%u)",
current_address, state_length, state_address, state_instruction,minimum_access_length, state_retention_priority);
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
goto decompression_failure;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
Add bounds checking in several places to the SigComp UDVM. Use memset() instead of while loops to initialize variables. Use a define instead of magic numbers. Don't use guint8s for counters. Add a corresponding entry to the release notes. svn path=/trunk/; revision=15715
2005-09-07 20:09:40 +00:00
if (( minimum_access_length < 6 ) || ( minimum_access_length > STATE_BUFFER_SIZE )){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
result_code = 1;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
goto decompression_failure;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
if ( state_retention_priority == 65535 ){
result_code = 13;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
goto decompression_failure;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
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;
Fix gcc 4.6 "set but not used [-Wunused-but-set-variable]" warnings svn path=/trunk/; revision=37600
2011-06-07 22:28:55 +00:00
/* state_state_retention_priority_buff[no_of_state_create] = state_retention_priority; */
Increment the cycle count no matter what. Increase the cycle count further when SIGCOMP_INSTR_INPUT_BYTES fails. Fixes the infinite loop found in bug 4826. svn path=/trunk/; revision=33061
2010-06-02 22:16:49 +00:00
used_udvm_cycles = used_udvm_cycles + state_length;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* Debug */
byte_copy_right = buff[66] << 8;
byte_copy_right = byte_copy_right | buff[67];
Bugfixes svn path=/trunk/; revision=12613
2004-11-28 19:39:19 +00:00
byte_copy_left = buff[64] << 8;
byte_copy_left = byte_copy_left | buff[65];
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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)",
Remove almost all of the casts I committed recently and in place of them, add -Wno-pointer-sign to CFLAGS when gcc will accept it. svn path=/trunk/; revision=21253
2007-03-28 21:55:11 +00:00
k,buff[k],buff[k],format_text(string, 1));
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
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)
*/
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* %partial_identifier_start
*/
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &p_id_start);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u partial_identifier_length %u",
operand_address, p_id_length);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## STATE-FREE (partial_identifier_start=%u, partial_identifier_length=%u)",
current_address, p_id_start, p_id_length);
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
current_address = next_operand_address;
/* Execute the instruction:
* TODO implement it
*/
udvm_state_free(buff,p_id_start,p_id_length);
goto execute_next_instruction;
break;
case SIGCOMP_INSTR_OUTPUT: /* 34 OUTPUT (%output_start, %output_length) */
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* %output_start
*/
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &output_start);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u output_start %u",
operand_address, output_start);
}
operand_address = next_operand_address;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* %output_length
*/
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &output_length);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u output_length %u",
operand_address, output_length);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## OUTPUT (output_start=%u, output_length=%u)",
current_address, output_start, output_length);
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
current_address = next_operand_address;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/*
* Execute instruction
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 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
*
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*/
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
n = 0;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
k = output_start;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
byte_copy_right = buff[66] << 8;
byte_copy_right = byte_copy_right | buff[67];
Bugfixes svn path=/trunk/; revision=12613
2004-11-28 19:39:19 +00:00
byte_copy_left = buff[64] << 8;
byte_copy_left = byte_copy_left | buff[65];
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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';
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",
Remove almost all of the casts I committed recently and in place of them, add -Wno-pointer-sign to CFLAGS when gcc will accept it. svn path=/trunk/; revision=21253
2007-03-28 21:55:11 +00:00
buff[k],buff[k],format_text(string,1), k,output_address);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
k = ( k + 1 ) & 0xffff;
output_address ++;
n++;
}
Increment the cycle count no matter what. Increase the cycle count further when SIGCOMP_INSTR_INPUT_BYTES fails. Fixes the infinite loop found in bug 4826. svn path=/trunk/; revision=33061
2010-06-02 22:16:49 +00:00
used_udvm_cycles = used_udvm_cycles + output_length;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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)
*/
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u state_instruction %u",
operand_address, state_instruction);
}
From Timo Metsala Changes: o Implemented CRC and SHA-1 (sort operations are still missing) o After state acccess, the execution start is not necessarily the beginning of the bytecode; start IP is now a new parameter to decompress_sigcomp_message() o Removed some hard-coded assumptions about bytecode starting at offset 128 svn path=/trunk/; revision=15531
2005-08-25 19:23:15 +00:00
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/*
* %minimum_access_length
*/
operand_address = next_operand_address;
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &minimum_access_length);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u minimum_access_length %u",
operand_address, minimum_access_length);
}
/*
* %state_retention_priority
*/
operand_address = next_operand_address;
next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_retention_priority);
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 2 ){
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u state_retention_priority %u",
operand_address, state_retention_priority);
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (show_instr_detail_level == 1)
{
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
"Addr: %u ## END-MESSAGE (requested_feedback_location=%u, returned_parameters_location=%u, state_length=%u, state_address=%u, state_instruction=%u, minimum_access_length=%u, state_retention_priority=%u)",
current_address, requested_feedback_location, returned_parameters_location, state_length, state_address, state_instruction, minimum_access_length,state_retention_priority);
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
goto decompression_failure;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
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;
Fix gcc 4.6 "set but not used [-Wunused-but-set-variable]" warnings svn path=/trunk/; revision=37600
2011-06-07 22:28:55 +00:00
/* state_state_retention_priority_buff[no_of_state_create] = state_retention_priority; */
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* 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 ){
Add bounds checking in several places to the SigComp UDVM. Use memset() instead of while loops to initialize variables. Use a define instead of magic numbers. Don't use guint8s for counters. Add a corresponding entry to the release notes. svn path=/trunk/; revision=15715
2005-09-07 20:09:40 +00:00
memset(sha1_digest_buf, 0, STATE_BUFFER_SIZE);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
n = 1;
byte_copy_right = buff[66] << 8;
byte_copy_right = byte_copy_right | buff[67];
Bugfixes svn path=/trunk/; revision=12613
2004-11-28 19:39:19 +00:00
byte_copy_left = buff[64] << 8;
byte_copy_left = byte_copy_left | buff[65];
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
sha1buff[5] = state_instruction_buff[n] & 0xff;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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 ){
Add bounds checking in several places to the SigComp UDVM. Use memset() instead of while loops to initialize variables. Use a define instead of magic numbers. Don't use guint8s for counters. Add a corresponding entry to the release notes. svn path=/trunk/; revision=15715
2005-09-07 20:09:40 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"SHA1 digest %s",bytes_to_str(sha1_digest_buf, STATE_BUFFER_SIZE));
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/* begin partial state-id change cco@iptel.org */
From Cristian Constantin: As a workarond for the problem that accsessing a state with a state id > the stored minimum access length fail, only store and compare the state with the minimum access lengt specified in the standard of 6 bytes. svn path=/trunk/; revision=20041
2006-12-05 06:43:47 +00:00
#if 0
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
udvm_state_create(sha1buff, sha1_digest_buf, state_minimum_access_length_buff[n]);
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
#endif
From Cristian Constantin: As a workarond for the problem that accsessing a state with a state id > the stored minimum access length fail, only store and compare the state with the minimum access lengt specified in the standard of 6 bytes. svn path=/trunk/; revision=20041
2006-12-05 06:43:47 +00:00
udvm_state_create(sha1buff, sha1_digest_buf, STATE_MIN_ACCESS_LEN);
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/* end partial state-id change cco@iptel.org */
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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 */
Apply some of the patches from: http://wiki.wireshark.org/Development/Optimization svn path=/trunk/; revision=28365
2009-05-14 20:12:43 +00:00
decomp_tvb = tvb_new_child_real_data(message_tvb, out_buff,output_address,output_address);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* Arrange that the allocated packet data copy be freed when the
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
* tvbuff is freed.
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
*/
tvb_set_free_cb( decomp_tvb, g_free );
add_new_data_source(pinfo, decomp_tvb, "Decompressed SigComp message");
/*
proto_tree_add_text(udvm_tree, decomp_tvb, 0, -1,"SigComp message Decompressed");
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*/
Increment the cycle count no matter what. Increase the cycle count further when SIGCOMP_INSTR_INPUT_BYTES fails. Fixes the infinite loop found in bug 4826. svn path=/trunk/; revision=33061
2010-06-02 22:16:49 +00:00
used_udvm_cycles = used_udvm_cycles + state_length;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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:
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"DECOMPRESSION FAILURE: %s",
val_to_str(result_code, result_code_vals,"Unknown (%u)"));
Be more paranoid about buffer overruns. svn path=/trunk/; revision=15901
2005-09-20 17:26:43 +00:00
THROW(ReportedBoundsError);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
g_free(out_buff);
return NULL;
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* 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
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
decode_udvm_literal_operand(guint8 *buff,guint operand_address, guint16 *value)
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
{
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;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
temp_data = buff[(operand_address + 1) & 0xffff];
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
temp_data = buff[(operand_address + 1) & 0xffff];
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
dissect_udvm_reference_operand(guint8 *buff,guint operand_address, guint16 *value,guint *result_dest)
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
{
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;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
temp_data = buff[(operand_address + 1) & 0xffff];
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
operand = operand | temp_data;
operand = (operand * 2);
*result_dest = operand;
temp_data16 = buff[operand] << 8;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
temp_data16 = temp_data16 | buff[(operand+1) & 0xffff];
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
*value = temp_data16;
offset = offset + 2;
}else{
/*
* 11000000 nnnnnnnn nnnnnnnn memory[N] 0 - 65535
*/
operand_address++;
operand = buff[operand_address] << 8;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
operand = operand | buff[(operand_address + 1) & 0xffff];
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
*result_dest = operand;
temp_data16 = buff[operand] << 8;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
temp_data16 = temp_data16 | buff[(operand+1) & 0xffff];
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
*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;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
temp_data16 = temp_data16 | buff[(operand+1) & 0xffff];
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
*value = temp_data16;
offset ++;
}
I think this is the check that was intended.... svn path=/trunk/; revision=15919
2005-09-21 01:39:00 +00:00
if (offset >= UDVM_MEMORY_SIZE || *result_dest >= UDVM_MEMORY_SIZE - 1 )
Be more paranoid about buffer overruns. svn path=/trunk/; revision=15901
2005-09-20 17:26:43 +00:00
THROW(ReportedBoundsError);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
* 1000011n 2 ^ (N + 6) 64 , 128 0x86
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 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;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
*value = 0;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
bytecode = buff[operand_address];
test_bits = ( bytecode & 0xc0 ) >> 6;
switch (test_bits ){
case 0:
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 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:
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/*
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* 01nnnnnn memory[2 * N] 0 - 65535
*/
memmory_addr = ( bytecode & 0x3f) * 2;
temp_data16 = buff[memmory_addr] << 8;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
temp_data16 = temp_data16 | buff[(memmory_addr+1) & 0xffff];
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
*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;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
temp_data = buff[(operand_address + 1) & 0xffff];
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
temp_data = buff[(operand_address + 1) & 0xffff];
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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
*/
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
result = 1 << ((buff[operand_address] & 0x07) + 8);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
operand = result & 0xffff;
*value = operand;
offset ++;
}else{
test_bits = ( bytecode & 0x0e ) >> 1;
if ( test_bits == 3 ){
/*
* 1000 011n 2 ^ (N + 6) 64 , 128
*/
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
result = 1 << ((buff[operand_address] & 0x01) + 6);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
operand = result & 0xffff;
*value = operand;
offset ++;
}else{
/*
* 1000 0000 nnnnnnnn nnnnnnnn N 0 - 65535
* 1000 0001 nnnnnnnn nnnnnnnn memory[N] 0 - 65535
*/
offset ++;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
temp_data16 = buff[(operand_address + 1) & 0xffff] << 8;
temp_data16 = temp_data16 | buff[(operand_address + 2) & 0xffff];
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* 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;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
temp_data16 = temp_data16 | buff[(memmory_addr+1) & 0xffff];
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
*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;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
memmory_addr = memmory_addr | buff[(operand_address + 1) & 0xffff];
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
temp_data16 = buff[memmory_addr] << 8;
Make sure our addresses are modulo 2^16 in a lot of places. Fixes a crash found while fuzzing, and hopefully fixes bug 4867. In sigcomp_init_udvm() initialize the first 8 bytes of our buffers, which squelches a valgrind complaint. svn path=/trunk/; revision=33321
2010-06-25 17:14:41 +00:00
temp_data16 = temp_data16 | buff[(memmory_addr+1) & 0xffff];
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
*value = temp_data16;
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/* debug
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
* g_warning("Reading 0x%x From address %u",temp_data16,memmory_addr);
*/
offset = offset +2;
}
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
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;
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
/*
* This is a lookup table used to reverse the bits in a byte.
*/
static guint8 reverse [] = {
0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
};
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
static int
decomp_dispatch_get_bits(
tvbuff_t *message_tvb,
proto_tree *udvm_tree,
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
guint8 bit_order,
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
guint8 *buff,
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
guint16 *old_input_bit_order,
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
guint16 *remaining_bits,
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
guint16 *input_bits,
guint *input_address,
guint16 length,
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
guint16 *result_code,
guint msg_end)
{
guint16 input_bit_order;
guint16 bits_still_required = length;
guint16 value = 0;
guint8 octet;
gint extra_bytes_available = msg_end - *input_address;
gint p_bit;
gint prev_p_bit = *old_input_bit_order & 0x0001;
gint bits_to_use = 0;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
input_bit_order = buff[68] << 8;
input_bit_order = input_bit_order | buff[69];
*result_code = 0;
p_bit = (input_bit_order & 0x0001) != 0;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
/*
* Discard any spare bits.
* Note: We take care to avoid remaining_bits having the value of 8.
*/
if (prev_p_bit != p_bit)
{
*remaining_bits = 0;
*old_input_bit_order = input_bit_order;
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
/*
* Check we can suppy the required number of bits now, before we alter
* the input buffer's state.
*/
if (*remaining_bits + extra_bytes_available * 8 < length)
{
*result_code = 11;
return 0xfbad;
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/* Note: This is never called with length > 16, so the following loop
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
* never loops more than three time. */
while (bits_still_required > 0)
{
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
/*
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
* We only put anything into input_bits if we know we will remove
* at least one bit. That ensures we can simply discard the spare
* bits if the P-bit changes.
*/
if (*remaining_bits == 0)
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
{
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
octet = tvb_get_guint8(message_tvb, *input_address);
if (print_level_1 ){
proto_tree_add_text(udvm_tree, message_tvb, *input_address , 1,
Fix some typos and spelling (mostly in text strings) svn path=/trunk/; revision=27068
2008-12-20 01:01:28 +00:00
" Getting value: %u (0x%x) From Addr: %u", octet, octet, *input_address);
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
*input_address = *input_address + 1;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (p_bit != 0)
{
octet = reverse[octet];
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
}
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
*input_bits = octet;
*remaining_bits = 8;
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
/* Add some more bits to the accumulated value. */
bits_to_use = bits_still_required < *remaining_bits ? bits_still_required : *remaining_bits;
bits_still_required -= bits_to_use;
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
*input_bits <<= bits_to_use; /* Shift bits into MSByte */
value = (value << bits_to_use) /* Then add to the accumulated value */
| ((*input_bits >> 8) & 0xFF);
Move sha1.[ch] to epan/crypt/crypt-sha1.[ch]. Remove duplicate code. svn path=/trunk/; revision=20399
2007-01-12 00:33:32 +00:00
*remaining_bits -= bits_to_use;
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
*input_bits &= 0x00FF; /* Leave just the remaining bits */
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
if (bit_order != 0)
{
/* Bit reverse the entire word. */
guint16 lsb = reverse[(value >> 8) & 0xFF];
guint16 msb = reverse[value & 0xFF];
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
value = ((msb << 8) | lsb) >> (16 - length);
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
From Paul Ollis: epan/sigcomp_state_hdlr.c epan/sigcomp_state_hdlr.h --------------------------------------------------- Function udvm_state_access: 1. Removed the state_vars_valid parameter. It is no longer used. 2. The function now correctly updates each of state_length, state_address and state_instruction with saved state value. [Previously this was only done for state referenced in the SigComp message header.] 3. Removed code that (incorrectly) read byte_copy_left from UDVM memory within the loop that writes the state to UDVM memory. 4. Removed the code that set the useful values in UDVM memory. This should only be done for state referenced in the SigComp message header. (The decompress_sigcomp_message function, sets the useful values.) epan/sigcomp-udvm.c epan/sigcomp-udvm.h --------------------------------------- Function decompress_sigcomp_message: 1. Added three new parameters; header_len, byte_code_state_len, byte_code_id_len. The byte_code_state_len and byte_code_id_len are used to set the useful values in UDVM memory. The header_len is required to calculate the cycles available for decompression. 2. Various minor corrections to spellings, etc in generated messages. 3. Reduced the number of lines of output for print_level_1. Now the execution trace shows the instruction name and parameter values on one line. [This was done because, we found that even at the lowest level of detail ethereal became unusably slow; running on a 500 MHz SPARC. This seems to be related to the number of lines produced by the SigComp trace, which can easily be over 1000 with the modified code.] 4. Removed the used of some floating point functions. In all cases they were unnecessary and could potentially cause the code to produce the wrong results on some platforms (although this is unlikely). 5. The useful values are now set correctly, using the new byte_code_state_len and byte_code_id_len parameters. 6. The message header length is now included in the calculation of maximum_UDVM_cycles. Previously, the calculation could underestimate the value, resulting in the (small) chance that some legitimate messages might fail to decompress. Note: The calculation might now slightly over-estimate the cycles but this is a reasonable thing to do. 7. Implemented the PUSH, POP, CALL and RETURN instructions. Note: The two SORT instructions and the CRC and SHA-1 instructions are still not implemented. 8. The COPY and COPY-LITERAL instructions now apply the byte-copying-rules to the source address as well as the destination address. 9. The COPY-LITERAL and COPY-OFFSET now correctly handle the destination operand. Previously, it was possible for the destination to be left at byte_copy_right when it should be left at byte_copy_left. 10. All three COPY instructions will now behave correctly if the source or destination start at byte_copy_right; i.e. they read/write to byte_copy_right, byte_copy_right+1, etc. Previously the parameters would wrap to byte_copy_left. 11. The COPY-OFFSET instruction now correctly calculates the source address for all values of offset. Previously a very large offset (greater than the circular buffer size) could cause the starting position to be mis-calculated. 12. Modulo 65536 arithmetic has been added in some places where it was missing. [Only when noticed, we have not been able to check all the code.] 13. Some redundant code was removed for the INPUT-BITS instruction. Also, INPUT-BITS (0, x, x) now correctly discards spare bits when the P-bit, has changed. 14. Corrected the cycles used calculation for the INPUT-BITS instruction. 15. Corrected some minor cases where the used_udvm_cycles was not incremented. [Not really a problem, but it allowed us to verify correctness with some of the SigComp torture tests.] 16. Removed some redundant code in INPUT-HUFFMAN (and reorganised some comments to keep them making sense). Function decomp_dispatch_get_bits: 1. This has been rewritten. The original version could not correctly handle requests for more than 8 bits. The new version is cleaner and correctly handles all cases. svn path=/trunk/; revision=14666
2005-06-16 21:15:12 +00:00
return value;
}
Set svn properties - without them, compilation with gcc would fail on Unix svn path=/trunk/; revision=12597
2004-11-24 16:30:52 +00:00
/* end udvm */