| blob | cf0a96787f0dd48135982461fbfc533f7c995ba9 |
1 /* sigcomp-udvm.c
2 * Routines making up the Universal Decompressor Virtual Machine (UDVM) used for
3 * Signaling Compression (SigComp) dissection.
4 * Copyright 2004, Anders Broman <anders.broman@ericsson.com>
5 *
6 * $Id$
7 *
8 * Wireshark - Network traffic analyzer
9 * By Gerald Combs <gerald@wireshark.org>
10 * Copyright 1998 Gerald Combs
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
25 * References:
26 * http://www.ietf.org/rfc/rfc3320.txt?number=3320
27 * http://www.ietf.org/rfc/rfc3321.txt?number=3321
28 * Useful links :
29 * http://www.ietf.org/internet-drafts/draft-ietf-rohc-sigcomp-impl-guide-05.txt
30 * http://www.ietf.org/internet-drafts/draft-ietf-rohc-sigcomp-sip-01.txt
31 */
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <glib.h>
40 #include <epan/emem.h>
42 #include <wsutil/sha1.h>
43 #include <wsutil/crc16.h>
53 #define SIGCOMP_INSTR_DECOMPRESSION_FAILURE 0
54 #define SIGCOMP_INSTR_AND 1
55 #define SIGCOMP_INSTR_OR 2
56 #define SIGCOMP_INSTR_NOT 3
57 #define SIGCOMP_INSTR_LSHIFT 4
58 #define SIGCOMP_INSTR_RSHIFT 5
59 #define SIGCOMP_INSTR_ADD 6
60 #define SIGCOMP_INSTR_SUBTRACT 7
61 #define SIGCOMP_INSTR_MULTIPLY 8
62 #define SIGCOMP_INSTR_DIVIDE 9
63 #define SIGCOMP_INSTR_REMAINDER 10
64 #define SIGCOMP_INSTR_SORT_ASCENDING 11
65 #define SIGCOMP_INSTR_SORT_DESCENDING 12
66 #define SIGCOMP_INSTR_SHA_1 13
67 #define SIGCOMP_INSTR_LOAD 14
68 #define SIGCOMP_INSTR_MULTILOAD 15
69 #define SIGCOMP_INSTR_PUSH 16
70 #define SIGCOMP_INSTR_POP 17
71 #define SIGCOMP_INSTR_COPY 18
72 #define SIGCOMP_INSTR_COPY_LITERAL 19
73 #define SIGCOMP_INSTR_COPY_OFFSET 20
74 #define SIGCOMP_INSTR_MEMSET 21
75 #define SIGCOMP_INSTR_JUMP 22
76 #define SIGCOMP_INSTR_COMPARE 23
77 #define SIGCOMP_INSTR_CALL 24
78 #define SIGCOMP_INSTR_RETURN 25
79 #define SIGCOMP_INSTR_SWITCH 26
80 #define SIGCOMP_INSTR_CRC 27
81 #define SIGCOMP_INSTR_INPUT_BYTES 28
82 #define SIGCOMP_INSTR_INPUT_BITS 29
83 #define SIGCOMP_INSTR_INPUT_HUFFMAN 30
84 #define SIGCOMP_INSTR_STATE_ACCESS 31
85 #define SIGCOMP_INSTR_STATE_CREATE 32
86 #define SIGCOMP_INSTR_STATE_FREE 33
87 #define SIGCOMP_INSTR_OUTPUT 34
88 #define SIGCOMP_INSTR_END_MESSAGE 35
96 /* Internal result code values of decompression failures */
117 };
120 static int dissect_udvm_reference_operand(guint8 *buff,guint operand_address, guint16 *value, guint *result_dest);
122 static int decode_udvm_address_operand(guint8 *buff,guint operand_address, guint16 *value,guint current_address);
123 static int decomp_dispatch_get_bits(tvbuff_t *message_tvb,proto_tree *udvm_tree,guint8 bit_order,
128 tvbuff_t*
132 gint header_len,
134 gint udvm_start_ip)
135 {
137 /* UDVM memory must be initialised to zero */
144 guint16 x;
146 guint16 H;
147 guint16 oldH;
149 guint result_dest;
151 guint8 current_instruction;
152 guint current_address;
153 guint operand_address;
154 guint input_address;
156 guint next_operand_address;
157 guint8 octet;
158 guint8 msb;
159 guint8 lsb;
160 guint16 byte_copy_right;
161 guint16 byte_copy_left;
162 guint16 input_bit_order;
163 guint16 stack_location;
164 guint16 stack_fill;
165 guint16 result;
174 guint16 instruction_address;
180 /* guint16 state_state_retention_priority_buff[5]; */
182 guint cycles_per_bit;
183 guint maximum_UDVM_cycles;
186 sha1_context ctx;
189 /* UDVM operand variables */
190 guint16 length;
191 guint16 at_address;
192 guint16 destination;
193 guint16 addr;
194 guint16 value;
195 guint16 p_id_start;
196 guint16 p_id_length;
197 guint16 state_begin;
198 guint16 state_length;
199 guint16 state_address;
200 guint16 state_instruction;
201 guint16 operand_1;
202 guint16 operand_2;
203 guint16 value_1;
204 guint16 value_2;
205 guint16 at_address_1;
206 guint16 at_address_2;
207 guint16 at_address_3;
208 guint16 j;
209 guint16 bits_n;
210 guint16 lower_bound_n;
211 guint16 upper_bound_n;
212 guint16 uncompressed_n;
213 guint16 position;
215 guint16 multy_offset;
216 guint16 output_start;
217 guint16 output_length;
218 guint16 minimum_access_length;
219 guint16 state_retention_priority;
220 guint16 requested_feedback_location;
221 guint16 returned_parameters_location;
222 guint16 start_value;
225 /* Set print parameters */
256 }
258 /* Set initial UDVM data
259 * The first 32 bytes of UDVM memory are then initialized to special
260 * values as illustrated in Figure 5.
261 *
262 * 0 7 8 15
263 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
264 * | UDVM_memory_size | 0 - 1
265 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
266 * | cycles_per_bit | 2 - 3
267 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
268 * | SigComp_version | 4 - 5
269 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
270 * | partial_state_ID_length | 6 - 7
271 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
272 * | state_length | 8 - 9
273 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
274 * | |
275 * : reserved : 10 - 31
276 * | |
277 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
278 *
279 * Figure 5: Initializing Useful Values in UDVM memory
280 */
281 /* UDVM_memory_size */
284 /* cycles_per_bit */
287 /* SigComp_version */
290 /* partial_state_ID_length */
293 /* state_length */
301 /*
302 * maximum_UDVM_cycles = (8 * n + 1000) * cycles_per_bit
303 */
306 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);
307 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);
309 /* Load bytecode into UDVM starting at "udvm_mem_dest" */
312 proto_tree_add_text(udvm_tree, bytecode_tvb, offset, 1,"Load bytecode into UDVM starting at %u",i);
319 i++;
320 offset++;
322 }
323 /* Largest allowed size for a message is UDVM_MEMORY_SIZE = 65536 */
325 /* Start executing code */
329 proto_tree_add_text(udvm_tree, bytecode_tvb, offset, 1,"UDVM EXECUTION STARTED at Address: %u Message size %u",
332 execute_next_instruction:
337 }
338 used_udvm_cycles++;
347 current_address);
351 /* At least something got decompressed, show it */
353 /* Arrange that the allocated packet data copy be freed when the
354 * tvbuff is freed.
355 */
357 /* Add the tvbuff to the list of tvbuffs to which the tvbuff we
358 * were handed refers, so it'll get cleaned up when that tvbuff
359 * is cleaned up.
360 */
364 }
373 current_address);
374 }
375 /* $operand_1*/
377 next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &operand_1, &result_dest);
381 }
383 /* %operand_2*/
388 }
390 {
394 }
395 /* execute the instruction */
404 }
414 current_address);
415 }
416 /* $operand_1*/
418 next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &operand_1, &result_dest);
422 }
424 /* %operand_2*/
429 }
431 {
435 }
436 /* execute the instruction */
445 }
455 current_address);
456 }
457 /* $operand_1*/
459 next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &operand_1, &result_dest);
463 }
465 {
469 }
470 /* execute the instruction */
479 }
488 current_address);
489 }
490 /* $operand_1*/
492 next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &operand_1, &result_dest);
496 }
498 /* %operand_2*/
503 }
505 {
509 }
510 /* execute the instruction */
519 }
528 current_address);
529 }
530 /* $operand_1*/
532 next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &operand_1, &result_dest);
536 }
538 /* %operand_2*/
543 }
545 {
549 }
550 /* execute the instruction */
559 }
567 current_address);
568 }
569 /* $operand_1*/
571 next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &operand_1, &result_dest);
575 }
577 /* %operand_2*/
582 }
584 {
588 }
589 /* execute the instruction */
598 }
606 current_address);
607 }
608 /* $operand_1*/
610 next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &operand_1, &result_dest);
614 }
616 /* %operand_2*/
621 }
623 {
627 }
628 /* execute the instruction */
637 }
646 current_address);
647 }
648 /* $operand_1*/
650 next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &operand_1, &result_dest);
654 }
656 /* %operand_2*/
661 }
663 {
667 }
668 /*
669 * execute the instruction
670 * MULTIPLY (m, n) := m * n (modulo 2^16)
671 */
675 }
684 }
693 current_address);
694 }
695 /* $operand_1*/
697 next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &operand_1, &result_dest);
701 }
703 /* %operand_2*/
708 }
710 {
714 }
715 /*
716 * execute the instruction
717 * DIVIDE (m, n) := floor(m / n)
718 * Decompression failure occurs if a DIVIDE or REMAINDER instruction
719 * encounters an operand_2 that is zero.
720 */
724 }
733 }
742 current_address);
743 }
744 /* $operand_1*/
746 next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &operand_1, &result_dest);
750 }
752 /* %operand_2*/
757 }
759 {
763 }
764 /*
765 * execute the instruction
766 * REMAINDER (m, n) := m - n * floor(m / n)
767 * Decompression failure occurs if a DIVIDE or REMAINDER instruction
768 * encounters an operand_2 that is zero.
769 */
773 }
782 }
787 /*
788 * used_udvm_cycles = 1 + k * (ceiling(log2(k)) + n)
789 */
793 current_address);
794 }
795 proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Execution of this instruction is NOT implemented");
796 /*
797 * used_udvm_cycles = 1 + k * (ceiling(log2(k)) + n)
798 */
805 current_address);
806 }
807 proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Execution of this instruction is NOT implemented");
808 /*
809 * used_udvm_cycles = 1 + k * (ceiling(log2(k)) + n)
810 */
816 current_address);
817 }
819 /* %position */
824 }
827 /* %length */
832 }
835 /* $destination */
836 next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &ref_destination, &result_dest);
840 }
853 }
862 }
873 }
874 }
885 n++;
889 }
890 }
896 }
906 current_address);
907 }
909 /* %address */
914 }
916 /* %value */
919 {
923 }
935 }
941 /* RFC 3320:
942 * The MULTILOAD instruction sets a contiguous block of 2-byte words in
943 * the UDVM memory to specified values.
944 * Hmm what if the value to load only takes one byte ? Chose to always load two bytes.
945 */
949 current_address);
950 }
952 /* %address */
957 }
960 /* #n */
965 }
967 {
971 }
976 /* %value */
986 /* debug
987 */
991 proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1, "Addr: %u Value %5u - Loading bytes at %5u Value %5u 0x%x",
993 }
996 }
1006 current_address);
1007 }
1009 /* %value */
1014 }
1016 {
1020 }
1023 /* Push the value address onto the stack */
1050 current_address);
1051 }
1053 /* %value */
1058 }
1060 {
1064 }
1067 /* Pop value from the top of the stack */
1072 {
1075 }
1092 /* ... and store the popped value. */
1106 current_address);
1107 }
1109 /* %position */
1114 }
1117 /* %length */
1122 }
1125 /* %destination */
1130 }
1132 {
1136 }
1138 /*
1139 * 8.4. Byte copying
1140 * :
1141 * The string of bytes is copied in ascending order of memory address,
1142 * respecting the bounds set by byte_copy_left and byte_copy_right.
1143 * More precisely, if a byte is copied from/to Address m then the next
1144 * byte is copied from/to Address n where n is calculated as follows:
1145 *
1146 * Set k := m + 1 (modulo 2^16)
1147 * If k = byte_copy_right then set n := byte_copy_left, else set n := k
1148 *
1149 */
1160 }
1168 }
1171 n++;
1173 /*
1174 * Check for circular buffer wrapping after the positions are
1175 * incremented. If either started at BCR then they should continue
1176 * to increment beyond BCR.
1177 */
1180 }
1183 }
1184 }
1193 current_address);
1194 }
1196 /* %position */
1201 }
1204 /* %length */
1209 }
1213 /* $destination */
1214 next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &ref_destination, &result_dest);
1218 }
1220 {
1224 }
1228 /*
1229 * 8.4. Byte copying
1230 * :
1231 * The string of bytes is copied in ascending order of memory address,
1232 * respecting the bounds set by byte_copy_left and byte_copy_right.
1233 * More precisely, if a byte is copied from/to Address m then the next
1234 * byte is copied from/to Address n where n is calculated as follows:
1235 *
1236 * Set k := m + 1 (modulo 2^16)
1237 * If k = byte_copy_right then set n := byte_copy_left, else set n := k
1238 *
1239 */
1250 }
1258 }
1261 n++;
1263 /*
1264 * Check for circular buffer wrapping after the positions are
1265 * incremented. It is important that k cannot be left set
1266 * to BCR. Also, if either started at BCR then they should continue
1267 * to increment beyond BCR.
1268 */
1271 }
1274 }
1275 }
1287 current_address);
1288 }
1290 /* %offset */
1295 }
1298 /* %length */
1303 }
1307 /* $destination */
1308 next_operand_address = dissect_udvm_reference_operand(buff, operand_address, &ref_destination, &result_dest);
1312 }
1315 {
1319 }
1322 /* Execute the instruction:
1323 * To derive the value of the position operand, starting at the memory
1324 * address specified by destination, the UDVM counts backwards a total
1325 * of offset memory addresses.
1326 *
1327 * If the memory address specified in byte_copy_left is reached, the
1328 * next memory address is taken to be (byte_copy_right - 1) modulo 2^16.
1329 */
1335 /*
1336 * In order to work out the position, simple arithmetic is tricky
1337 * to apply because there some nasty corner cases. A simple loop
1338 * is inefficient but the logic is simple.
1339 *
1340 * FUTURE: This could be optimised.
1341 */
1343 {
1345 {
1347 }
1348 else
1349 {
1351 }
1352 }
1358 }
1359 /* The COPY-OFFSET instruction then behaves as a COPY-LITERAL
1360 * instruction, taking the value of the position operand to be the last
1361 * memory address reached in the above step.
1362 */
1364 /*
1365 * 8.4. Byte copying
1366 * :
1367 * The string of bytes is copied in ascending order of memory address,
1368 * respecting the bounds set by byte_copy_left and byte_copy_right.
1369 * More precisely, if a byte is copied from/to Address m then the next
1370 * byte is copied from/to Address n where n is calculated as follows:
1371 *
1372 * Set k := m + 1 (modulo 2^16)
1373 * If k = byte_copy_right then set n := byte_copy_left, else set n := k
1374 *
1375 */
1382 }
1389 }
1390 n++;
1394 /*
1395 * Check for circular buffer wrapping after the positions are
1396 * incremented. It is important that k cannot be left set
1397 * to BCR. Also, if either started at BCR then they should continue
1398 * to increment beyond BCR.
1399 */
1402 }
1405 }
1406 }
1417 current_address);
1418 }
1421 /* %address */
1426 }
1429 /* %length, */
1434 }
1436 /* %start_value */
1441 }
1444 /* %offset */
1449 }
1451 {
1455 }
1457 /* exetute the instruction
1458 * The sequence of values used by the MEMSET instruction is specified by
1459 * the following formula:
1460 *
1461 * Seq[n] := (start_value + n * offset) modulo 256
1462 */
1472 }
1476 }
1482 }
1484 n++;
1495 current_address);
1496 }
1498 /* @address */
1499 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
1500 /*next_operand_address = */decode_udvm_address_operand(buff,operand_address, &at_address, current_address);
1504 }
1506 {
1510 }
1516 /* COMPARE (%value_1, %value_2, @address_1, @address_2, @address_3)
1517 */
1521 current_address);
1522 }
1525 /* %value_1 */
1530 }
1533 /* %value_2 */
1538 }
1541 /* @address_1 */
1542 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
1548 }
1552 /* @address_2 */
1553 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
1559 }
1562 /* @address_3 */
1563 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
1564 /*next_operand_address = */decode_udvm_multitype_operand(buff, operand_address, &at_address_3);
1569 }
1571 {
1575 }
1576 /* execute the instruction
1577 * If value_1 < value_2 then the UDVM continues instruction execution at
1578 * the memory address specified by address 1. If value_1 = value_2 then
1579 * it jumps to the address specified by address_2. If value_1 > value_2
1580 * then it jumps to the address specified by address_3.
1581 */
1595 current_address);
1596 }
1598 /* @address */
1599 next_operand_address = decode_udvm_address_operand(buff,operand_address, &at_address, current_address);
1603 }
1605 {
1609 }
1612 /* Push the current address onto the stack */
1628 /* ... and jump to the destination address */
1639 current_address);
1640 }
1642 /* Pop value from the top of the stack */
1647 {
1650 }
1662 /* ... and set the PC to the popped value */
1669 case SIGCOMP_INSTR_SWITCH: /* 26 SWITCH (#n, %j, @address_0, @address_1, ... , @address_n-1) */
1670 /*
1671 * When a SWITCH instruction is encountered the UDVM reads the value of
1672 * j. It then continues instruction execution at the address specified
1673 * by address j.
1674 *
1675 * Decompression failure occurs if j specifies a value of n or more, or
1676 * if the address lies beyond the overall UDVM memory size.
1677 */
1682 current_address);
1683 }
1685 /* #n
1686 * Number of addresses in the instruction
1687 */
1692 }
1694 /* %j */
1699 }
1703 /* @address_n-1 */
1704 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
1710 }
1713 }
1715 m++;
1716 }
1717 /* Check decompression failure */
1721 }
1725 }
1735 current_address);
1736 }
1740 /* %value */
1745 }
1748 /* %position */
1753 }
1756 /* %length */
1761 }
1764 /* @address */
1770 }
1771 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
1785 }
1793 }
1804 }
1805 }
1811 }
1814 }
1817 }
1826 current_address);
1827 }
1829 /* %length */
1834 }
1837 /* %destination */
1842 }
1845 /* @address */
1846 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
1852 }
1854 {
1858 }
1859 /* execute the instruction TODO insert checks
1860 * RFC 3320 :
1861 *
1862 * 0 7 8 15
1863 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1864 * | byte_copy_left | 64 - 65
1865 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1866 * | byte_copy_right | 66 - 67
1867 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1868 * | input_bit_order | 68 - 69
1869 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1870 * | stack_location | 70 - 71
1871 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1872 *
1873 * Figure 7: Memory addresses of the UDVM registers
1874 * :
1875 * 8.4. Byte copying
1876 * :
1877 * The string of bytes is copied in ascending order of memory address,
1878 * respecting the bounds set by byte_copy_left and byte_copy_right.
1879 * More precisely, if a byte is copied from/to Address m then the next
1880 * byte is copied from/to Address n where n is calculated as follows:
1881 *
1882 * Set k := m + 1 (modulo 2^16)
1883 * If k = byte_copy_right then set n := byte_copy_left, else set n := k
1884 *
1885 */
1896 }
1897 /* clear out remaining bits if any */
1900 /* operand_address used as dummy */
1906 }
1910 }
1916 }
1917 input_address++;
1918 /*
1919 * If the instruction requests data that lies beyond the end of the
1920 * SigComp message, no data is returned. Instead the UDVM moves program
1921 * execution to the address specified by the address operand.
1922 */
1926 n++;
1927 }
1933 /*
1934 * The length operand indicates the requested number of bits.
1935 * Decompression failure occurs if this operand does not lie between 0
1936 * and 16 inclusive.
1937 *
1938 * The destination operand specifies the memory address to which the
1939 * compressed data should be copied. Note that the requested bits are
1940 * interpreted as a 2-byte integer ranging from 0 to 2^length - 1, as
1941 * explained in Section 8.2.
1942 *
1943 * If the instruction requests data that lies beyond the end of the
1944 * SigComp message, no data is returned. Instead the UDVM moves program
1945 * execution to the address specified by the address operand.
1946 */
1951 current_address);
1952 }
1955 /* %length */
1960 }
1962 /* %destination */
1967 }
1970 /* @address */
1971 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
1972 next_operand_address = decode_udvm_address_operand(buff,operand_address, &at_address, current_address);
1976 }
1978 {
1982 }
1985 /*
1986 * Execute actual instr.
1987 * The input_bit_order register contains the following three flags:
1988 *
1989 * 0 7 8 15
1990 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1991 * | reserved |F|H|P| 68 - 69
1992 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1993 */
1996 /*
1997 * If the instruction requests data that lies beyond the end of the
1998 * SigComp message, no data is returned. Instead the UDVM moves program
1999 * execution to the address specified by the address operand.
2000 */
2005 }
2009 }
2011 /*
2012 * Transfer F bit to bit_order to tell decomp dispatcher which bit order to use
2013 */
2021 }
2030 " Loading value: %u (0x%x) at Addr: %u, remaining_bits: %u", value, value, destination, remaining_bits);
2031 }
2036 /*
2037 * INPUT-HUFFMAN (%destination, @address, #n, %bits_1, %lower_bound_1,
2038 * %upper_bound_1, %uncompressed_1, ... , %bits_n, %lower_bound_n,
2039 * %upper_bound_n, %uncompressed_n)
2040 */
2043 "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)",
2044 current_address);
2045 }
2048 /* %destination */
2053 }
2056 /* @address */
2057 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
2058 next_operand_address = decode_udvm_address_operand(buff,operand_address, &at_address, current_address);
2062 }
2065 /* #n */
2070 }
2073 {
2075 "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)",
2077 }
2081 /*
2082 * Note that if n = 0 then the INPUT-HUFFMAN instruction is ignored and
2083 * program execution resumes at the following instruction.
2084 * Decompression failure occurs if (bits_1 + ... + bits_n) > 16.
2085 *
2086 * In all other cases, the behavior of the INPUT-HUFFMAN instruction is
2087 * defined below:
2088 *
2089 * 1. Set j := 1 and set H := 0.
2090 *
2091 * 2. Request bits_j compressed bits. Interpret the returned bits as an
2092 * integer k from 0 to 2^bits_j - 1, as explained in Section 8.2.
2093 *
2094 * 3. Set H := H * 2^bits_j + k.
2095 *
2096 * 4. If data is requested that lies beyond the end of the SigComp
2097 * message, terminate the INPUT-HUFFMAN instruction and move program
2098 * execution to the memory address specified by the address operand.
2099 *
2100 * 5. If (H < lower_bound_j) or (H > upper_bound_j) then set j := j + 1.
2101 * Then go back to Step 2, unless j > n in which case decompression
2102 * failure occurs.
2103 *
2104 * 6. Copy (H + uncompressed_j - lower_bound_j) modulo 2^16 to the
2105 * memory address specified by the destination operand.
2106 *
2107 */
2108 /*
2109 * The input_bit_order register contains the following three flags:
2110 *
2111 * 0 7 8 15
2112 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2113 * | reserved |F|H|P| 68 - 69
2114 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
2115 *
2116 * Transfer H bit to bit_order to tell decomp dispatcher which bit order to use
2117 */
2128 /* %bits_n */
2133 }
2136 /* %lower_bound_n */
2141 }
2143 /* %upper_bound_n */
2148 }
2150 /* %uncompressed_n */
2155 }
2157 /* execute instruction */
2159 /*
2160 * 2. Request bits_j compressed bits. Interpret the returned bits as an
2161 * integer k from 0 to 2^bits_j - 1, as explained in Section 8.2.
2162 */
2167 /*
2168 * 4. If data is requested that lies beyond the end of the SigComp
2169 * message, terminate the INPUT-HUFFMAN instruction and move program
2170 * execution to the memory address specified by the address operand.
2171 */
2174 }
2176 /*
2177 * 3. Set H := H * 2^bits_j + k.
2178 * [In practice is a shift+OR operation.]
2179 */
2183 proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1," Set H(%u) := H(%u) * 2^bits_j(%u) + k(%u)",
2185 }
2187 /*
2188 * 5. If (H < lower_bound_j) or (H > upper_bound_j) then set j := j + 1.
2189 * Then go back to Step 2, unless j > n in which case decompression
2190 * failure occurs.
2191 */
2197 /*
2198 * 6. Copy (H + uncompressed_j - lower_bound_j) modulo 2^16 to the
2199 * memory address specified by the destination operand.
2200 */
2205 }
2217 }
2219 }
2222 }
2224 }
2228 }
2235 /* STATE-ACCESS (%partial_identifier_start, %partial_identifier_length,
2236 * %state_begin, %state_length, %state_address, %state_instruction)
2237 */
2240 "Addr: %u ## STATE-ACCESS(31) (partial_identifier_start, partial_identifier_length,state_begin, state_length, state_address, state_instruction)",
2241 current_address);
2242 }
2245 /*
2246 * %partial_identifier_start
2247 */
2252 }
2254 /*
2255 * %partial_identifier_length
2256 */
2262 }
2263 /*
2264 * %state_begin
2265 */
2271 }
2272 /*
2273 * %state_length
2274 */
2280 }
2281 /*
2282 * %state_address
2283 */
2289 }
2290 /*
2291 * %state_instruction
2292 */
2294 next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_instruction);
2298 }
2300 {
2302 "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)",
2303 current_address, p_id_start, p_id_length, state_begin, state_length, state_address, state_instruction);
2304 }
2313 }
2315 result_code = udvm_state_access(message_tvb, udvm_tree, buff, p_id_start, p_id_length, state_begin, &state_length,
2319 }
2324 /*
2325 * STATE-CREATE (%state_length, %state_address, %state_instruction,
2326 * %minimum_access_length, %state_retention_priority)
2327 */
2330 "Addr: %u ## STATE-CREATE(32) (state_length, state_address, state_instruction,minimum_access_length, state_retention_priority)",
2331 current_address);
2332 }
2335 /*
2336 * %state_length
2337 */
2342 }
2343 /*
2344 * %state_address
2345 */
2351 }
2352 /*
2353 * %state_instruction
2354 */
2356 next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_instruction);
2360 }
2361 /*
2362 * %minimum_access_length
2363 */
2365 next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &minimum_access_length);
2369 }
2370 /*
2371 * %state_retention_priority
2372 */
2374 next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_retention_priority);
2378 }
2380 {
2382 "Addr: %u ## STATE-CREATE(32) (state_length=%u, state_address=%u, state_instruction=%u,minimum_access_length=%u, state_retention_priority=%u)",
2383 current_address, state_length, state_address, state_instruction,minimum_access_length, state_retention_priority);
2384 }
2386 /* Execute the instruction
2387 * TODO Implement the instruction
2388 * RFC3320:
2389 * Note that the new state item cannot be created until a valid
2390 * compartment identifier has been returned by the application.
2391 * Consequently, when a STATE-CREATE instruction is encountered the UDVM
2392 * simply buffers the five supplied operands until the END-MESSAGE
2393 * instruction is reached. The steps taken at this point are described
2394 * in Section 9.4.9.
2395 *
2396 * Decompression failure MUST occur if more than four state creation
2397 * requests are made before the END-MESSAGE instruction is encountered.
2398 * Decompression failure also occurs if the minimum_access_length does
2399 * not lie between 6 and 20 inclusive, or if the
2400 * state_retention_priority is 65535.
2401 */
2402 no_of_state_create++;
2406 }
2410 }
2414 }
2419 /* state_state_retention_priority_buff[no_of_state_create] = state_retention_priority; */
2421 /* Debug */
2431 }
2438 }
2440 n++;
2441 }
2442 /* End debug */
2447 /*
2448 * STATE-FREE (%partial_identifier_start, %partial_identifier_length)
2449 */
2453 current_address);
2454 }
2456 /*
2457 * %partial_identifier_start
2458 */
2463 }
2466 /*
2467 * %partial_identifier_length
2468 */
2473 }
2475 {
2479 }
2482 /* Execute the instruction:
2483 * TODO implement it
2484 */
2493 current_address);
2494 }
2496 /*
2497 * %output_start
2498 */
2503 }
2505 /*
2506 * %output_length
2507 */
2512 }
2514 {
2518 }
2521 /*
2522 * Execute instruction
2523 * 8.4. Byte copying
2524 * :
2525 * The string of bytes is copied in ascending order of memory address,
2526 * respecting the bounds set by byte_copy_left and byte_copy_right.
2527 * More precisely, if a byte is copied from/to Address m then the next
2528 * byte is copied from/to Address n where n is calculated as follows:
2529 *
2530 * Set k := m + 1 (modulo 2^16)
2531 * If k = byte_copy_right then set n := byte_copy_left, else set n := k
2532 *
2533 */
2544 }
2549 }
2557 }
2559 output_address ++;
2560 n++;
2561 }
2566 /*
2567 * END-MESSAGE (%requested_feedback_location,
2568 * %returned_parameters_location, %state_length, %state_address,
2569 * %state_instruction, %minimum_access_length,
2570 * %state_retention_priority)
2571 */
2574 "Addr: %u ## END-MESSAGE (requested_feedback_location,state_instruction, minimum_access_length,state_retention_priority)",
2575 current_address);
2576 }
2579 /* %requested_feedback_location */
2580 next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &requested_feedback_location);
2584 }
2586 /* returned_parameters_location */
2587 next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &returned_parameters_location);
2591 }
2592 /*
2593 * %state_length
2594 */
2600 }
2601 /*
2602 * %state_address
2603 */
2609 }
2610 /*
2611 * %state_instruction
2612 */
2614 next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_instruction);
2618 }
2620 /*
2621 * %minimum_access_length
2622 */
2624 next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &minimum_access_length);
2628 }
2630 /*
2631 * %state_retention_priority
2632 */
2634 /*next_operand_address =*/ decode_udvm_multitype_operand(buff, operand_address, &state_retention_priority);
2638 }
2640 {
2642 "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)",
2643 current_address, requested_feedback_location, returned_parameters_location, state_length, state_address, state_instruction, minimum_access_length,state_retention_priority);
2644 }
2645 /* TODO: This isn't currently totaly correct as END_INSTRUCTION might not create state */
2646 no_of_state_create++;
2650 }
2654 /* Not used ? */
2656 /* state_state_retention_priority_buff[no_of_state_create] = state_retention_priority; */
2658 /* Execute the instruction
2659 */
2660 proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"no_of_state_create %u",no_of_state_create);
2682 }
2683 }
2686 {
2689 }
2692 }
2698 proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"SHA1 digest %s",bytes_to_str(sha1_digest_buf, STATE_BUFFER_SIZE));
2700 }
2701 /* begin partial state-id change cco@iptel.org */
2702 #if 0
2704 #endif
2706 /* end partial state-id change cco@iptel.org */
2708 proto_tree_add_string(udvm_tree,hf_id, bytecode_tvb, 0, 0, bytes_to_str(sha1_digest_buf, state_minimum_access_length_buff[n]));
2710 n++;
2712 }
2713 }
2717 /* At least something got decompressed, show it */
2719 /* Arrange that the allocated packet data copy be freed when the
2720 * tvbuff is freed.
2721 */
2725 /*
2726 proto_tree_add_text(udvm_tree, decomp_tvb, 0, -1,"SigComp message Decompressed");
2727 */
2729 proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"maximum_UDVM_cycles %u used_udvm_cycles %u",
2735 proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1," ### Addr %u Invalid instruction: %u (0x%x)",
2738 }
2741 decompression_failure:
2749 }
2751 /* The simplest operand type is the literal (#), which encodes a
2752 * constant integer from 0 to 65535 inclusive. A literal operand may
2753 * require between 1 and 3 bytes depending on its value.
2754 * Bytecode: Operand value: Range:
2755 * 0nnnnnnn N 0 - 127
2756 * 10nnnnnn nnnnnnnn N 0 - 16383
2757 * 11000000 nnnnnnnn nnnnnnnn N 0 - 65535
2758 *
2759 * Figure 8: Bytecode for a literal (#) operand
2760 *
2761 */
2762 static int
2764 {
2765 guint bytecode;
2766 guint16 operand;
2767 guint test_bits;
2769 guint8 temp_data;
2776 /*
2777 * 10nnnnnn nnnnnnnn N 0 - 16383
2778 */
2787 /*
2788 * 111000000 nnnnnnnn nnnnnnnn N 0 - 65535
2789 */
2790 offset ++;
2798 }
2800 /*
2801 * 0nnnnnnn N 0 - 127
2802 */
2805 offset ++;
2806 }
2810 }
2812 /*
2813 * The second operand type is the reference ($), which is always used to
2814 * access a 2-byte value located elsewhere in the UDVM memory. The
2815 * bytecode for a reference operand is decoded to be a constant integer
2816 * from 0 to 65535 inclusive, which is interpreted as the memory address
2817 * containing the actual value of the operand.
2818 * Bytecode: Operand value: Range:
2819 *
2820 * 0nnnnnnn memory[2 * N] 0 - 65535
2821 * 10nnnnnn nnnnnnnn memory[2 * N] 0 - 65535
2822 * 11000000 nnnnnnnn nnnnnnnn memory[N] 0 - 65535
2823 *
2824 * Figure 9: Bytecode for a reference ($) operand
2825 */
2826 static int
2827 dissect_udvm_reference_operand(guint8 *buff,guint operand_address, guint16 *value,guint *result_dest)
2828 {
2829 guint bytecode;
2830 guint16 operand;
2832 guint test_bits;
2833 guint8 temp_data;
2834 guint16 temp_data16;
2841 /*
2842 * 10nnnnnn nnnnnnnn memory[2 * N] 0 - 65535
2843 */
2856 /*
2857 * 11000000 nnnnnnnn nnnnnnnn memory[N] 0 - 65535
2858 */
2859 operand_address++;
2868 }
2870 /*
2871 * 0nnnnnnn memory[2 * N] 0 - 65535
2872 */
2879 offset ++;
2880 }
2886 }
2888 /* RFC3320
2889 * Figure 10: Bytecode for a multitype (%) operand
2890 * Bytecode: Operand value: Range: HEX val
2891 * 00nnnnnn N 0 - 63 0x00
2892 * 01nnnnnn memory[2 * N] 0 - 65535 0x40
2893 * 1000011n 2 ^ (N + 6) 64 , 128 0x86
2894 * 10001nnn 2 ^ (N + 8) 256 , ... , 32768 0x88
2895 * 111nnnnn N + 65504 65504 - 65535 0xe0
2896 * 1001nnnn nnnnnnnn N + 61440 61440 - 65535 0x90
2897 * 101nnnnn nnnnnnnn N 0 - 8191 0xa0
2898 * 110nnnnn nnnnnnnn memory[N] 0 - 65535 0xc0
2899 * 10000000 nnnnnnnn nnnnnnnn N 0 - 65535 0x80
2900 * 10000001 nnnnnnnn nnnnnnnn memory[N] 0 - 65535 0x81
2901 */
2902 static int
2904 {
2905 guint test_bits;
2906 guint bytecode;
2908 guint16 operand;
2909 guint32 result;
2910 guint8 temp_data;
2911 guint16 temp_data16;
2920 /*
2921 * 00nnnnnn N 0 - 63
2922 */
2924 /* debug
2925 *g_warning("Reading 0x%x From address %u",operand,offset);
2926 */
2928 offset ++;
2931 /*
2932 * 01nnnnnn memory[2 * N] 0 - 65535
2933 */
2938 offset ++;
2941 /* Check tree most significant bits */
2944 /*
2945 * 101nnnnn nnnnnnnn N 0 - 8191
2946 */
2956 /*
2957 * 1001nnnn nnnnnnnn N + 61440 61440 - 65535
2958 */
2969 /*
2970 * 10001nnn 2 ^ (N + 8) 256 , ... , 32768
2971 */
2976 offset ++;
2980 /*
2981 * 1000 011n 2 ^ (N + 6) 64 , 128
2982 */
2986 offset ++;
2988 /*
2989 * 1000 0000 nnnnnnnn nnnnnnnn N 0 - 65535
2990 * 1000 0001 nnnnnnnn nnnnnnnn memory[N] 0 - 65535
2991 */
2992 offset ++;
2995 /* debug
2996 * g_warning("Reading 0x%x From address %u",temp_data16,operand_address);
2997 */
3002 }
3005 }
3008 }
3009 }
3010 }
3016 /*
3017 * 111nnnnn N + 65504 65504 - 65535
3018 */
3021 offset ++;
3023 /*
3024 * 110nnnnn nnnnnnnn memory[N] 0 - 65535
3025 */
3032 /* debug
3033 * g_warning("Reading 0x%x From address %u",temp_data16,memmory_addr);
3034 */
3036 }
3040 }
3042 }
3043 /*
3044 *
3045 * The fourth operand type is the address (@). This operand is decoded
3046 * as a multitype operand followed by a further step: the memory address
3047 * of the UDVM instruction containing the address operand is added to
3048 * obtain the correct operand value. So if the operand value from
3049 * Figure 10 is D then the actual operand value of an address is
3050 * calculated as follows:
3051 *
3052 * operand_value = (memory_address_of_instruction + D) modulo 2^16
3053 *
3054 * Address operands are always used in instructions that control program
3055 * flow, because they ensure that the UDVM bytecode is position-
3056 * independent code (i.e., it will run independently of where it is
3057 * placed in the UDVM memory).
3058 */
3059 static int
3060 decode_udvm_address_operand(guint8 *buff,guint operand_address, guint16 *value,guint current_address)
3061 {
3062 guint32 result;
3063 guint16 value1;
3064 guint next_opreand_address;
3071 }
3074 /*
3075 * This is a lookup table used to reverse the bits in a byte.
3076 */
3110 };
3113 static int
3117 guint8 bit_order,
3123 guint16 length,
3125 guint msg_end)
3126 {
3127 guint16 input_bit_order;
3130 guint8 octet;
3132 gint p_bit;
3142 /*
3143 * Discard any spare bits.
3144 * Note: We take care to avoid remaining_bits having the value of 8.
3145 */
3147 {
3150 }
3152 /*
3153 * Check we can suppy the required number of bits now, before we alter
3154 * the input buffer's state.
3155 */
3157 {
3160 }
3162 /* Note: This is never called with length > 16, so the following loop
3163 * never loops more than three time. */
3165 {
3166 /*
3167 * We only put anything into input_bits if we know we will remove
3168 * at least one bit. That ensures we can simply discard the spare
3169 * bits if the P-bit changes.
3170 */
3172 {
3177 }
3181 {
3183 }
3186 }
3188 /* Add some more bits to the accumulated value. */
3197 }
3200 {
3201 /* Bit reverse the entire word. */
3206 }
3209 }
3212 /* end udvm */