| blob | 331f45087ba8e9109468dd70b70f2d4d1ed39a41 |
1 /* packet-sigcomp.c
2 * Routines for Signaling Compression (SigComp) dissection.
3 * Copyright 2004-2005, Anders Broman <anders.broman@ericsson.com>
4 *
5 * Wireshark - Network traffic analyzer
6 * By Gerald Combs <gerald@wireshark.org>
7 * Copyright 1998 Gerald Combs
8 *
9 * SPDX-License-Identifier: GPL-2.0-or-later
10 * References:
11 * https://www.ietf.org/rfc/rfc3320
12 * https://www.ietf.org/rfc/rfc3321
13 * https://www.ietf.org/rfc/rfc4077
14 * Useful links :
15 * https://tools.ietf.org/html/draft-ietf-rohc-sigcomp-impl-guide-10
16 * https://tools.ietf.org/html/draft-ietf-rohc-sigcomp-sip-01
17 */
21 #include <epan/packet.h>
22 #include <epan/prefs.h>
23 #include <epan/expert.h>
24 #include <epan/to_str.h>
25 #include <epan/strutil.h>
26 #include <epan/exceptions.h>
28 #include <wsutil/wsgcrypt.h>
29 #include <wsutil/crc16.h>
30 #include <wsutil/pow2.h>
35 /* Initialize the protocol and registered fields */
52 /* static int hf_udvm_operand; */
104 /* Generated from convert_proto_tree_add_text.pl */
142 /* Initialize the subtree pointers */
151 /* Generated from convert_proto_tree_add_text.pl */
164 /* set the tcp ports */
167 /* Default preference whether to display the bytecode in UDVM operands or not */
169 /* Default preference whether to dissect the UDVM code or not */
170 /* WARNING: Setting this to true might result in the entire dissector being
171 disabled by default or removed completely. */
174 /* Default preference whether to decompress the message or not */
175 /* WARNING: Setting this to true might result in the entire dissector being
176 disabled by default or removed completely. */
178 /* Default preference whether to print debug info at execution of UDVM
179 * 0 = No printout
180 * 1 = details level 1
181 * 2 = details level 2
182 * 3 = details level 3
183 * 4 = details level 4
184 */
187 /* Value strings */
194 };
215 };
219 /* RFC3320
220 * Figure 10: Bytecode for a multitype (%) operand
221 * Bytecode: Operand value: Range: HEX val
222 * 00nnnnnn N 0 - 63 0x00
223 * 01nnnnnn memory[2 * N] 0 - 65535 0x40
224 * 1000011n 2 ^ (N + 6) 64 , 128 0x86
225 * 10001nnn 2 ^ (N + 8) 256 , ... , 32768 0x88
226 * 111nnnnn N + 65504 65504 - 65535 0xe0
227 * 1001nnnn nnnnnnnn N + 61440 61440 - 65535 0x90
228 * 101nnnnn nnnnnnnn N 0 - 8191 0xa0
229 * 110nnnnn nnnnnnnn memory[N] 0 - 65535 0xc0
230 * 10000000 nnnnnnnn nnnnnnnn N 0 - 65535 0x80
231 * 10000001 nnnnnnnn nnnnnnnn memory[N] 0 - 65535 0x81
232 */
246 };
247 /* RFC3320
248 * 0nnnnnnn memory[2 * N] 0 - 65535
249 * 10nnnnnn nnnnnnnn memory[2 * N] 0 - 65535
250 * 11000000 nnnnnnnn nnnnnnnn memory[N] 0 - 65535
251 */
257 };
258 /* The simplest operand type is the literal (#), which encodes a
259 * constant integer from 0 to 65535 inclusive. A literal operand may
260 * require between 1 and 3 bytes depending on its value.
261 * Bytecode: Operand value: Range:
262 * 0nnnnnnn N 0 - 127
263 * 10nnnnnn nnnnnnnn N 0 - 16383
264 * 11000000 nnnnnnnn nnnnnnnn N 0 - 65535
265 *
266 * Figure 8: Bytecode for a literal (#) operand
267 *
268 */
275 };
277 #define SIGCOMP_NACK_STATE_NOT_FOUND 1
278 #define SIGCOMP_NACK_CYCLES_EXHAUSTED 2
279 #define SIGCOMP_NACK_BYTECODES_TOO_LARGE 18
280 #define SIGCOMP_NACK_ID_NOT_UNIQUE 21
281 #define SIGCOMP_NACK_STATE_TOO_SHORT 23
310 };
315 static void dissect_udvm_bytecode(tvbuff_t *udvm_tvb, packet_info* pinfo, proto_tree *sigcomp_udvm_tree, unsigned destination);
332 #define UDVM_MEMORY_SIZE 65536
334 /**********************************************************************************************
335 *
336 * SIGCOMP STATE HANDLER
337 *
338 **********************************************************************************************/
339 #define STATE_BUFFER_SIZE 20
340 #define STATE_MIN_ACCESS_LEN 6
342 /*
343 * Defenitions for:
344 * The Session Initiation Protocol (SIP) and Session Description Protocol
345 * (SDP) Static Dictionary for Signaling Compression (SigComp)
346 * https://www.ietf.org/rfc/rfc3485
347 */
348 #define SIP_SDP_STATE_LENGTH 0x12e4
351 {
352 /* -0000, */ 0xfb, 0xe5, 0x07, 0xdf, 0xe5, 0xe6, 0xaa, 0x5a, 0xf2, 0xab, 0xb9, 0x14, 0xce, 0xaa, 0x05, 0xf9,
354 };
357 {
359 /* -0000, */ 0x0d, 0x0a, 0x52, 0x65, 0x6a, 0x65, 0x63, 0x74, 0x2d, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x63, 0x74,
360 /* -0010, */ 0x3a, 0x20, 0x0d, 0x0a, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x2d, 0x49, 0x6e, 0x66, 0x6f, 0x3a, 0x20,
361 /* -0020, */ 0x0d, 0x0a, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x3a, 0x20, 0x0d, 0x0a, 0x43,
362 /* -0030, */ 0x61, 0x6c, 0x6c, 0x2d, 0x49, 0x6e, 0x66, 0x6f, 0x3a, 0x20, 0x0d, 0x0a, 0x52, 0x65, 0x70, 0x6c,
363 /* -0040, */ 0x79, 0x2d, 0x54, 0x6f, 0x3a, 0x20, 0x0d, 0x0a, 0x57, 0x61, 0x72, 0x6e, 0x69, 0x6e, 0x67, 0x3a,
364 /* -0050, */ 0x20, 0x0d, 0x0a, 0x53, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3a, 0x20, 0x3b, 0x68, 0x61, 0x6e,
365 /* -0060, */ 0x64, 0x6c, 0x69, 0x6e, 0x67, 0x3d, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x3b, 0x70, 0x75, 0x72, 0x70,
366 /* -0070, */ 0x6f, 0x73, 0x65, 0x3d, 0x3b, 0x63, 0x61, 0x75, 0x73, 0x65, 0x3d, 0x3b, 0x74, 0x65, 0x78, 0x74,
367 /* -0080, */ 0x3d, 0x63, 0x61, 0x72, 0x64, 0x33, 0x30, 0x30, 0x20, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c,
368 /* -0090, */ 0x65, 0x20, 0x43, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x73, 0x6d, 0x69, 0x6d, 0x65, 0x73, 0x73, 0x61,
369 /* -00A0, */ 0x67, 0x65, 0x2f, 0x73, 0x69, 0x70, 0x66, 0x72, 0x61, 0x67, 0x34, 0x30, 0x37, 0x20, 0x50, 0x72,
370 /* -00B0, */ 0x6f, 0x78, 0x79, 0x20, 0x41, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x69,
371 /* -00C0, */ 0x6f, 0x6e, 0x20, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74,
372 /* -00D0, */ 0x2d, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x69, 0x74, 0x79, 0x34, 0x38, 0x34, 0x20, 0x41, 0x64,
373 /* -00E0, */ 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x49, 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65,
374 /* -00F0, */ 0x6c, 0x65, 0x70, 0x68, 0x6f, 0x6e, 0x65, 0x2d, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x34, 0x39,
375 /* -0100, */ 0x34, 0x20, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x20, 0x41, 0x67, 0x72, 0x65, 0x65,
376 /* -0110, */ 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x65, 0x61, 0x63,
377 /* -0120, */ 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x64, 0x34, 0x38, 0x31, 0x20, 0x43, 0x61, 0x6c, 0x6c, 0x2f,
378 /* -0130, */ 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x44, 0x6f, 0x65, 0x73,
379 /* -0140, */ 0x20, 0x4e, 0x6f, 0x74, 0x20, 0x45, 0x78, 0x69, 0x73, 0x74, 0x61, 0x6c, 0x65, 0x3d, 0x35, 0x30,
380 /* -0150, */ 0x30, 0x20, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61,
381 /* -0160, */ 0x6c, 0x20, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x6f, 0x62, 0x75, 0x73, 0x74, 0x2d, 0x73, 0x6f, 0x72,
382 /* -0170, */ 0x74, 0x69, 0x6e, 0x67, 0x3d, 0x34, 0x31, 0x36, 0x20, 0x55, 0x6e, 0x73, 0x75, 0x70, 0x70, 0x6f,
383 /* -0180, */ 0x72, 0x74, 0x65, 0x64, 0x20, 0x55, 0x52, 0x49, 0x20, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x65, 0x72,
384 /* -0190, */ 0x67, 0x65, 0x6e, 0x63, 0x79, 0x34, 0x31, 0x35, 0x20, 0x55, 0x6e, 0x73, 0x75, 0x70, 0x70, 0x6f,
385 /* -01A0, */ 0x72, 0x74, 0x65, 0x64, 0x20, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x20, 0x54, 0x79, 0x70, 0x65, 0x6e,
386 /* -01B0, */ 0x64, 0x69, 0x6e, 0x67, 0x34, 0x38, 0x38, 0x20, 0x4e, 0x6f, 0x74, 0x20, 0x41, 0x63, 0x63, 0x65,
387 /* -01C0, */ 0x70, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x48, 0x65, 0x72, 0x65, 0x6a, 0x65, 0x63, 0x74, 0x65,
388 /* -01D0, */ 0x64, 0x34, 0x32, 0x33, 0x20, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x20, 0x54, 0x6f,
389 /* -01E0, */ 0x6f, 0x20, 0x42, 0x72, 0x69, 0x65, 0x66, 0x72, 0x6f, 0x6d, 0x2d, 0x74, 0x61, 0x67, 0x51, 0x2e,
390 /* -01F0, */ 0x38, 0x35, 0x30, 0x35, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x4e, 0x6f, 0x74,
391 /* -0200, */ 0x20, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x34, 0x30, 0x33, 0x20, 0x46, 0x6f,
392 /* -0210, */ 0x72, 0x62, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x6f, 0x6e, 0x2d, 0x75, 0x72, 0x67, 0x65, 0x6e, 0x74,
393 /* -0220, */ 0x34, 0x32, 0x39, 0x20, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x20, 0x52, 0x65, 0x66, 0x65,
394 /* -0230, */ 0x72, 0x72, 0x6f, 0x72, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x34, 0x32, 0x30,
395 /* -0240, */ 0x20, 0x42, 0x61, 0x64, 0x20, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x6f, 0x72,
396 /* -0250, */ 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x0d, 0x0a, 0x61, 0x3d, 0x6b, 0x65, 0x79, 0x2d, 0x6d,
397 /* -0260, */ 0x67, 0x6d, 0x74, 0x3a, 0x6d, 0x69, 0x6b, 0x65, 0x79, 0x4f, 0x50, 0x54, 0x49, 0x4f, 0x4e, 0x53,
398 /* -0270, */ 0x20, 0x4c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x3a, 0x20, 0x35, 0x30, 0x34, 0x20, 0x53,
399 /* -0280, */ 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x54, 0x69, 0x6d, 0x65, 0x2d, 0x6f, 0x75, 0x74, 0x6f, 0x2d,
400 /* -0290, */ 0x74, 0x61, 0x67, 0x0d, 0x0a, 0x41, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74,
401 /* -02A0, */ 0x69, 0x6f, 0x6e, 0x2d, 0x49, 0x6e, 0x66, 0x6f, 0x3a, 0x20, 0x44, 0x65, 0x63, 0x20, 0x33, 0x38,
402 /* -02B0, */ 0x30, 0x20, 0x41, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x53, 0x65,
403 /* -02C0, */ 0x72, 0x76, 0x69, 0x63, 0x65, 0x35, 0x30, 0x33, 0x20, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65,
404 /* -02D0, */ 0x20, 0x55, 0x6e, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x34, 0x32, 0x31, 0x20,
405 /* -02E0, */ 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72,
406 /* -02F0, */ 0x65, 0x64, 0x34, 0x30, 0x35, 0x20, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x4e, 0x6f, 0x74,
407 /* -0300, */ 0x20, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x34, 0x38, 0x37, 0x20, 0x52, 0x65, 0x71, 0x75,
408 /* -0310, */ 0x65, 0x73, 0x74, 0x20, 0x54, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x64, 0x61, 0x75,
409 /* -0320, */ 0x74, 0x68, 0x2d, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6c, 0x65, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x3d,
410 /* -0330, */ 0x0d, 0x0a, 0x6d, 0x3d, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20,
411 /* -0340, */ 0x41, 0x75, 0x67, 0x20, 0x35, 0x31, 0x33, 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20,
412 /* -0350, */ 0x54, 0x6f, 0x6f, 0x20, 0x4c, 0x61, 0x72, 0x67, 0x65, 0x36, 0x38, 0x37, 0x20, 0x44, 0x69, 0x61,
413 /* -0360, */ 0x6c, 0x6f, 0x67, 0x20, 0x54, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x64, 0x33, 0x30,
414 /* -0370, */ 0x32, 0x20, 0x4d, 0x6f, 0x76, 0x65, 0x64, 0x20, 0x54, 0x65, 0x6d, 0x70, 0x6f, 0x72, 0x61, 0x72,
415 /* -0380, */ 0x69, 0x6c, 0x79, 0x33, 0x30, 0x31, 0x20, 0x4d, 0x6f, 0x76, 0x65, 0x64, 0x20, 0x50, 0x65, 0x72,
416 /* -0390, */ 0x6d, 0x61, 0x6e, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x61, 0x72,
417 /* -03A0, */ 0x74, 0x2f, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x0d, 0x0a, 0x52, 0x65, 0x74, 0x72, 0x79, 0x2d,
418 /* -03B0, */ 0x41, 0x66, 0x74, 0x65, 0x72, 0x3a, 0x20, 0x47, 0x4d, 0x54, 0x68, 0x75, 0x2c, 0x20, 0x34, 0x30,
419 /* -03C0, */ 0x32, 0x20, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72,
420 /* -03D0, */ 0x65, 0x64, 0x0d, 0x0a, 0x61, 0x3d, 0x6f, 0x72, 0x69, 0x65, 0x6e, 0x74, 0x3a, 0x6c, 0x61, 0x6e,
421 /* -03E0, */ 0x64, 0x73, 0x63, 0x61, 0x70, 0x65, 0x34, 0x30, 0x30, 0x20, 0x42, 0x61, 0x64, 0x20, 0x52, 0x65,
422 /* -03F0, */ 0x71, 0x75, 0x65, 0x73, 0x74, 0x72, 0x75, 0x65, 0x34, 0x39, 0x31, 0x20, 0x52, 0x65, 0x71, 0x75,
423 /* -0400, */ 0x65, 0x73, 0x74, 0x20, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x35, 0x30, 0x31, 0x20, 0x4e,
424 /* -0410, */ 0x6f, 0x74, 0x20, 0x49, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x34, 0x30,
425 /* -0420, */ 0x36, 0x20, 0x4e, 0x6f, 0x74, 0x20, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x61, 0x62, 0x6c, 0x65,
426 /* -0430, */ 0x36, 0x30, 0x36, 0x20, 0x4e, 0x6f, 0x74, 0x20, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x61, 0x62,
427 /* -0440, */ 0x6c, 0x65, 0x0d, 0x0a, 0x61, 0x3d, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x62, 0x72, 0x6f, 0x61, 0x64,
428 /* -0450, */ 0x63, 0x61, 0x73, 0x74, 0x6f, 0x6e, 0x65, 0x34, 0x39, 0x33, 0x20, 0x55, 0x6e, 0x64, 0x65, 0x63,
429 /* -0460, */ 0x69, 0x70, 0x68, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x0d, 0x0a, 0x4d, 0x49, 0x4d, 0x45, 0x2d,
430 /* -0470, */ 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3a, 0x20, 0x4d, 0x61, 0x79, 0x20, 0x34, 0x38, 0x32,
431 /* -0480, */ 0x20, 0x4c, 0x6f, 0x6f, 0x70, 0x20, 0x44, 0x65, 0x74, 0x65, 0x63, 0x74, 0x65, 0x64, 0x0d, 0x0a,
432 /* -0490, */ 0x4f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x20, 0x4a, 0x75,
433 /* -04A0, */ 0x6e, 0x20, 0x6d, 0x6f, 0x64, 0x65, 0x2d, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x2d, 0x6e, 0x65,
434 /* -04B0, */ 0x69, 0x67, 0x68, 0x62, 0x6f, 0x72, 0x3d, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x65,
435 /* -04C0, */ 0x72, 0x74, 0x63, 0x70, 0x2d, 0x66, 0x62, 0x34, 0x38, 0x39, 0x20, 0x42, 0x61, 0x64, 0x20, 0x45,
436 /* -04D0, */ 0x76, 0x65, 0x6e, 0x74, 0x6c, 0x73, 0x0d, 0x0a, 0x55, 0x6e, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72,
437 /* -04E0, */ 0x74, 0x65, 0x64, 0x3a, 0x20, 0x4a, 0x61, 0x6e, 0x20, 0x35, 0x30, 0x32, 0x20, 0x42, 0x61, 0x64,
438 /* -04F0, */ 0x20, 0x47, 0x61, 0x74, 0x65, 0x77, 0x61, 0x79, 0x6d, 0x6f, 0x64, 0x65, 0x2d, 0x63, 0x68, 0x61,
439 /* -0500, */ 0x6e, 0x67, 0x65, 0x2d, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x3d, 0x0d, 0x0a, 0x61, 0x3d, 0x6f,
440 /* -0510, */ 0x72, 0x69, 0x65, 0x6e, 0x74, 0x3a, 0x73, 0x65, 0x61, 0x73, 0x63, 0x61, 0x70, 0x65, 0x0d, 0x0a,
441 /* -0520, */ 0x61, 0x3d, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x6d, 0x6f, 0x64, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64,
442 /* -0530, */ 0x34, 0x30, 0x34, 0x20, 0x4e, 0x6f, 0x74, 0x20, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x33, 0x30, 0x35,
443 /* -0540, */ 0x20, 0x55, 0x73, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x78, 0x79, 0x0d, 0x0a, 0x61, 0x3d, 0x74, 0x79,
444 /* -0550, */ 0x70, 0x65, 0x3a, 0x72, 0x65, 0x63, 0x76, 0x6f, 0x6e, 0x6c, 0x79, 0x0d, 0x0a, 0x61, 0x3d, 0x74,
445 /* -0560, */ 0x79, 0x70, 0x65, 0x3a, 0x6d, 0x65, 0x65, 0x74, 0x69, 0x6e, 0x67, 0x0d, 0x0a, 0x6b, 0x3d, 0x70,
446 /* -0570, */ 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x3a, 0x0d, 0x0a, 0x52, 0x65, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64,
447 /* -0580, */ 0x2d, 0x42, 0x79, 0x3a, 0x20, 0x0d, 0x0a, 0x49, 0x6e, 0x2d, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x2d,
448 /* -0590, */ 0x54, 0x6f, 0x3a, 0x20, 0x54, 0x52, 0x55, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x3a,
449 /* -05A0, */ 0x20, 0x31, 0x38, 0x32, 0x20, 0x51, 0x75, 0x65, 0x75, 0x65, 0x64, 0x41, 0x75, 0x74, 0x68, 0x65,
450 /* -05B0, */ 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x3a, 0x20, 0x0d, 0x0a, 0x55, 0x73, 0x65, 0x72, 0x2d,
451 /* -05C0, */ 0x41, 0x67, 0x65, 0x6e, 0x74, 0x3a, 0x20, 0x0d, 0x0a, 0x61, 0x3d, 0x66, 0x72, 0x61, 0x6d, 0x65,
452 /* -05D0, */ 0x72, 0x61, 0x74, 0x65, 0x3a, 0x0d, 0x0a, 0x41, 0x6c, 0x65, 0x72, 0x74, 0x2d, 0x49, 0x6e, 0x66,
453 /* -05E0, */ 0x6f, 0x3a, 0x20, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x20, 0x0d, 0x0a, 0x61, 0x3d, 0x6d, 0x61,
454 /* -05F0, */ 0x78, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x3a, 0x3b, 0x72, 0x65, 0x74, 0x72, 0x79, 0x2d, 0x61, 0x66,
455 /* -0600, */ 0x74, 0x65, 0x72, 0x3d, 0x75, 0x61, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x3d, 0x34,
456 /* -0610, */ 0x31, 0x30, 0x20, 0x47, 0x6f, 0x6e, 0x65, 0x0d, 0x0a, 0x52, 0x65, 0x66, 0x65, 0x72, 0x2d, 0x54,
457 /* -0620, */ 0x6f, 0x3a, 0x20, 0x0d, 0x0a, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x3a, 0x20, 0x0d,
458 /* -0630, */ 0x0a, 0x6d, 0x3d, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x20, 0x0d, 0x0a, 0x61, 0x3d, 0x71,
459 /* -0640, */ 0x75, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x3a, 0x0d, 0x0a, 0x61, 0x3d, 0x73, 0x64, 0x70, 0x6c, 0x61,
460 /* -0650, */ 0x6e, 0x67, 0x3a, 0x0d, 0x0a, 0x61, 0x3d, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, 0x74, 0x3a, 0x0d,
461 /* -0660, */ 0x0a, 0x52, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x73, 0x3a, 0x20, 0x52, 0x45, 0x46, 0x45, 0x52,
462 /* -0670, */ 0x20, 0x69, 0x70, 0x73, 0x65, 0x63, 0x2d, 0x69, 0x6b, 0x65, 0x3b, 0x74, 0x72, 0x61, 0x6e, 0x73,
463 /* -0680, */ 0x70, 0x6f, 0x72, 0x74, 0x3d, 0x0d, 0x0a, 0x61, 0x3d, 0x6b, 0x65, 0x79, 0x77, 0x64, 0x73, 0x3a,
464 /* -0690, */ 0x0d, 0x0a, 0x6b, 0x3d, 0x62, 0x61, 0x73, 0x65, 0x36, 0x34, 0x3a, 0x3b, 0x72, 0x65, 0x66, 0x72,
465 /* -06A0, */ 0x65, 0x73, 0x68, 0x65, 0x72, 0x3d, 0x0d, 0x0a, 0x61, 0x3d, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x3a,
466 /* -06B0, */ 0x0d, 0x0a, 0x6b, 0x3d, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x3a, 0x3b, 0x72, 0x65, 0x63, 0x65, 0x69,
467 /* -06C0, */ 0x76, 0x65, 0x64, 0x3d, 0x3b, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x0d, 0x0a,
468 /* -06D0, */ 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x3a, 0x20, 0x0d, 0x0a, 0x61, 0x3d, 0x67, 0x72, 0x6f, 0x75,
469 /* -06E0, */ 0x70, 0x3a, 0x46, 0x41, 0x4c, 0x53, 0x45, 0x3a, 0x20, 0x49, 0x4e, 0x46, 0x4f, 0x20, 0x0d, 0x0a,
470 /* -06F0, */ 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2d, 0x0d, 0x0a, 0x61, 0x3d, 0x6c, 0x61, 0x6e, 0x67, 0x3a,
471 /* -0700, */ 0x0d, 0x0a, 0x6d, 0x3d, 0x64, 0x61, 0x74, 0x61, 0x20, 0x6d, 0x6f, 0x64, 0x65, 0x2d, 0x73, 0x65,
472 /* -0710, */ 0x74, 0x3d, 0x0d, 0x0a, 0x61, 0x3d, 0x74, 0x6f, 0x6f, 0x6c, 0x3a, 0x54, 0x4c, 0x53, 0x75, 0x6e,
473 /* -0720, */ 0x2c, 0x20, 0x0d, 0x0a, 0x44, 0x61, 0x74, 0x65, 0x3a, 0x20, 0x0d, 0x0a, 0x61, 0x3d, 0x63, 0x61,
474 /* -0730, */ 0x74, 0x3a, 0x0d, 0x0a, 0x6b, 0x3d, 0x75, 0x72, 0x69, 0x3a, 0x0d, 0x0a, 0x50, 0x72, 0x6f, 0x78,
475 /* -0740, */ 0x79, 0x2d, 0x3b, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x3d, 0x3b, 0x6d, 0x65, 0x74, 0x68, 0x6f,
476 /* -0750, */ 0x64, 0x3d, 0x0d, 0x0a, 0x61, 0x3d, 0x6d, 0x69, 0x64, 0x3a, 0x3b, 0x6d, 0x61, 0x64, 0x64, 0x72,
477 /* -0760, */ 0x3d, 0x6f, 0x70, 0x61, 0x71, 0x75, 0x65, 0x3d, 0x0d, 0x0a, 0x4d, 0x69, 0x6e, 0x2d, 0x3b, 0x61,
478 /* -0770, */ 0x6c, 0x67, 0x3d, 0x4d, 0x6f, 0x6e, 0x2c, 0x20, 0x54, 0x75, 0x65, 0x2c, 0x20, 0x57, 0x65, 0x64,
479 /* -0780, */ 0x2c, 0x20, 0x46, 0x72, 0x69, 0x2c, 0x20, 0x53, 0x61, 0x74, 0x2c, 0x20, 0x3b, 0x74, 0x74, 0x6c,
480 /* -0790, */ 0x3d, 0x61, 0x75, 0x74, 0x73, 0x3d, 0x0d, 0x0a, 0x72, 0x3d, 0x0d, 0x0a, 0x7a, 0x3d, 0x0d, 0x0a,
481 /* -07A0, */ 0x65, 0x3d, 0x3b, 0x69, 0x64, 0x3d, 0x0d, 0x0a, 0x69, 0x3d, 0x63, 0x72, 0x63, 0x3d, 0x0d, 0x0a,
482 /* -07B0, */ 0x75, 0x3d, 0x3b, 0x71, 0x3d, 0x75, 0x61, 0x73, 0x34, 0x31, 0x34, 0x20, 0x52, 0x65, 0x71, 0x75,
483 /* -07C0, */ 0x65, 0x73, 0x74, 0x2d, 0x55, 0x52, 0x49, 0x20, 0x54, 0x6f, 0x6f, 0x20, 0x4c, 0x6f, 0x6e, 0x67,
484 /* -07D0, */ 0x69, 0x76, 0x65, 0x75, 0x70, 0x72, 0x69, 0x76, 0x61, 0x63, 0x79, 0x75, 0x64, 0x70, 0x72, 0x65,
485 /* -07E0, */ 0x66, 0x65, 0x72, 0x36, 0x30, 0x30, 0x20, 0x42, 0x75, 0x73, 0x79, 0x20, 0x45, 0x76, 0x65, 0x72,
486 /* -07F0, */ 0x79, 0x77, 0x68, 0x65, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x34, 0x38, 0x30, 0x20,
487 /* -0800, */ 0x54, 0x65, 0x6d, 0x70, 0x6f, 0x72, 0x61, 0x72, 0x69, 0x6c, 0x79, 0x20, 0x55, 0x6e, 0x61, 0x76,
488 /* -0810, */ 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x0d, 0x0a, 0x61, 0x3d, 0x74, 0x79, 0x70, 0x65, 0x3a,
489 /* -0820, */ 0x48, 0x2e, 0x33, 0x33, 0x32, 0x30, 0x32, 0x20, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64,
490 /* -0830, */ 0x0d, 0x0a, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2d, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65,
491 /* -0840, */ 0x73, 0x3a, 0x20, 0x0d, 0x0a, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f,
492 /* -0850, */ 0x6e, 0x2d, 0x53, 0x74, 0x61, 0x74, 0x65, 0x3a, 0x20, 0x4e, 0x6f, 0x76, 0x20, 0x0d, 0x0a, 0x53,
493 /* -0860, */ 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2d, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x3a, 0x20, 0x53, 0x65,
494 /* -0870, */ 0x70, 0x20, 0x0d, 0x0a, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x2d, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73,
495 /* -0880, */ 0x3a, 0x20, 0x46, 0x65, 0x62, 0x20, 0x0d, 0x0a, 0x61, 0x3d, 0x69, 0x6e, 0x61, 0x63, 0x74, 0x69,
496 /* -0890, */ 0x76, 0x65, 0x52, 0x54, 0x50, 0x2f, 0x53, 0x41, 0x56, 0x50, 0x20, 0x52, 0x54, 0x50, 0x2f, 0x41,
497 /* -08A0, */ 0x56, 0x50, 0x46, 0x20, 0x41, 0x6e, 0x6f, 0x6e, 0x79, 0x6d, 0x6f, 0x75, 0x73, 0x69, 0x70, 0x73,
498 /* -08B0, */ 0x3a, 0x0d, 0x0a, 0x61, 0x3d, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x74, 0x65, 0x73, 0x74, 0x65, 0x6c,
499 /* -08C0, */ 0x3a, 0x4d, 0x45, 0x53, 0x53, 0x41, 0x47, 0x45, 0x20, 0x0d, 0x0a, 0x61, 0x3d, 0x72, 0x65, 0x63,
500 /* -08D0, */ 0x76, 0x6f, 0x6e, 0x6c, 0x79, 0x0d, 0x0a, 0x61, 0x3d, 0x73, 0x65, 0x6e, 0x64, 0x6f, 0x6e, 0x6c,
501 /* -08E0, */ 0x79, 0x0d, 0x0a, 0x63, 0x3d, 0x49, 0x4e, 0x20, 0x49, 0x50, 0x34, 0x20, 0x0d, 0x0a, 0x52, 0x65,
502 /* -08F0, */ 0x61, 0x73, 0x6f, 0x6e, 0x3a, 0x20, 0x0d, 0x0a, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x3a, 0x20, 0x0d,
503 /* -0900, */ 0x0a, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x3a, 0x20, 0x0d, 0x0a, 0x50, 0x61, 0x74, 0x68, 0x3a, 0x20,
504 /* -0910, */ 0x3b, 0x75, 0x73, 0x65, 0x72, 0x3d, 0x0d, 0x0a, 0x62, 0x3d, 0x41, 0x53, 0x20, 0x43, 0x54, 0x20,
505 /* -0920, */ 0x0d, 0x0a, 0x57, 0x57, 0x57, 0x2d, 0x41, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61,
506 /* -0930, */ 0x74, 0x65, 0x3a, 0x20, 0x44, 0x69, 0x67, 0x65, 0x73, 0x74, 0x20, 0x0d, 0x0a, 0x61, 0x3d, 0x73,
507 /* -0940, */ 0x65, 0x6e, 0x64, 0x72, 0x65, 0x63, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x63, 0x74, 0x65, 0x74, 0x2d,
508 /* -0950, */ 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3d, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f,
509 /* -0960, */ 0x6e, 0x2f, 0x73, 0x64, 0x70, 0x61, 0x74, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x70, 0x61,
510 /* -0970, */ 0x75, 0x74, 0x68, 0x3d, 0x0d, 0x0a, 0x61, 0x3d, 0x6f, 0x72, 0x69, 0x65, 0x6e, 0x74, 0x3a, 0x70,
511 /* -0980, */ 0x6f, 0x72, 0x74, 0x72, 0x61, 0x69, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x74, 0x72, 0x2d,
512 /* -0990, */ 0x69, 0x6e, 0x74, 0x69, 0x63, 0x6f, 0x6e, 0x63, 0x3d, 0x34, 0x38, 0x33, 0x20, 0x54, 0x6f, 0x6f,
513 /* -09A0, */ 0x20, 0x4d, 0x61, 0x6e, 0x79, 0x20, 0x48, 0x6f, 0x70, 0x73, 0x6c, 0x69, 0x6e, 0x66, 0x6f, 0x70,
514 /* -09B0, */ 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x3d, 0x36, 0x30,
515 /* -09C0, */ 0x34, 0x20, 0x44, 0x6f, 0x65, 0x73, 0x20, 0x4e, 0x6f, 0x74, 0x20, 0x45, 0x78, 0x69, 0x73, 0x74,
516 /* -09D0, */ 0x20, 0x41, 0x6e, 0x79, 0x77, 0x68, 0x65, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x3d,
517 /* -09E0, */ 0x0d, 0x0a, 0x0d, 0x0a, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2d, 0x44, 0x69, 0x73, 0x70,
518 /* -09F0, */ 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x20, 0x4d, 0x44, 0x35, 0x38, 0x30, 0x20, 0x50,
519 /* -0A00, */ 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x46, 0x61, 0x69, 0x6c,
520 /* -0A10, */ 0x75, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x73, 0x34, 0x32, 0x32, 0x20, 0x53, 0x65, 0x73,
521 /* -0A20, */ 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x20, 0x54, 0x6f,
522 /* -0A30, */ 0x6f, 0x20, 0x53, 0x6d, 0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x31, 0x38, 0x31, 0x20, 0x43,
523 /* -0A40, */ 0x61, 0x6c, 0x6c, 0x20, 0x49, 0x73, 0x20, 0x42, 0x65, 0x69, 0x6e, 0x67, 0x20, 0x46, 0x6f, 0x72,
524 /* -0A50, */ 0x77, 0x61, 0x72, 0x64, 0x65, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x3d, 0x66, 0x61, 0x69, 0x6c,
525 /* -0A60, */ 0x75, 0x72, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x65, 0x61, 0x6c, 0x6d, 0x3d, 0x53, 0x55, 0x42, 0x53,
526 /* -0A70, */ 0x43, 0x52, 0x49, 0x42, 0x45, 0x20, 0x70, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69,
527 /* -0A80, */ 0x6f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x70, 0x73, 0x65, 0x63, 0x2d, 0x6d, 0x61, 0x6e,
528 /* -0A90, */ 0x64, 0x61, 0x74, 0x6f, 0x72, 0x79, 0x34, 0x31, 0x33, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
529 /* -0AA0, */ 0x74, 0x20, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, 0x54, 0x6f, 0x6f, 0x20, 0x4c, 0x61, 0x72,
530 /* -0AB0, */ 0x67, 0x65, 0x32, 0x65, 0x31, 0x38, 0x33, 0x20, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x20,
531 /* -0AC0, */ 0x50, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x63, 0x74, 0x70, 0x34, 0x38, 0x36, 0x20, 0x42,
532 /* -0AD0, */ 0x75, 0x73, 0x79, 0x20, 0x48, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e,
533 /* -0AE0, */ 0x61, 0x74, 0x65, 0x64, 0x41, 0x4b, 0x41, 0x76, 0x31, 0x2d, 0x4d, 0x44, 0x35, 0x2d, 0x73, 0x65,
534 /* -0AF0, */ 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x6f, 0x6e, 0x65, 0x0d, 0x0a, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72,
535 /* -0B00, */ 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x20, 0x36, 0x30, 0x33, 0x20, 0x44, 0x65, 0x63,
536 /* -0B10, */ 0x6c, 0x69, 0x6e, 0x65, 0x78, 0x74, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x3d, 0x34, 0x38, 0x35, 0x20,
537 /* -0B20, */ 0x41, 0x6d, 0x62, 0x69, 0x67, 0x75, 0x6f, 0x75, 0x73, 0x65, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x3d,
538 /* -0B30, */ 0x61, 0x75, 0x64, 0x69, 0x6f, 0x0d, 0x0a, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d, 0x54,
539 /* -0B40, */ 0x79, 0x70, 0x65, 0x3a, 0x20, 0x4d, 0x61, 0x72, 0x20, 0x0d, 0x0a, 0x52, 0x65, 0x63, 0x6f, 0x72,
540 /* -0B50, */ 0x64, 0x2d, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x3a, 0x20, 0x4a, 0x75, 0x6c, 0x20, 0x34, 0x30, 0x31,
541 /* -0B60, */ 0x20, 0x55, 0x6e, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x65, 0x64, 0x0d, 0x0a, 0x52,
542 /* -0B70, */ 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x3a, 0x20, 0x0d, 0x0a, 0x74, 0x3d, 0x30, 0x20, 0x30, 0x2e,
543 /* -0B80, */ 0x30, 0x2e, 0x30, 0x2e, 0x30, 0x0d, 0x0a, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x3a, 0x20, 0x52,
544 /* -0B90, */ 0x45, 0x47, 0x49, 0x53, 0x54, 0x45, 0x52, 0x20, 0x0d, 0x0a, 0x63, 0x3d, 0x49, 0x4e, 0x20, 0x49,
545 /* -0BA0, */ 0x50, 0x36, 0x20, 0x31, 0x38, 0x30, 0x20, 0x52, 0x69, 0x6e, 0x67, 0x69, 0x6e, 0x67, 0x31, 0x30,
546 /* -0BB0, */ 0x30, 0x20, 0x54, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x76, 0x3d, 0x30, 0x0d, 0x0a, 0x6f, 0x3d, 0x55,
547 /* -0BC0, */ 0x50, 0x44, 0x41, 0x54, 0x45, 0x20, 0x4e, 0x4f, 0x54, 0x49, 0x46, 0x59, 0x20, 0x0d, 0x0a, 0x53,
548 /* -0BD0, */ 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x3a, 0x20, 0x75, 0x6e, 0x6b, 0x6e, 0x6f, 0x77,
549 /* -0BE0, */ 0x6e, 0x41, 0x4d, 0x52, 0x54, 0x50, 0x2f, 0x41, 0x56, 0x50, 0x20, 0x0d, 0x0a, 0x50, 0x72, 0x69,
550 /* -0BF0, */ 0x76, 0x61, 0x63, 0x79, 0x3a, 0x20, 0x0d, 0x0a, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79,
551 /* -0C00, */ 0x2d, 0x0d, 0x0a, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x73, 0x3a, 0x20, 0x0d, 0x0a, 0x61, 0x3d,
552 /* -0C10, */ 0x72, 0x74, 0x70, 0x6d, 0x61, 0x70, 0x3a, 0x0d, 0x0a, 0x6d, 0x3d, 0x76, 0x69, 0x64, 0x65, 0x6f,
553 /* -0C20, */ 0x20, 0x0d, 0x0a, 0x6d, 0x3d, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x20, 0x0d, 0x0a, 0x73, 0x3d, 0x20,
554 /* -0C30, */ 0x66, 0x61, 0x6c, 0x73, 0x65, 0x0d, 0x0a, 0x61, 0x3d, 0x63, 0x6f, 0x6e, 0x66, 0x3a, 0x3b, 0x65,
555 /* -0C40, */ 0x78, 0x70, 0x69, 0x72, 0x65, 0x73, 0x3d, 0x0d, 0x0a, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x3a, 0x20,
556 /* -0C50, */ 0x0d, 0x0a, 0x61, 0x3d, 0x66, 0x6d, 0x74, 0x70, 0x3a, 0x0d, 0x0a, 0x61, 0x3d, 0x63, 0x75, 0x72,
557 /* -0C60, */ 0x72, 0x3a, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x3a, 0x20, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79,
558 /* -0C70, */ 0x3a, 0x20, 0x0d, 0x0a, 0x61, 0x3d, 0x64, 0x65, 0x73, 0x3a, 0x0d, 0x0a, 0x52, 0x41, 0x63, 0x6b,
559 /* -0C80, */ 0x3a, 0x20, 0x0d, 0x0a, 0x52, 0x53, 0x65, 0x71, 0x3a, 0x20, 0x42, 0x59, 0x45, 0x20, 0x63, 0x6e,
560 /* -0C90, */ 0x6f, 0x6e, 0x63, 0x65, 0x3d, 0x31, 0x30, 0x30, 0x72, 0x65, 0x6c, 0x75, 0x72, 0x69, 0x3d, 0x71,
561 /* -0CA0, */ 0x6f, 0x70, 0x3d, 0x54, 0x43, 0x50, 0x55, 0x44, 0x50, 0x71, 0x6f, 0x73, 0x78, 0x6d, 0x6c, 0x3b,
562 /* -0CB0, */ 0x6c, 0x72, 0x0d, 0x0a, 0x56, 0x69, 0x61, 0x3a, 0x20, 0x53, 0x49, 0x50, 0x2f, 0x32, 0x2e, 0x30,
563 /* -0CC0, */ 0x2f, 0x54, 0x43, 0x50, 0x20, 0x34, 0x30, 0x38, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
564 /* -0CD0, */ 0x20, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x69, 0x6d, 0x65, 0x72, 0x70, 0x73, 0x69, 0x70,
565 /* -0CE0, */ 0x3a, 0x0d, 0x0a, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d, 0x4c, 0x65, 0x6e, 0x67, 0x74,
566 /* -0CF0, */ 0x68, 0x3a, 0x20, 0x4f, 0x63, 0x74, 0x20, 0x0d, 0x0a, 0x56, 0x69, 0x61, 0x3a, 0x20, 0x53, 0x49,
567 /* -0D00, */ 0x50, 0x2f, 0x32, 0x2e, 0x30, 0x2f, 0x55, 0x44, 0x50, 0x20, 0x3b, 0x63, 0x6f, 0x6d, 0x70, 0x3d,
568 /* -0D10, */ 0x73, 0x69, 0x67, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x6f, 0x62, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61,
569 /* -0D20, */ 0x63, 0x6b, 0x3b, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x3d, 0x7a, 0x39, 0x68, 0x47, 0x34, 0x62,
570 /* -0D30, */ 0x4b, 0x0d, 0x0a, 0x4d, 0x61, 0x78, 0x2d, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x73, 0x3a,
571 /* -0D40, */ 0x20, 0x41, 0x70, 0x72, 0x20, 0x53, 0x43, 0x54, 0x50, 0x52, 0x41, 0x43, 0x4b, 0x20, 0x49, 0x4e,
572 /* -0D50, */ 0x56, 0x49, 0x54, 0x45, 0x20, 0x0d, 0x0a, 0x43, 0x61, 0x6c, 0x6c, 0x2d, 0x49, 0x44, 0x3a, 0x20,
573 /* -0D60, */ 0x0d, 0x0a, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x63, 0x74, 0x3a, 0x20, 0x32, 0x30, 0x30, 0x20, 0x4f,
574 /* -0D70, */ 0x4b, 0x0d, 0x0a, 0x46, 0x72, 0x6f, 0x6d, 0x3a, 0x20, 0x0d, 0x0a, 0x43, 0x53, 0x65, 0x71, 0x3a,
575 /* -0D80, */ 0x20, 0x0d, 0x0a, 0x54, 0x6f, 0x3a, 0x20, 0x3b, 0x74, 0x61, 0x67, 0x3d, 0x04, 0x10, 0xdd, 0x10,
576 /* -0D90, */ 0x11, 0x31, 0x0d, 0x11, 0x0a, 0x07, 0x10, 0xb9, 0x0c, 0x10, 0xfe, 0x12, 0x10, 0xe1, 0x06, 0x11,
577 /* -0DA0, */ 0x4e, 0x07, 0x11, 0x4e, 0x03, 0x11, 0x4a, 0x04, 0x11, 0x4a, 0x07, 0x10, 0xb2, 0x08, 0x11, 0x79,
578 /* -0DB0, */ 0x06, 0x11, 0x81, 0x0f, 0x11, 0x22, 0x0b, 0x11, 0x55, 0x06, 0x11, 0x6b, 0x0b, 0x11, 0x60, 0x13,
579 /* -0DC0, */ 0x10, 0xb2, 0x08, 0x11, 0x71, 0x05, 0x11, 0x87, 0x13, 0x10, 0xf7, 0x09, 0x0e, 0x8d, 0x08, 0x0d,
580 /* -0DD0, */ 0xae, 0x0c, 0x10, 0xb9, 0x07, 0x10, 0x8e, 0x03, 0x0d, 0x96, 0x03, 0x10, 0x8a, 0x04, 0x10, 0x8a,
581 /* -0DE0, */ 0x09, 0x0d, 0xd7, 0x0a, 0x0f, 0x12, 0x08, 0x0f, 0x8f, 0x09, 0x0f, 0x8f, 0x08, 0x0d, 0x6c, 0x06,
582 /* -0DF0, */ 0x0e, 0x66, 0x09, 0x0e, 0x6c, 0x0a, 0x0e, 0x6c, 0x06, 0x0f, 0xc6, 0x07, 0x0f, 0xc6, 0x05, 0x11,
583 /* -0E00, */ 0x48, 0x06, 0x11, 0x48, 0x06, 0x0f, 0xbf, 0x07, 0x0f, 0xbf, 0x07, 0x0e, 0x55, 0x06, 0x0f, 0x16,
584 /* -0E10, */ 0x04, 0x0e, 0xf4, 0x03, 0x0e, 0xb1, 0x03, 0x10, 0xa6, 0x09, 0x10, 0x50, 0x03, 0x10, 0xa3, 0x0a,
585 /* -0E20, */ 0x0d, 0xb4, 0x05, 0x0e, 0x36, 0x06, 0x0e, 0xd6, 0x03, 0x0d, 0xf9, 0x11, 0x0e, 0xf8, 0x04, 0x0c,
586 /* -0E30, */ 0xd9, 0x08, 0x0e, 0xea, 0x04, 0x09, 0x53, 0x03, 0x0a, 0x4b, 0x04, 0x0e, 0xe4, 0x10, 0x0f, 0x35,
587 /* -0E40, */ 0x09, 0x0e, 0xe4, 0x08, 0x0d, 0x3f, 0x03, 0x0f, 0xe1, 0x0b, 0x10, 0x01, 0x03, 0x10, 0xac, 0x06,
588 /* -0E50, */ 0x10, 0x95, 0x0c, 0x0e, 0x76, 0x0b, 0x0f, 0xeb, 0x0a, 0x0f, 0xae, 0x05, 0x10, 0x2b, 0x04, 0x10,
589 /* -0E60, */ 0x2b, 0x08, 0x10, 0x7a, 0x10, 0x0f, 0x49, 0x07, 0x0f, 0xb8, 0x09, 0x10, 0x3e, 0x0b, 0x10, 0x0c,
590 /* -0E70, */ 0x07, 0x0f, 0x78, 0x0b, 0x0f, 0x6d, 0x09, 0x10, 0x47, 0x08, 0x10, 0x82, 0x0b, 0x0f, 0xf6, 0x08,
591 /* -0E80, */ 0x10, 0x62, 0x08, 0x0f, 0x87, 0x08, 0x10, 0x6a, 0x04, 0x0f, 0x78, 0x0d, 0x0f, 0xcd, 0x08, 0x0d,
592 /* -0E90, */ 0xae, 0x10, 0x0f, 0x5d, 0x0b, 0x0f, 0x98, 0x14, 0x0d, 0x20, 0x1b, 0x0d, 0x20, 0x04, 0x0d, 0xe0,
593 /* -0EA0, */ 0x14, 0x0e, 0xb4, 0x0b, 0x0f, 0xa3, 0x0b, 0x07, 0x34, 0x0f, 0x0d, 0x56, 0x04, 0x0e, 0xf4, 0x03,
594 /* -0EB0, */ 0x10, 0xaf, 0x07, 0x0d, 0x34, 0x09, 0x0f, 0x27, 0x04, 0x10, 0x9b, 0x04, 0x10, 0x9f, 0x09, 0x10,
595 /* -0EC0, */ 0x59, 0x08, 0x10, 0x72, 0x09, 0x10, 0x35, 0x0a, 0x10, 0x21, 0x0a, 0x10, 0x17, 0x08, 0x0f, 0xe3,
596 /* -0ED0, */ 0x03, 0x10, 0xa9, 0x05, 0x0c, 0xac, 0x04, 0x0c, 0xbd, 0x07, 0x0c, 0xc1, 0x08, 0x0c, 0xc1, 0x09,
597 /* -0EE0, */ 0x0c, 0xf6, 0x10, 0x0c, 0x72, 0x0c, 0x0c, 0x86, 0x04, 0x0d, 0x64, 0x0c, 0x0c, 0xd5, 0x09, 0x0c,
598 /* -0EF0, */ 0xff, 0x1b, 0x0b, 0xfc, 0x11, 0x0c, 0x5d, 0x13, 0x0c, 0x30, 0x09, 0x0c, 0xa4, 0x0c, 0x0c, 0x24,
599 /* -0F00, */ 0x0c, 0x0d, 0x3b, 0x03, 0x0d, 0x1a, 0x03, 0x0d, 0x1d, 0x16, 0x0c, 0x43, 0x09, 0x0c, 0x92, 0x09,
600 /* -0F10, */ 0x0c, 0x9b, 0x0d, 0x0e, 0xcb, 0x04, 0x0d, 0x16, 0x06, 0x0d, 0x10, 0x05, 0x04, 0xf2, 0x0b, 0x0c,
601 /* -0F20, */ 0xe1, 0x05, 0x0b, 0xde, 0x0a, 0x0c, 0xec, 0x13, 0x0b, 0xe3, 0x07, 0x0b, 0xd4, 0x08, 0x0d, 0x08,
602 /* -0F30, */ 0x0c, 0x0c, 0xc9, 0x09, 0x0c, 0x3a, 0x04, 0x0a, 0xe5, 0x0c, 0x0a, 0x23, 0x08, 0x0b, 0x3a, 0x0e,
603 /* -0F40, */ 0x09, 0xab, 0x0f, 0x0e, 0xfa, 0x09, 0x0f, 0x6f, 0x0c, 0x0a, 0x17, 0x0f, 0x09, 0x76, 0x0c, 0x0a,
604 /* -0F50, */ 0x5f, 0x17, 0x0d, 0xe2, 0x0f, 0x07, 0xa8, 0x0a, 0x0f, 0x85, 0x0f, 0x08, 0xd6, 0x0e, 0x09, 0xb9,
605 /* -0F60, */ 0x0b, 0x0a, 0x7a, 0x03, 0x0b, 0xdb, 0x03, 0x08, 0xc1, 0x04, 0x0e, 0xc7, 0x03, 0x08, 0xd3, 0x02,
606 /* -0F70, */ 0x04, 0x8d, 0x08, 0x0b, 0x4a, 0x05, 0x0b, 0x8c, 0x07, 0x0b, 0x61, 0x06, 0x05, 0x48, 0x04, 0x07,
607 /* -0F80, */ 0xf4, 0x05, 0x10, 0x30, 0x04, 0x07, 0x1e, 0x08, 0x07, 0x1e, 0x05, 0x0b, 0x91, 0x10, 0x04, 0xca,
608 /* -0F90, */ 0x09, 0x0a, 0x71, 0x09, 0x0e, 0x87, 0x05, 0x04, 0x98, 0x05, 0x0b, 0x6e, 0x0b, 0x04, 0x9b, 0x0f,
609 /* -0FA0, */ 0x04, 0x9b, 0x07, 0x04, 0x9b, 0x03, 0x04, 0xa3, 0x07, 0x04, 0xa3, 0x10, 0x07, 0x98, 0x09, 0x07,
610 /* -0FB0, */ 0x98, 0x05, 0x0b, 0x73, 0x05, 0x0b, 0x78, 0x05, 0x0b, 0x7d, 0x05, 0x07, 0xb9, 0x05, 0x0b, 0x82,
611 /* -0FC0, */ 0x05, 0x0b, 0x87, 0x05, 0x0b, 0x1d, 0x05, 0x08, 0xe4, 0x05, 0x0c, 0x81, 0x05, 0x0f, 0x44, 0x05,
612 /* -0FD0, */ 0x11, 0x40, 0x05, 0x08, 0x78, 0x05, 0x08, 0x9d, 0x05, 0x0f, 0x58, 0x05, 0x07, 0x3f, 0x05, 0x0c,
613 /* -0FE0, */ 0x6d, 0x05, 0x10, 0xf2, 0x05, 0x0c, 0x58, 0x05, 0x06, 0xa9, 0x04, 0x07, 0xb6, 0x09, 0x05, 0x8c,
614 /* -0FF0, */ 0x06, 0x06, 0x1a, 0x06, 0x0e, 0x81, 0x0a, 0x06, 0x16, 0x0a, 0x0a, 0xc4, 0x07, 0x0b, 0x5a, 0x0a,
615 /* -1000, */ 0x0a, 0xba, 0x03, 0x0b, 0x1b, 0x04, 0x11, 0x45, 0x06, 0x0c, 0x8c, 0x07, 0x05, 0xad, 0x0a, 0x0e,
616 /* -1010, */ 0xda, 0x08, 0x0b, 0x42, 0x0d, 0x09, 0xf7, 0x0b, 0x05, 0x1c, 0x09, 0x11, 0x16, 0x08, 0x05, 0xc9,
617 /* -1020, */ 0x07, 0x0d, 0x86, 0x06, 0x0b, 0xcf, 0x0a, 0x06, 0x4d, 0x04, 0x0b, 0xa2, 0x06, 0x06, 0x8d, 0x08,
618 /* -1030, */ 0x05, 0xe6, 0x08, 0x0e, 0x11, 0x0b, 0x0a, 0x9b, 0x03, 0x0a, 0x04, 0x03, 0x0b, 0xb5, 0x05, 0x10,
619 /* -1040, */ 0xd7, 0x04, 0x09, 0x94, 0x05, 0x0a, 0xe2, 0x03, 0x0b, 0xb2, 0x06, 0x0d, 0x67, 0x04, 0x0d, 0x11,
620 /* -1050, */ 0x08, 0x08, 0xb7, 0x1b, 0x0e, 0x3b, 0x0a, 0x09, 0xa1, 0x14, 0x04, 0x85, 0x15, 0x07, 0x83, 0x15,
621 /* -1060, */ 0x07, 0x6e, 0x0d, 0x09, 0x3d, 0x17, 0x06, 0xae, 0x0f, 0x07, 0xe6, 0x14, 0x07, 0xbe, 0x0d, 0x06,
622 /* -1070, */ 0x0a, 0x0d, 0x09, 0x30, 0x16, 0x06, 0xf2, 0x12, 0x08, 0x1e, 0x21, 0x04, 0xaa, 0x13, 0x10, 0xc5,
623 /* -1080, */ 0x08, 0x0a, 0x0f, 0x1c, 0x0e, 0x96, 0x18, 0x0b, 0xb8, 0x1a, 0x05, 0x95, 0x1a, 0x05, 0x75, 0x11,
624 /* -1090, */ 0x06, 0x3d, 0x16, 0x06, 0xdc, 0x1e, 0x0e, 0x19, 0x16, 0x05, 0xd1, 0x1d, 0x06, 0x20, 0x23, 0x05,
625 /* -10A0, */ 0x27, 0x11, 0x08, 0x7d, 0x11, 0x0d, 0x99, 0x16, 0x04, 0xda, 0x0d, 0x0f, 0x1c, 0x16, 0x07, 0x08,
626 /* -10B0, */ 0x17, 0x05, 0xb4, 0x0d, 0x08, 0xc7, 0x13, 0x07, 0xf8, 0x12, 0x08, 0x57, 0x1f, 0x04, 0xfe, 0x19,
627 /* -10C0, */ 0x05, 0x4e, 0x13, 0x08, 0x0b, 0x0f, 0x08, 0xe9, 0x17, 0x06, 0xc5, 0x13, 0x06, 0x7b, 0x19, 0x05,
628 /* -10D0, */ 0xf1, 0x15, 0x07, 0x44, 0x18, 0x0d, 0xfb, 0x0b, 0x0f, 0x09, 0x1b, 0x0d, 0xbe, 0x12, 0x08, 0x30,
629 /* -10E0, */ 0x15, 0x07, 0x59, 0x04, 0x0b, 0xa6, 0x04, 0x0b, 0xae, 0x04, 0x0b, 0x9e, 0x04, 0x0b, 0x96, 0x04,
630 /* -10F0, */ 0x0b, 0x9a, 0x0a, 0x0a, 0xb0, 0x0b, 0x0a, 0x90, 0x08, 0x0b, 0x32, 0x0b, 0x09, 0x6b, 0x08, 0x0b,
631 /* -1100, */ 0x2a, 0x0b, 0x0a, 0x85, 0x09, 0x0b, 0x12, 0x0a, 0x0a, 0xa6, 0x0d, 0x09, 0xea, 0x13, 0x0d, 0x74,
632 /* -1110, */ 0x14, 0x07, 0xd2, 0x13, 0x09, 0x0b, 0x12, 0x08, 0x42, 0x10, 0x09, 0x5b, 0x12, 0x09, 0x1e, 0x0d,
633 /* -1120, */ 0x0c, 0xb1, 0x0e, 0x0c, 0x17, 0x11, 0x09, 0x4a, 0x0c, 0x0a, 0x53, 0x0c, 0x0a, 0x47, 0x09, 0x0a,
634 /* -1130, */ 0xf7, 0x0e, 0x09, 0xc7, 0x0c, 0x0a, 0x3b, 0x07, 0x06, 0x69, 0x08, 0x06, 0x69, 0x06, 0x09, 0xe3,
635 /* -1140, */ 0x08, 0x0b, 0x52, 0x0a, 0x0a, 0xd8, 0x12, 0x06, 0x57, 0x0d, 0x06, 0x57, 0x07, 0x09, 0xe3, 0x04,
636 /* -1150, */ 0x0a, 0xe9, 0x10, 0x07, 0x30, 0x09, 0x0b, 0x00, 0x0c, 0x0a, 0x2f, 0x05, 0x0a, 0xe9, 0x05, 0x0a,
637 /* -1160, */ 0x6b, 0x06, 0x0a, 0x6b, 0x0a, 0x0a, 0xce, 0x09, 0x0a, 0xee, 0x03, 0x0b, 0xdb, 0x07, 0x0f, 0x7e,
638 /* -1170, */ 0x0a, 0x09, 0x97, 0x0a, 0x06, 0x71, 0x0e, 0x09, 0xd5, 0x17, 0x06, 0x93, 0x07, 0x0e, 0x5c, 0x07,
639 /* -1180, */ 0x0f, 0xda, 0x0a, 0x0f, 0x35, 0x0d, 0x0d, 0xec, 0x0a, 0x09, 0x97, 0x0a, 0x06, 0x71, 0x08, 0x0b,
640 /* -1190, */ 0x22, 0x0f, 0x09, 0x85, 0x06, 0x0b, 0x68, 0x0c, 0x0d, 0x4a, 0x09, 0x0b, 0x09, 0x13, 0x08, 0xf8,
641 /* -11A0, */ 0x15, 0x08, 0xa2, 0x04, 0x0b, 0xaa, 0x0f, 0x05, 0x66, 0x0d, 0x07, 0x23, 0x09, 0x0a, 0x06, 0x0b,
642 /* -11B0, */ 0x0d, 0x4a, 0x0f, 0x04, 0xee, 0x06, 0x04, 0xf8, 0x04, 0x09, 0x2b, 0x04, 0x08, 0x53, 0x07, 0x08,
643 /* -11C0, */ 0xc0, 0x03, 0x11, 0x1f, 0x04, 0x11, 0x1e, 0x07, 0x0d, 0x8c, 0x03, 0x07, 0x34, 0x04, 0x10, 0xdb,
644 /* -11D0, */ 0x03, 0x07, 0x36, 0x03, 0x0d, 0xa9, 0x0d, 0x04, 0x20, 0x0b, 0x04, 0x51, 0x0c, 0x04, 0x3a, 0x04,
645 /* -11E0, */ 0x0b, 0xb8, 0x04, 0x0c, 0x24, 0x04, 0x05, 0x95, 0x04, 0x04, 0x7c, 0x04, 0x05, 0x75, 0x04, 0x04,
646 /* -11F0, */ 0x85, 0x04, 0x09, 0x6b, 0x04, 0x06, 0x3d, 0x06, 0x04, 0x7b, 0x04, 0x06, 0xdc, 0x04, 0x07, 0x83,
647 /* -1200, */ 0x04, 0x0e, 0x19, 0x12, 0x04, 0x00, 0x10, 0x08, 0x8e, 0x10, 0x08, 0x69, 0x0e, 0x04, 0x12, 0x0d,
648 /* -1210, */ 0x04, 0x2d, 0x03, 0x10, 0xb9, 0x04, 0x05, 0xd1, 0x04, 0x07, 0x6e, 0x04, 0x06, 0x20, 0x07, 0x04,
649 /* -1220, */ 0x74, 0x04, 0x0b, 0xfc, 0x0a, 0x04, 0x5c, 0x04, 0x05, 0x27, 0x04, 0x09, 0x3d, 0x04, 0x08, 0x7d,
650 /* -1230, */ 0x04, 0x0f, 0xae, 0x04, 0x0d, 0x99, 0x04, 0x06, 0xae, 0x04, 0x04, 0xda, 0x09, 0x04, 0x09, 0x08,
651 /* -1240, */ 0x11, 0x22, 0x04, 0x0f, 0x1c, 0x04, 0x07, 0xe6, 0x04, 0x0e, 0xcb, 0x05, 0x08, 0xbd, 0x04, 0x07,
652 /* -1250, */ 0x08, 0x04, 0x0f, 0xa3, 0x04, 0x06, 0x57, 0x04, 0x05, 0xb4, 0x04, 0x0f, 0x5d, 0x04, 0x08, 0xc7,
653 /* -1260, */ 0x08, 0x0b, 0xf4, 0x04, 0x07, 0xf8, 0x04, 0x07, 0x30, 0x04, 0x07, 0xbe, 0x04, 0x08, 0x57, 0x05,
654 /* -1270, */ 0x0d, 0x46, 0x04, 0x04, 0xfe, 0x04, 0x06, 0x0a, 0x04, 0x05, 0x4e, 0x04, 0x0e, 0x3b, 0x04, 0x08,
655 /* -1280, */ 0x0b, 0x04, 0x09, 0x30, 0x04, 0x08, 0xe9, 0x05, 0x05, 0xee, 0x04, 0x06, 0xc5, 0x04, 0x06, 0xf2,
656 /* -1290, */ 0x04, 0x06, 0x7b, 0x04, 0x09, 0xa1, 0x04, 0x05, 0xf1, 0x04, 0x08, 0x1e, 0x04, 0x07, 0x44, 0x04,
657 /* -12A0, */ 0x0b, 0xdd, 0x04, 0x0d, 0xfb, 0x04, 0x04, 0xaa, 0x04, 0x0b, 0xe3, 0x07, 0x0e, 0xee, 0x04, 0x0f,
658 /* -12B0, */ 0x09, 0x04, 0x0e, 0xb4, 0x04, 0x0d, 0xbe, 0x04, 0x10, 0xc5, 0x04, 0x08, 0x30, 0x05, 0x0f, 0x30,
659 /* -12C0, */ 0x04, 0x07, 0x59, 0x04, 0x0a, 0x0f, 0x06, 0x0e, 0x61, 0x04, 0x04, 0x81, 0x04, 0x0d, 0xab, 0x04,
660 /* -12D0, */ 0x0d, 0x93, 0x04, 0x11, 0x6b, 0x04, 0x0e, 0x96, 0x05, 0x04, 0x66, 0x09, 0x04, 0x6b, 0x0b, 0x04,
663 };
665 /*
666 * Definitions for:
667 * The Presence-Specific Static Dictionary for Signaling
668 * https://www.ietf.org/rfc/rfc5112
669 */
670 #define PRESENCE_STATE_LENGTH 0x0d93
673 {
674 /* -0000, */ 0xd9, 0x42, 0x29, 0x7d, 0x0b, 0xb3, 0x8f, 0xc0, 0x1d, 0x67, 0x41, 0xd6, 0xb3, 0xb4, 0x81, 0x57,
676 };
679 {
680 /* -0000, */ 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x63, 0x65, 0x6e, 0x74, 0x65,
681 /* -0010, */ 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x64, 0x65, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64,
682 /* -0020, */ 0x69, 0x73, 0x67, 0x75, 0x73, 0x74, 0x65, 0x64, 0x69, 0x6e, 0x64, 0x75, 0x73, 0x74, 0x72, 0x69,
683 /* -0030, */ 0x61, 0x6c, 0x61, 0x73, 0x74, 0x2d, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x3d, 0x68, 0x75, 0x6d, 0x69,
684 /* -0040, */ 0x6c, 0x69, 0x61, 0x74, 0x65, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x3d, 0x61, 0x75, 0x74, 0x6f,
685 /* -0050, */ 0x6d, 0x6f, 0x62, 0x69, 0x6c, 0x65, 0x63, 0x75, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x70, 0x69, 0x72,
686 /* -0060, */ 0x69, 0x74, 0x73, 0x2d, 0x49, 0x4e, 0x44, 0x50, 0x73, 0x65, 0x6e, 0x64, 0x2d, 0x6f, 0x6e, 0x6c,
687 /* -0070, */ 0x79, 0x70, 0x61, 0x74, 0x68, 0x65, 0x61, 0x74, 0x65, 0x72, 0x65, 0x73, 0x74, 0x6c, 0x65, 0x73,
688 /* -0080, */ 0x73, 0x6c, 0x65, 0x65, 0x70, 0x79, 0x69, 0x6e, 0x2d, 0x70, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x61,
689 /* -0090, */ 0x6c, 0x6f, 0x6e, 0x65, 0x6c, 0x79, 0x70, 0x6c, 0x61, 0x79, 0x66, 0x75, 0x6c, 0x6f, 0x77, 0x65,
690 /* -00A0, */ 0x72, 0x74, 0x68, 0x61, 0x6e, 0x6e, 0x6f, 0x79, 0x65, 0x64, 0x75, 0x6e, 0x63, 0x6f, 0x6d, 0x66,
691 /* -00B0, */ 0x6f, 0x72, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x3d, 0x63, 0x6f,
692 /* -00C0, */ 0x6e, 0x66, 0x75, 0x73, 0x65, 0x64, 0x76, 0x61, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x63, 0x6c,
693 /* -00D0, */ 0x75, 0x62, 0x75, 0x73, 0x2d, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x63,
694 /* -00E0, */ 0x72, 0x61, 0x66, 0x74, 0x68, 0x69, 0x72, 0x73, 0x74, 0x79, 0x63, 0x6f, 0x75, 0x72, 0x69, 0x65,
695 /* -00F0, */ 0x72, 0x65, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x68, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x66, 0x6f,
696 /* -0100, */ 0x66, 0x66, 0x69, 0x63, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x3d, 0x61, 0x72, 0x65, 0x6e,
697 /* -0110, */ 0x61, 0x62, 0x6c, 0x65, 0x64, 0x3d, 0x52, 0x45, 0x46, 0x45, 0x52, 0x45, 0x47, 0x49, 0x53, 0x54,
698 /* -0120, */ 0x45, 0x52, 0x77, 0x61, 0x69, 0x74, 0x69, 0x6e, 0x67, 0x72, 0x75, 0x6d, 0x70, 0x79, 0x70, 0x72,
699 /* -0130, */ 0x65, 0x66, 0x69, 0x78, 0x3d, 0x68, 0x61, 0x6c, 0x66, 0x72, 0x65, 0x69, 0x67, 0x68, 0x74, 0x6d,
700 /* -0140, */ 0x65, 0x61, 0x6e, 0x67, 0x72, 0x79, 0x53, 0x55, 0x42, 0x53, 0x43, 0x52, 0x49, 0x42, 0x45, 0x70,
701 /* -0150, */ 0x72, 0x6f, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x3d,
702 /* -0160, */ 0x61, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x64, 0x68, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x79, 0x75,
703 /* -0170, */ 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x70, 0x61, 0x72, 0x6b, 0x69, 0x6e, 0x67, 0x4d, 0x45, 0x53,
704 /* -0180, */ 0x53, 0x41, 0x47, 0x45, 0x77, 0x6f, 0x72, 0x72, 0x69, 0x65, 0x64, 0x68, 0x75, 0x6d, 0x62, 0x6c,
705 /* -0190, */ 0x65, 0x64, 0x61, 0x69, 0x72, 0x70, 0x6f, 0x72, 0x74, 0x61, 0x73, 0x68, 0x61, 0x6d, 0x65, 0x64,
706 /* -01A0, */ 0x70, 0x6c, 0x61, 0x79, 0x69, 0x6e, 0x67, 0x50, 0x55, 0x42, 0x4c, 0x49, 0x53, 0x48, 0x68, 0x75,
707 /* -01B0, */ 0x6e, 0x67, 0x72, 0x79, 0x63, 0x72, 0x61, 0x6e, 0x6b, 0x79, 0x61, 0x6d, 0x61, 0x7a, 0x65, 0x64,
708 /* -01C0, */ 0x61, 0x66, 0x72, 0x61, 0x69, 0x64, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x4e, 0x4f, 0x54, 0x49,
709 /* -01D0, */ 0x46, 0x59, 0x49, 0x4e, 0x56, 0x49, 0x54, 0x45, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x66, 0x72,
710 /* -01E0, */ 0x69, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x73, 0x74, 0x61, 0x6c, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79,
711 /* -01F0, */ 0x70, 0x72, 0x69, 0x73, 0x6f, 0x6e, 0x69, 0x6e, 0x5f, 0x61, 0x77, 0x65, 0x62, 0x72, 0x61, 0x76,
712 /* -0200, */ 0x65, 0x71, 0x75, 0x69, 0x65, 0x74, 0x62, 0x6f, 0x72, 0x65, 0x64, 0x50, 0x52, 0x41, 0x43, 0x4b,
713 /* -0210, */ 0x70, 0x72, 0x6f, 0x75, 0x64, 0x66, 0x69, 0x78, 0x65, 0x64, 0x68, 0x6f, 0x74, 0x65, 0x6c, 0x68,
714 /* -0220, */ 0x61, 0x70, 0x70, 0x79, 0x63, 0x61, 0x66, 0x65, 0x63, 0x69, 0x64, 0x3d, 0x62, 0x61, 0x6e, 0x6b,
715 /* -0230, */ 0x6d, 0x69, 0x6e, 0x3d, 0x61, 0x77, 0x61, 0x79, 0x6d, 0x61, 0x78, 0x3d, 0x6d, 0x65, 0x61, 0x6c,
716 /* -0240, */ 0x62, 0x75, 0x73, 0x79, 0x77, 0x6f, 0x72, 0x6b, 0x75, 0x72, 0x6e, 0x3d, 0x63, 0x6f, 0x6c, 0x64,
717 /* -0250, */ 0x68, 0x75, 0x72, 0x74, 0x6a, 0x65, 0x61, 0x6c, 0x6f, 0x75, 0x73, 0x70, 0x69, 0x72, 0x69, 0x74,
718 /* -0260, */ 0x73, 0x2d, 0x75, 0x73, 0x65, 0x72, 0x2d, 0x70, 0x72, 0x6f, 0x67, 0x6f, 0x76, 0x65, 0x72, 0x6e,
719 /* -0270, */ 0x6d, 0x65, 0x6e, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x2d, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e,
720 /* -0280, */ 0x6f, 0x72, 0x65, 0x66, 0x65, 0x72, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x66,
721 /* -0290, */ 0x6f, 0x72, 0x65, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2d,
722 /* -02A0, */ 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x73,
723 /* -02B0, */ 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x64, 0x3d, 0x68, 0x69, 0x67, 0x68, 0x65, 0x72,
724 /* -02C0, */ 0x74, 0x68, 0x61, 0x6e, 0x78, 0x69, 0x6f, 0x75, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2d,
725 /* -02D0, */ 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x62, 0x72, 0x65, 0x61,
726 /* -02E0, */ 0x6b, 0x66, 0x61, 0x73, 0x74, 0x61, 0x64, 0x69, 0x75, 0x6d, 0x73, 0x67, 0x2d, 0x74, 0x61, 0x6b,
727 /* -02F0, */ 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x72, 0x73, 0x65, 0x66, 0x75, 0x6c, 0x6c, 0x3a, 0x63, 0x69, 0x76,
728 /* -0300, */ 0x69, 0x63, 0x4c, 0x6f, 0x63, 0x6f, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x71, 0x75,
729 /* -0310, */ 0x61, 0x6c, 0x73, 0x74, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x77, 0x61, 0x74, 0x65, 0x72, 0x63,
730 /* -0320, */ 0x72, 0x61, 0x66, 0x74, 0x65, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x3a, 0x62, 0x61, 0x73, 0x69, 0x63,
731 /* -0330, */ 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x63, 0x6c, 0x65, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x79,
732 /* -0340, */ 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64, 0x75, 0x6e, 0x74, 0x69, 0x6c, 0x3d, 0x61, 0x64, 0x64,
733 /* -0350, */ 0x65, 0x64, 0x75, 0x72, 0x69, 0x3d, 0x77, 0x68, 0x61, 0x74, 0x70, 0x65, 0x72, 0x6d, 0x61, 0x6e,
734 /* -0360, */ 0x65, 0x6e, 0x74, 0x2d, 0x61, 0x62, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x6d, 0x62, 0x61, 0x72, 0x72,
735 /* -0370, */ 0x61, 0x73, 0x73, 0x65, 0x64, 0x65, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x64, 0x69,
736 /* -0380, */ 0x73, 0x74, 0x72, 0x61, 0x63, 0x74, 0x65, 0x64, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x76, 0x6f, 0x75,
737 /* -0390, */ 0x73, 0x65, 0x6c, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x65, 0x6c, 0x69, 0x65, 0x76, 0x65, 0x64,
738 /* -03A0, */ 0x66, 0x6c, 0x69, 0x72, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x75, 0x73, 0x61, 0x67, 0x65, 0x2d, 0x72,
739 /* -03B0, */ 0x75, 0x6c, 0x65, 0x73, 0x65, 0x72, 0x76, 0x63, 0x61, 0x70, 0x73, 0x70, 0x68, 0x65, 0x72, 0x65,
740 /* -03C0, */ 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x73, 0x74, 0x61, 0x74, 0x65,
741 /* -03D0, */ 0x3d, 0x62, 0x61, 0x72, 0x72, 0x69, 0x6e, 0x67, 0x2d, 0x73, 0x74, 0x61, 0x74, 0x65, 0x78, 0x74,
742 /* -03E0, */ 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2d, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x65, 0x74, 0x69, 0x6d, 0x65,
743 /* -03F0, */ 0x2d, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x64, 0x69, 0x61, 0x6c, 0x6f, 0x67, 0x69, 0x6e, 0x5f,
744 /* -0400, */ 0x6c, 0x6f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x69, 0x6e, 0x67, 0x2d, 0x77, 0x69, 0x6c, 0x6c,
745 /* -0410, */ 0x69, 0x6e, 0x67, 0x6e, 0x65, 0x73, 0x73, 0x70, 0x65, 0x63, 0x74, 0x61, 0x74, 0x6f, 0x72, 0x65,
746 /* -0420, */ 0x73, 0x69, 0x64, 0x65, 0x6e, 0x63, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2d, 0x70, 0x61, 0x63, 0x6b,
747 /* -0430, */ 0x61, 0x67, 0x65, 0x73, 0x75, 0x70, 0x65, 0x72, 0x76, 0x69, 0x73, 0x6f, 0x72, 0x65, 0x73, 0x74,
748 /* -0440, */ 0x61, 0x75, 0x72, 0x61, 0x6e, 0x74, 0x72, 0x75, 0x63, 0x6b, 0x70, 0x6c, 0x6d, 0x6f, 0x62, 0x69,
749 /* -0450, */ 0x6c, 0x69, 0x74, 0x79, 0x6a, 0x6f, 0x69, 0x6e, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x70, 0x72, 0x69,
750 /* -0460, */ 0x61, 0x74, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x65, 0x72, 0x69, 0x6e,
751 /* -0470, */ 0x67, 0x69, 0x76, 0x65, 0x75, 0x70, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x61, 0x6e,
752 /* -0480, */ 0x67, 0x75, 0x61, 0x67, 0x65, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
753 /* -0490, */ 0x2d, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x2d, 0x6f, 0x66,
754 /* -04A0, */ 0x2d, 0x77, 0x6f, 0x72, 0x73, 0x68, 0x69, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x2d, 0x74, 0x79, 0x70,
755 /* -04B0, */ 0x65, 0x3d, 0x3a, 0x74, 0x69, 0x6d, 0x65, 0x64, 0x2d, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2d,
756 /* -04C0, */ 0x69, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x75, 0x74,
757 /* -04D0, */ 0x72, 0x61, 0x6c, 0x49, 0x4e, 0x46, 0x4f, 0x50, 0x54, 0x49, 0x4f, 0x4e, 0x53, 0x69, 0x65, 0x6d,
758 /* -04E0, */ 0x65, 0x6e, 0x73, 0x2d, 0x52, 0x54, 0x50, 0x2d, 0x53, 0x74, 0x61, 0x74, 0x73, 0x65, 0x72, 0x76,
759 /* -04F0, */ 0x69, 0x63, 0x65, 0x2d, 0x69, 0x64, 0x6c, 0x65, 0x2d, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f,
760 /* -0500, */ 0x6c, 0x64, 0x3d, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2d, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70,
761 /* -0510, */ 0x6f, 0x72, 0x74, 0x6f, 0x6f, 0x62, 0x72, 0x69, 0x67, 0x68, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65,
762 /* -0520, */ 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x3d, 0x3a, 0x67, 0x65, 0x6f, 0x70, 0x72, 0x69,
763 /* -0530, */ 0x76, 0x31, 0x30, 0x30, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x68, 0x69, 0x70,
764 /* -0540, */ 0x6f, 0x63, 0x2d, 0x73, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x75, 0x72, 0x70, 0x72, 0x69,
765 /* -0550, */ 0x73, 0x65, 0x64, 0x61, 0x72, 0x6b, 0x75, 0x72, 0x6e, 0x3a, 0x6f, 0x6d, 0x61, 0x3a, 0x78, 0x6d,
766 /* -0560, */ 0x6c, 0x3a, 0x70, 0x72, 0x73, 0x3a, 0x70, 0x69, 0x64, 0x66, 0x3a, 0x6f, 0x6d, 0x61, 0x2d, 0x70,
767 /* -0570, */ 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x6f, 0x69, 0x73, 0x79, 0x3a,
768 /* -0580, */ 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x2d, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x2d, 0x73, 0x65,
769 /* -0590, */ 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x64, 0x6f, 0x6f, 0x72, 0x73, 0x63, 0x68, 0x6f, 0x6f,
770 /* -05A0, */ 0x6c, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2d,
771 /* -05B0, */ 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6d, 0x65, 0x65, 0x74,
772 /* -05C0, */ 0x69, 0x6e, 0x67, 0x63, 0x61, 0x6c, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x74, 0x6f, 0x72,
773 /* -05D0, */ 0x65, 0x74, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x3a,
774 /* -05E0, */ 0x77, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x69, 0x6e, 0x66, 0x6f, 0x66, 0x66, 0x65, 0x6e, 0x64,
775 /* -05F0, */ 0x65, 0x64, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6f, 0x6f, 0x6b, 0x69, 0x6e, 0x67, 0x2d,
776 /* -0600, */ 0x66, 0x6f, 0x72, 0x2d, 0x77, 0x6f, 0x72, 0x6b, 0x69, 0x6e, 0x67, 0x77, 0x61, 0x74, 0x63, 0x68,
777 /* -0610, */ 0x65, 0x72, 0x2d, 0x6c, 0x69, 0x73, 0x74, 0x72, 0x65, 0x65, 0x74, 0x70, 0x6c, 0x61, 0x63, 0x65,
778 /* -0620, */ 0x2d, 0x69, 0x73, 0x66, 0x6f, 0x63, 0x75, 0x73, 0x6f, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x77, 0x61,
779 /* -0630, */ 0x79, 0x68, 0x6f, 0x6d, 0x65, 0x70, 0x61, 0x67, 0x65, 0x70, 0x72, 0x69, 0x76, 0x61, 0x63, 0x79,
780 /* -0640, */ 0x77, 0x61, 0x72, 0x65, 0x68, 0x6f, 0x75, 0x73, 0x65, 0x72, 0x2d, 0x69, 0x6e, 0x70, 0x75, 0x74,
781 /* -0650, */ 0x72, 0x61, 0x76, 0x65, 0x6c, 0x62, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76,
782 /* -0660, */ 0x65, 0x2d, 0x6f, 0x6e, 0x6c, 0x79, 0x3a, 0x72, 0x6c, 0x6d, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x75,
783 /* -0670, */ 0x65, 0x3d, 0x3a, 0x63, 0x61, 0x70, 0x73, 0x6c, 0x65, 0x65, 0x70, 0x69, 0x6e, 0x67, 0x75, 0x69,
784 /* -0680, */ 0x6c, 0x74, 0x79, 0x69, 0x6e, 0x76, 0x69, 0x6e, 0x63, 0x69, 0x62, 0x6c, 0x65, 0x76, 0x65, 0x6e,
785 /* -0690, */ 0x74, 0x3d, 0x6d, 0x6f, 0x6f, 0x64, 0x79, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x3d, 0x70,
786 /* -06A0, */ 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x66, 0x72, 0x6f, 0x6d,
787 /* -06B0, */ 0x3d, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x63, 0x61, 0x72, 0x64, 0x70, 0x6f, 0x73, 0x3d, 0x61, 0x75,
788 /* -06C0, */ 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,
789 /* -06D0, */ 0x6f, 0x74, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65,
790 /* -06E0, */ 0x49, 0x44, 0x69, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x69, 0x73, 0x61, 0x70, 0x70,
791 /* -06F0, */ 0x6f, 0x69, 0x6e, 0x74, 0x65, 0x64, 0x6e, 0x6f, 0x74, 0x65, 0x2d, 0x77, 0x65, 0x6c, 0x6c, 0x69,
792 /* -0700, */ 0x62, 0x72, 0x61, 0x72, 0x79, 0x3a, 0x64, 0x61, 0x74, 0x61, 0x2d, 0x6d, 0x6f, 0x64, 0x65, 0x6c,
793 /* -0710, */ 0x65, 0x63, 0x74, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x69, 0x76, 0x69, 0x63, 0x41, 0x64, 0x64, 0x72,
794 /* -0720, */ 0x65, 0x73, 0x73, 0x61, 0x72, 0x63, 0x61, 0x73, 0x74, 0x69, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e,
795 /* -0730, */ 0x74, 0x65, 0x64, 0x69, 0x6e, 0x64, 0x69, 0x67, 0x6e, 0x61, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x72,
796 /* -0740, */ 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x73, 0x68, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x63, 0x6c, 0x61,
797 /* -0750, */ 0x73, 0x73, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
798 /* -0760, */ 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x2d, 0x62, 0x79, 0x3a, 0x63, 0x69, 0x70, 0x69, 0x64,
799 /* -0770, */ 0x66, 0x2d, 0x66, 0x75, 0x6c, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x65, 0x3d, 0x61, 0x63, 0x74, 0x6f,
800 /* -0780, */ 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x64, 0x62, 0x75, 0x73, 0x69, 0x6e, 0x65, 0x73, 0x73, 0x65,
801 /* -0790, */ 0x72, 0x69, 0x6f, 0x75, 0x73, 0x65, 0x6c, 0x3d, 0x3a, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x78,
802 /* -07A0, */ 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x3a, 0x72, 0x70, 0x69, 0x64, 0x75, 0x72, 0x6e, 0x3a, 0x69,
803 /* -07B0, */ 0x65, 0x74, 0x66, 0x3a, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x3a, 0x78, 0x6d, 0x6c, 0x2d, 0x70,
804 /* -07C0, */ 0x61, 0x74, 0x63, 0x68, 0x2d, 0x6f, 0x70, 0x73, 0x65, 0x63, 0x2d, 0x61, 0x67, 0x72, 0x65, 0x65,
805 /* -07D0, */ 0x61, 0x72, 0x6c, 0x79, 0x2d, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2d, 0x70, 0x61, 0x74,
806 /* -07E0, */ 0x69, 0x63, 0x69, 0x70, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x74, 0x68, 0x65, 0x2d, 0x70, 0x68,
807 /* -07F0, */ 0x6f, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2d, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62,
808 /* -0800, */ 0x69, 0x6c, 0x69, 0x74, 0x79, 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65,
809 /* -0810, */ 0x78, 0x63, 0x69, 0x74, 0x65, 0x64, 0x70, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69,
810 /* -0820, */ 0x6f, 0x6e, 0x6f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2d, 0x70, 0x72, 0x69, 0x6f,
811 /* -0830, */ 0x72, 0x69, 0x74, 0x79, 0x3d, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2d,
812 /* -0840, */ 0x63, 0x6c, 0x61, 0x73, 0x73, 0x72, 0x6f, 0x6f, 0x6d, 0x75, 0x73, 0x74, 0x55, 0x6e, 0x64, 0x65,
813 /* -0850, */ 0x72, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x2d, 0x6e, 0x61, 0x6d,
814 /* -0860, */ 0x65, 0x3d, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
815 /* -0870, */ 0x6f, 0x6e, 0x73, 0x2d, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x73, 0x64, 0x70, 0x2d, 0x61,
816 /* -0880, */ 0x6e, 0x61, 0x74, 0x74, 0x65, 0x6e, 0x64, 0x61, 0x6e, 0x74, 0x72, 0x75, 0x65, 0x3a, 0x70, 0x69,
817 /* -0890, */ 0x64, 0x66, 0x2d, 0x64, 0x69, 0x66, 0x66, 0x72, 0x75, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x64,
818 /* -08A0, */ 0x75, 0x70, 0x6c, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x63, 0x6f,
819 /* -08B0, */ 0x6e, 0x74, 0x61, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x69, 0x65, 0x73, 0x68, 0x6f, 0x70, 0x70,
820 /* -08C0, */ 0x69, 0x6e, 0x67, 0x2d, 0x61, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x3d, 0x61, 0x70, 0x70, 0x6f,
821 /* -08D0, */ 0x69, 0x6e, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x3d, 0x61, 0x73, 0x73, 0x6f, 0x63,
822 /* -08E0, */ 0x69, 0x61, 0x74, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x3d, 0x69, 0x6e, 0x74, 0x65,
823 /* -08F0, */ 0x72, 0x65, 0x73, 0x74, 0x65, 0x64, 0x65, 0x76, 0x63, 0x61, 0x70, 0x73, 0x74, 0x61, 0x74, 0x75,
824 /* -0900, */ 0x73, 0x3d, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x77, 0x69,
825 /* -0910, */ 0x6e, 0x66, 0x6f, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x69, 0x6e, 0x2d, 0x74, 0x72, 0x61,
826 /* -0920, */ 0x6e, 0x73, 0x69, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x68, 0x6f, 0x73, 0x70, 0x69, 0x74, 0x61, 0x6c,
827 /* -0930, */ 0x61, 0x6e, 0x67, 0x3d, 0x3c, 0x3f, 0x78, 0x6d, 0x6c, 0x6e, 0x73, 0x3d, 0x73, 0x69, 0x63, 0x6b,
828 /* -0940, */ 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x55, 0x54, 0x46, 0x2d, 0x38, 0x3f, 0x3e, 0x63,
829 /* -0950, */ 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x05, 0x0d, 0x34, 0x08, 0x0d, 0x06, 0x09, 0x0c, 0xe3, 0x07, 0x0d,
830 /* -0960, */ 0x48, 0x06, 0x0d, 0x36, 0x13, 0x0b, 0xab, 0x05, 0x09, 0x65, 0x07, 0x0c, 0xd4, 0x08, 0x0d, 0x40,
831 /* -0970, */ 0x05, 0x0d, 0x23, 0x05, 0x0c, 0x35, 0x07, 0x0c, 0xae, 0x05, 0x0d, 0x2f, 0x06, 0x08, 0xb9, 0x05,
832 /* -0980, */ 0x07, 0x2b, 0x04, 0x0d, 0x12, 0x06, 0x0d, 0x4f, 0x09, 0x0c, 0x2c, 0x04, 0x0c, 0x89, 0x04, 0x0a,
833 /* -0990, */ 0xf6, 0x09, 0x0b, 0x57, 0x0b, 0x0b, 0x05, 0x08, 0x0a, 0xda, 0x06, 0x0a, 0xda, 0x06, 0x04, 0x89,
834 /* -09A0, */ 0x05, 0x0b, 0xa6, 0x04, 0x0b, 0x94, 0x06, 0x05, 0x05, 0x07, 0x0b, 0x3f, 0x0e, 0x0b, 0xba, 0x07,
835 /* -09B0, */ 0x0b, 0x98, 0x0a, 0x0c, 0x8d, 0x09, 0x0b, 0x6d, 0x09, 0x0c, 0x8e, 0x0e, 0x0c, 0x48, 0x0a, 0x0c,
836 /* -09C0, */ 0xb2, 0x1d, 0x09, 0x56, 0x0d, 0x0c, 0x38, 0x06, 0x07, 0xba, 0x0b, 0x08, 0xb9, 0x0b, 0x07, 0xec,
837 /* -09D0, */ 0x06, 0x0d, 0x02, 0x0a, 0x0a, 0x46, 0x04, 0x08, 0xf4, 0x06, 0x0b, 0x6a, 0x04, 0x0a, 0xb6, 0x0c,
838 /* -09E0, */ 0x0c, 0x55, 0x08, 0x0a, 0x31, 0x04, 0x0a, 0x92, 0x08, 0x0a, 0x1b, 0x05, 0x0a, 0xb1, 0x04, 0x08,
839 /* -09F0, */ 0xc0, 0x05, 0x0a, 0x27, 0x05, 0x0a, 0xa7, 0x05, 0x0a, 0xac, 0x04, 0x0a, 0xba, 0x04, 0x07, 0xdc,
840 /* -0A00, */ 0x05, 0x08, 0xad, 0x0a, 0x09, 0x29, 0x0a, 0x08, 0xa7, 0x05, 0x0a, 0x56, 0x05, 0x0b, 0x4d, 0x07,
841 /* -0A10, */ 0x09, 0x2a, 0x0d, 0x09, 0xa7, 0x0b, 0x07, 0xa9, 0x06, 0x09, 0xc6, 0x0b, 0x0b, 0x5f, 0x0c, 0x09,
842 /* -0A20, */ 0xdf, 0x0b, 0x09, 0xe0, 0x06, 0x07, 0xcb, 0x0c, 0x0a, 0x0b, 0x09, 0x09, 0x20, 0x08, 0x0a, 0x97,
843 /* -0A30, */ 0x07, 0x09, 0xe0, 0x07, 0x0c, 0xfb, 0x06, 0x0a, 0x8c, 0x0e, 0x09, 0x7f, 0x0a, 0x09, 0x87, 0x0b,
844 /* -0A40, */ 0x0c, 0x71, 0x0a, 0x0c, 0x71, 0x06, 0x07, 0x93, 0x05, 0x0a, 0x66, 0x04, 0x08, 0x67, 0x04, 0x09,
845 /* -0A50, */ 0xba, 0x08, 0x09, 0x20, 0x0a, 0x0b, 0x72, 0x05, 0x0a, 0x72, 0x08, 0x07, 0xb3, 0x0b, 0x0a, 0xc5,
846 /* -0A60, */ 0x07, 0x09, 0xf2, 0x07, 0x08, 0x89, 0x04, 0x08, 0xad, 0x08, 0x0a, 0xbe, 0x06, 0x0c, 0x9f, 0x0b,
847 /* -0A70, */ 0x06, 0xd0, 0x0e, 0x08, 0x26, 0x08, 0x0a, 0x9f, 0x07, 0x09, 0xc6, 0x0a, 0x0c, 0x69, 0x07, 0x08,
848 /* -0A80, */ 0x85, 0x05, 0x0b, 0x7c, 0x07, 0x0a, 0x39, 0x0c, 0x09, 0x34, 0x07, 0x0a, 0x21, 0x09, 0x08, 0x7d,
849 /* -0A90, */ 0x07, 0x0c, 0xf5, 0x0b, 0x0c, 0xa3, 0x14, 0x06, 0xa6, 0x0d, 0x08, 0xb2, 0x0c, 0x07, 0x2a, 0x0c,
850 /* -0AA0, */ 0x08, 0xb3, 0x04, 0x07, 0x56, 0x07, 0x09, 0x1a, 0x04, 0x07, 0x52, 0x07, 0x07, 0x40, 0x05, 0x07,
851 /* -0AB0, */ 0x4d, 0x07, 0x0b, 0x80, 0x06, 0x07, 0x47, 0x16, 0x06, 0x91, 0x08, 0x0c, 0x62, 0x10, 0x09, 0xcf,
852 /* -0AC0, */ 0x10, 0x07, 0xdd, 0x09, 0x0a, 0xf6, 0x09, 0x06, 0xfc, 0x0c, 0x0b, 0x17, 0x07, 0x07, 0x39, 0x04,
853 /* -0AD0, */ 0x06, 0xf8, 0x07, 0x09, 0xa1, 0x06, 0x06, 0x8d, 0x05, 0x07, 0x21, 0x04, 0x0a, 0x55, 0x09, 0x0a,
854 /* -0AE0, */ 0xd2, 0x0c, 0x0a, 0xcf, 0x13, 0x06, 0xc8, 0x0a, 0x08, 0xec, 0x07, 0x0d, 0x06, 0x0b, 0x08, 0x0c,
855 /* -0AF0, */ 0x14, 0x0b, 0xd5, 0x12, 0x07, 0xbe, 0x0d, 0x07, 0xd1, 0x16, 0x08, 0x01, 0x14, 0x0b, 0xf1, 0x06,
856 /* -0B00, */ 0x05, 0xb4, 0x07, 0x04, 0x56, 0x09, 0x04, 0x17, 0x0c, 0x0a, 0xea, 0x09, 0x04, 0x1f, 0x0a, 0x07,
857 /* -0B10, */ 0x7e, 0x0b, 0x07, 0x6a, 0x07, 0x0c, 0x0f, 0x0b, 0x07, 0xa0, 0x0a, 0x0c, 0x96, 0x06, 0x05, 0x28,
858 /* -0B20, */ 0x06, 0x0a, 0x7d, 0x05, 0x06, 0x1f, 0x07, 0x05, 0x8b, 0x0a, 0x04, 0x3c, 0x06, 0x05, 0xae, 0x04,
859 /* -0B30, */ 0x06, 0x50, 0x09, 0x0a, 0xe2, 0x06, 0x05, 0xf6, 0x07, 0x07, 0xfd, 0x09, 0x0b, 0x33, 0x0a, 0x0c,
860 /* -0B40, */ 0xec, 0x0a, 0x0a, 0x83, 0x07, 0x06, 0x54, 0x06, 0x04, 0x90, 0x04, 0x05, 0x3f, 0x05, 0x0a, 0x92,
861 /* -0B50, */ 0x07, 0x07, 0x8a, 0x07, 0x08, 0xcc, 0x08, 0x09, 0xea, 0x07, 0x04, 0x96, 0x05, 0x06, 0x10, 0x08,
862 /* -0B60, */ 0x07, 0x98, 0x0a, 0x06, 0xf1, 0x08, 0x04, 0x79, 0x09, 0x0b, 0x22, 0x07, 0x0b, 0x8e, 0x07, 0x0b,
863 /* -0B70, */ 0x46, 0x04, 0x0d, 0x3c, 0x06, 0x04, 0x80, 0x08, 0x07, 0x12, 0x09, 0x09, 0x4a, 0x07, 0x04, 0xe3,
864 /* -0B80, */ 0x07, 0x05, 0x84, 0x05, 0x09, 0x7a, 0x05, 0x06, 0x01, 0x09, 0x09, 0x12, 0x04, 0x09, 0x52, 0x0d,
865 /* -0B90, */ 0x04, 0xaa, 0x0d, 0x08, 0x56, 0x08, 0x04, 0xdc, 0x07, 0x05, 0x92, 0x05, 0x05, 0x0c, 0x0a, 0x04,
866 /* -0BA0, */ 0x4c, 0x04, 0x06, 0x2c, 0x0b, 0x04, 0xd1, 0x04, 0x06, 0x24, 0x09, 0x0c, 0x40, 0x04, 0x04, 0xce,
867 /* -0BB0, */ 0x0c, 0x08, 0xc1, 0x11, 0x04, 0x00, 0x05, 0x07, 0x34, 0x0a, 0x06, 0x6a, 0x08, 0x0d, 0x28, 0x05,
868 /* -0BC0, */ 0x06, 0x1a, 0x0a, 0x04, 0x28, 0x07, 0x0a, 0xfe, 0x06, 0x04, 0xff, 0x08, 0x09, 0x94, 0x07, 0x05,
869 /* -0BD0, */ 0x76, 0x10, 0x08, 0x98, 0x06, 0x05, 0xf0, 0x06, 0x09, 0x03, 0x10, 0x09, 0x03, 0x09, 0x08, 0x1e,
870 /* -0BE0, */ 0x0a, 0x08, 0x3c, 0x06, 0x09, 0x9b, 0x0d, 0x0c, 0xbb, 0x07, 0x06, 0xe3, 0x05, 0x09, 0xcc, 0x06,
871 /* -0BF0, */ 0x0a, 0x15, 0x07, 0x04, 0x73, 0x05, 0x06, 0x73, 0x0d, 0x06, 0x73, 0x05, 0x08, 0x45, 0x08, 0x0a,
872 /* -0C00, */ 0x29, 0x09, 0x0a, 0x40, 0x05, 0x07, 0x1a, 0x0a, 0x07, 0x1a, 0x09, 0x0b, 0x4f, 0x09, 0x0c, 0xdb,
873 /* -0C10, */ 0x06, 0x05, 0xea, 0x06, 0x05, 0xde, 0x0a, 0x04, 0x0e, 0x0a, 0x0b, 0x0e, 0x09, 0x06, 0x86, 0x08,
874 /* -0C20, */ 0x05, 0x60, 0x0b, 0x07, 0x74, 0x09, 0x05, 0x4f, 0x08, 0x04, 0xf0, 0x07, 0x09, 0x90, 0x06, 0x08,
875 /* -0C30, */ 0x70, 0x0a, 0x0c, 0x21, 0x07, 0x05, 0x6f, 0x0b, 0x0c, 0xcc, 0x04, 0x07, 0x90, 0x07, 0x04, 0xea,
876 /* -0C40, */ 0x0a, 0x08, 0x33, 0x04, 0x06, 0x34, 0x09, 0x06, 0xdc, 0x04, 0x06, 0x40, 0x07, 0x05, 0x2e, 0x04,
877 /* -0C50, */ 0x06, 0x48, 0x06, 0x07, 0x87, 0x07, 0x05, 0x68, 0x0a, 0x0d, 0x1a, 0x07, 0x04, 0x45, 0x07, 0x05,
878 /* -0C60, */ 0x05, 0x08, 0x05, 0x0e, 0x08, 0x05, 0x58, 0x08, 0x04, 0xb6, 0x10, 0x09, 0xf8, 0x04, 0x06, 0x3c,
879 /* -0C70, */ 0x07, 0x09, 0xbc, 0x0c, 0x06, 0xd0, 0x0c, 0x0b, 0xe7, 0x04, 0x06, 0x44, 0x04, 0x0a, 0x31, 0x0b,
880 /* -0C80, */ 0x0c, 0x05, 0x04, 0x06, 0x28, 0x11, 0x07, 0x5a, 0x07, 0x0c, 0xc5, 0x07, 0x05, 0xa0, 0x0c, 0x09,
881 /* -0C90, */ 0x6f, 0x08, 0x0c, 0xbb, 0x08, 0x0a, 0x76, 0x09, 0x08, 0x16, 0x08, 0x08, 0x69, 0x06, 0x05, 0xe4,
882 /* -0CA0, */ 0x09, 0x04, 0x86, 0x07, 0x05, 0x38, 0x06, 0x0a, 0x4f, 0x08, 0x04, 0xc6, 0x0f, 0x08, 0xf4, 0x0b,
883 /* -0CB0, */ 0x04, 0x31, 0x07, 0x0a, 0x04, 0x07, 0x08, 0xa1, 0x0d, 0x0c, 0x55, 0x06, 0x05, 0xc0, 0x06, 0x05,
884 /* -0CC0, */ 0xba, 0x05, 0x05, 0x41, 0x08, 0x0b, 0x87, 0x08, 0x04, 0x89, 0x04, 0x05, 0x35, 0x0c, 0x0a, 0x5a,
885 /* -0CD0, */ 0x09, 0x04, 0x68, 0x09, 0x04, 0x9c, 0x0a, 0x06, 0xba, 0x06, 0x07, 0x0d, 0x05, 0x07, 0x25, 0x09,
886 /* -0CE0, */ 0x0b, 0x9d, 0x09, 0x0a, 0x69, 0x06, 0x0a, 0x6c, 0x04, 0x06, 0x38, 0x04, 0x06, 0x30, 0x07, 0x0d,
887 /* -0CF0, */ 0x13, 0x08, 0x08, 0x4c, 0x05, 0x06, 0x15, 0x06, 0x04, 0x50, 0x0a, 0x07, 0x04, 0x06, 0x07, 0xf7,
888 /* -0D00, */ 0x04, 0x08, 0x49, 0x0f, 0x08, 0x89, 0x0c, 0x09, 0x3f, 0x05, 0x06, 0x81, 0x11, 0x08, 0xdc, 0x0d,
889 /* -0D10, */ 0x04, 0x5c, 0x11, 0x06, 0x5a, 0x05, 0x0d, 0x0e, 0x06, 0x05, 0xd8, 0x04, 0x08, 0xd3, 0x06, 0x05,
890 /* -0D20, */ 0xd2, 0x07, 0x05, 0x7d, 0x06, 0x05, 0xcc, 0x07, 0x08, 0xd6, 0x05, 0x06, 0x0b, 0x07, 0x05, 0xa7,
891 /* -0D30, */ 0x05, 0x05, 0x16, 0x08, 0x05, 0x1a, 0x09, 0x05, 0x46, 0x06, 0x05, 0xc6, 0x06, 0x09, 0x31, 0x0d,
892 /* -0D40, */ 0x0b, 0xcf, 0x09, 0x08, 0x62, 0x08, 0x04, 0xf8, 0x04, 0x08, 0x54, 0x0a, 0x06, 0x7f, 0x04, 0x04,
893 /* -0D50, */ 0x71, 0x0c, 0x0c, 0x16, 0x04, 0x05, 0x2e, 0x08, 0x0b, 0x3f, 0x11, 0x0c, 0x23, 0x08, 0x0c, 0x7b,
894 /* -0D60, */ 0x09, 0x0b, 0xc7, 0x07, 0x07, 0xf6, 0x05, 0x0b, 0x3b, 0x09, 0x08, 0x75, 0x09, 0x0c, 0x81, 0x09,
895 /* -0D70, */ 0x06, 0xe9, 0x0b, 0x09, 0xb0, 0x07, 0x05, 0x22, 0x07, 0x04, 0xa3, 0x07, 0x06, 0xc2, 0x07, 0x05,
896 /* -0D80, */ 0x99, 0x05, 0x06, 0x06, 0x05, 0x05, 0xfc, 0x04, 0x09, 0xc3, 0x04, 0x06, 0x4c, 0x08, 0x04, 0xbe,
898 };
903 static void
908 g_str_equal,
911 /*
912 * Store static dictionaries in hash table
913 */
936 }
938 static void
941 }
944 static int udvm_state_access(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,uint8_t *buff,uint16_t p_id_start, uint16_t p_id_length, uint16_t state_begin, uint16_t *state_length,
947 {
958 /*
959 * Perform initial checks on validity of data
960 * RFC 3320 :
961 * 9.4.5. STATE-ACCESS
962 * :
963 * Decompression failure occurs if partial_identifier_length does not
964 * lie between 6 and 20 inclusive. Decompression failure also occurs if
965 * no state item matching the partial state identifier can be found, if
966 * more than one state item matches the partial identifier, or if
967 * partial_identifier_length is less than the minimum_access_length of
968 * the matched state item. Otherwise, a state item is returned from the
969 * state handler.
970 */
975 }
980 n++;
981 }
986 /* Debug
987 * ws_warning("State Access: partial state =%s",partial_state_str);
988 * ws_warning("g_hash_table_lookup = 0x%x",state_buff);
989 * ws_warning("State Access: partial state =%s",partial_state_str);
990 */
995 }
996 /*
997 * sip_sdp_static_dictionaty
998 *
999 * 8.4. Byte copying
1000 * :
1001 * The string of bytes is copied in ascending order of memory address,
1002 * respecting the bounds set by byte_copy_left and byte_copy_right.
1003 * More precisely, if a byte is copied from/to Address m then the next
1004 * byte is copied from/to Address n where n is calculated as follows:
1005 *
1006 * Set k := m + 1 (modulo 2^16)
1007 * If k = byte_copy_right then set n := byte_copy_left, else set n := k
1008 *
1009 */
1011 /*
1012 * buff = Where "state" will be stored
1013 * p_id_start = Partial state identifier start pos in the buffer(buff)
1014 * p-id_length = Partial state identifier length
1015 * state_begin = Where to start to read state from
1016 * state_length = Length of state
1017 * state_address = Address where to store the state in the buffer(buff)
1018 * state_instruction =
1019 * false = Indicates that state_* is in the stored state
1020 */
1024 /*
1025 * The value of
1026 * state_length MUST be taken from the returned item of state in the
1027 * case that the state_length operand is set to 0.
1028 *
1029 * The same is true of state_address, state_instruction.
1030 */
1033 }
1037 }
1041 }
1043 /*
1044 * Decompression failure occurs if bytes are copied from beyond the end of
1045 * the state_value.
1046 */
1049 }
1051 /*
1052 * Note that decompression failure will always occur if the state_length
1053 * operand is set to 0 but the state_begin operand is non-zero.
1054 */
1057 }
1062 /*
1063 * NOTE: Strictly speaking, byte_copy_left and byte_copy_right should
1064 * not be used if this has been called for bytecode referenced in
1065 * the message header. However, since the memory is initialised
1066 * to zero, the code works OK.
1067 */
1072 /* debug
1073 *ws_warning(" state_begin %u state_address %u",state_begin , *state_address);
1074 */
1077 /* debug
1078 ws_warning(" Loading 0x%x at address %u",buff[k] , k);
1079 */
1083 }
1084 n++;
1085 }
1087 /*
1088 * End SIP
1089 */
1091 }
1093 static void udvm_state_create(uint8_t *state_buff,uint8_t *state_identifier,uint16_t p_id_length) {
1099 /*
1100 * Debug
1101 ws_warning("Received items of state,state_length_buff[0]= %u, state_length_buff[1]= %u",
1102 state_length_buff[0],state_length_buff[1]);
1104 */
1108 i++;
1109 }
1116 /* The buffer allocated by sigcomp-udvm.c wasn't needed so free it
1117 */
1120 }
1122 }
1124 #if 1
1125 static void udvm_state_free(uint8_t buff[] _U_,uint16_t p_id_start _U_,uint16_t p_id_length _U_) {
1126 }
1127 #else
1138 i++;
1139 }
1141 /* TODO Implement a state create counter before actually freeing states
1142 * Hmm is it a good idea to free the buffer at all?
1143 * ws_warning("State-free on %s ",partial_state_str);
1144 */
1149 }
1151 }
1152 #endif
1154 /**********************************************************************************************
1155 *
1156 * SIGCOMP DECOMPRESSION
1157 *
1158 **********************************************************************************************/
1159 #define SIGCOMP_INSTR_DECOMPRESSION_FAILURE 0
1160 #define SIGCOMP_INSTR_AND 1
1161 #define SIGCOMP_INSTR_OR 2
1162 #define SIGCOMP_INSTR_NOT 3
1163 #define SIGCOMP_INSTR_LSHIFT 4
1164 #define SIGCOMP_INSTR_RSHIFT 5
1165 #define SIGCOMP_INSTR_ADD 6
1166 #define SIGCOMP_INSTR_SUBTRACT 7
1167 #define SIGCOMP_INSTR_MULTIPLY 8
1168 #define SIGCOMP_INSTR_DIVIDE 9
1169 #define SIGCOMP_INSTR_REMAINDER 10
1170 #define SIGCOMP_INSTR_SORT_ASCENDING 11
1171 #define SIGCOMP_INSTR_SORT_DESCENDING 12
1172 #define SIGCOMP_INSTR_SHA_1 13
1173 #define SIGCOMP_INSTR_LOAD 14
1174 #define SIGCOMP_INSTR_MULTILOAD 15
1175 #define SIGCOMP_INSTR_PUSH 16
1176 #define SIGCOMP_INSTR_POP 17
1177 #define SIGCOMP_INSTR_COPY 18
1178 #define SIGCOMP_INSTR_COPY_LITERAL 19
1179 #define SIGCOMP_INSTR_COPY_OFFSET 20
1180 #define SIGCOMP_INSTR_MEMSET 21
1181 #define SIGCOMP_INSTR_JUMP 22
1182 #define SIGCOMP_INSTR_COMPARE 23
1183 #define SIGCOMP_INSTR_CALL 24
1184 #define SIGCOMP_INSTR_RETURN 25
1185 #define SIGCOMP_INSTR_SWITCH 26
1186 #define SIGCOMP_INSTR_CRC 27
1187 #define SIGCOMP_INSTR_INPUT_BYTES 28
1188 #define SIGCOMP_INSTR_INPUT_BITS 29
1189 #define SIGCOMP_INSTR_INPUT_HUFFMAN 30
1190 #define SIGCOMP_INSTR_STATE_ACCESS 31
1191 #define SIGCOMP_INSTR_STATE_CREATE 32
1192 #define SIGCOMP_INSTR_STATE_FREE 33
1193 #define SIGCOMP_INSTR_OUTPUT 34
1194 #define SIGCOMP_INSTR_END_MESSAGE 35
1234 };
1238 /* Internal result code values of decompression failures */
1260 };
1262 /* The simplest operand type is the literal (#), which encodes a
1263 * constant integer from 0 to 65535 inclusive. A literal operand may
1264 * require between 1 and 3 bytes depending on its value.
1265 * Bytecode: Operand value: Range:
1266 * 0nnnnnnn N 0 - 127
1267 * 10nnnnnn nnnnnnnn N 0 - 16383
1268 * 11000000 nnnnnnnn nnnnnnnn N 0 - 65535
1269 *
1270 * Figure 8: Bytecode for a literal (#) operand
1271 *
1272 */
1273 static int
1275 {
1289 /*
1290 * 10nnnnnn nnnnnnnn N 0 - 16383
1291 */
1300 /*
1301 * 111000000 nnnnnnnn nnnnnnnn N 0 - 65535
1302 */
1303 offset ++;
1311 }
1313 /*
1314 * 0nnnnnnn N 0 - 127
1315 */
1318 offset ++;
1319 }
1323 }
1325 /*
1326 * The second operand type is the reference ($), which is always used to
1327 * access a 2-byte value located elsewhere in the UDVM memory. The
1328 * bytecode for a reference operand is decoded to be a constant integer
1329 * from 0 to 65535 inclusive, which is interpreted as the memory address
1330 * containing the actual value of the operand.
1331 * Bytecode: Operand value: Range:
1332 *
1333 * 0nnnnnnn memory[2 * N] 0 - 65535
1334 * 10nnnnnn nnnnnnnn memory[2 * N] 0 - 65535
1335 * 11000000 nnnnnnnn nnnnnnnn memory[N] 0 - 65535
1336 *
1337 * Figure 9: Bytecode for a reference ($) operand
1338 */
1339 static int
1340 dissect_udvm_reference_operand_memory(uint8_t *buff,unsigned operand_address, uint16_t *value,unsigned *result_dest)
1341 {
1356 /*
1357 * 10nnnnnn nnnnnnnn memory[2 * N] 0 - 65535
1358 */
1371 /*
1372 * 11000000 nnnnnnnn nnnnnnnn memory[N] 0 - 65535
1373 */
1374 operand_address++;
1383 }
1385 /*
1386 * 0nnnnnnn memory[2 * N] 0 - 65535
1387 */
1394 offset ++;
1395 }
1401 }
1403 /* RFC3320
1404 * Figure 10: Bytecode for a multitype (%) operand
1405 * Bytecode: Operand value: Range: HEX val
1406 * 00nnnnnn N 0 - 63 0x00
1407 * 01nnnnnn memory[2 * N] 0 - 65535 0x40
1408 * 1000011n 2 ^ (N + 6) 64 , 128 0x86
1409 * 10001nnn 2 ^ (N + 8) 256 , ... , 32768 0x88
1410 * 111nnnnn N + 65504 65504 - 65535 0xe0
1411 * 1001nnnn nnnnnnnn N + 61440 61440 - 65535 0x90
1412 * 101nnnnn nnnnnnnn N 0 - 8191 0xa0
1413 * 110nnnnn nnnnnnnn memory[N] 0 - 65535 0xc0
1414 * 10000000 nnnnnnnn nnnnnnnn N 0 - 65535 0x80
1415 * 10000001 nnnnnnnn nnnnnnnn memory[N] 0 - 65535 0x81
1416 */
1417 static int
1419 {
1437 /*
1438 * 00nnnnnn N 0 - 63
1439 */
1441 /* debug
1442 *ws_warning("Reading 0x%x From address %u",operand,offset);
1443 */
1445 offset ++;
1448 /*
1449 * 01nnnnnn memory[2 * N] 0 - 65535
1450 */
1455 offset ++;
1458 /* Check tree most significant bits */
1461 /*
1462 * 101nnnnn nnnnnnnn N 0 - 8191
1463 */
1473 /*
1474 * 1001nnnn nnnnnnnn N + 61440 61440 - 65535
1475 */
1486 /*
1487 * 10001nnn 2 ^ (N + 8) 256 , ... , 32768
1488 */
1493 offset ++;
1497 /*
1498 * 1000 011n 2 ^ (N + 6) 64 , 128
1499 */
1503 offset ++;
1505 /*
1506 * 1000 0000 nnnnnnnn nnnnnnnn N 0 - 65535
1507 * 1000 0001 nnnnnnnn nnnnnnnn memory[N] 0 - 65535
1508 */
1509 offset ++;
1512 /* debug
1513 * ws_warning("Reading 0x%x From address %u",temp_data16,operand_address);
1514 */
1519 }
1522 }
1525 }
1526 }
1527 }
1533 /*
1534 * 111nnnnn N + 65504 65504 - 65535
1535 */
1538 offset ++;
1540 /*
1541 * 110nnnnn nnnnnnnn memory[N] 0 - 65535
1542 */
1549 /* debug
1550 * ws_warning("Reading 0x%x From address %u",temp_data16,memmory_addr);
1551 */
1553 }
1557 }
1559 }
1560 /*
1561 *
1562 * The fourth operand type is the address (@). This operand is decoded
1563 * as a multitype operand followed by a further step: the memory address
1564 * of the UDVM instruction containing the address operand is added to
1565 * obtain the correct operand value. So if the operand value from
1566 * Figure 10 is D then the actual operand value of an address is
1567 * calculated as follows:
1568 *
1569 * operand_value = (memory_address_of_instruction + D) modulo 2^16
1570 *
1571 * Address operands are always used in instructions that control program
1572 * flow, because they ensure that the UDVM bytecode is position-
1573 * independent code (i.e., it will run independently of where it is
1574 * placed in the UDVM memory).
1575 */
1576 static int
1577 decode_udvm_address_operand(uint8_t *buff,unsigned operand_address, uint16_t *value,unsigned current_address)
1578 {
1588 }
1591 /*
1592 * This is a lookup table used to reverse the bits in a byte.
1593 */
1627 };
1630 static int
1644 {
1660 /*
1661 * Discard any spare bits.
1662 * Note: We take care to avoid remaining_bits having the value of 8.
1663 */
1665 {
1668 }
1670 /*
1671 * Check we can supply the required number of bits now, before we alter
1672 * the input buffer's state.
1673 */
1675 {
1678 }
1680 /* Note: This is never called with length > 16, so the following loop
1681 * never loops more than three time. */
1683 {
1684 /*
1685 * We only put anything into input_bits if we know we will remove
1686 * at least one bit. That ensures we can simply discard the spare
1687 * bits if the P-bit changes.
1688 */
1690 {
1693 proto_tree_add_uint_format(udvm_tree, hf_sigcomp_getting_value, message_tvb, *input_address, 1, octet,
1695 }
1699 {
1701 }
1704 }
1706 /* Add some more bits to the accumulated value. */
1715 }
1718 {
1719 /* Bit reverse the entire word. */
1724 }
1727 }
1736 {
1738 /* UDVM memory must be initialised to zero */
1782 /* uint16_t state_state_retention_priority_buff[5]; */
1788 gcry_md_hd_t sha1_handle;
1792 /* UDVM operand variables */
1827 /* Set print parameters */
1856 }
1858 /* Set initial UDVM data
1859 * The first 32 bytes of UDVM memory are then initialized to special
1860 * values as illustrated in Figure 5.
1861 *
1862 * 0 7 8 15
1863 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1864 * | UDVM_memory_size | 0 - 1
1865 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1866 * | cycles_per_bit | 2 - 3
1867 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1868 * | SigComp_version | 4 - 5
1869 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1870 * | partial_state_ID_length | 6 - 7
1871 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1872 * | state_length | 8 - 9
1873 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1874 * | |
1875 * : reserved : 10 - 31
1876 * | |
1877 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1878 *
1879 * Figure 5: Initializing Useful Values in UDVM memory
1880 */
1881 /* UDVM_memory_size */
1884 /* cycles_per_bit */
1887 /* SigComp_version */
1890 /* partial_state_ID_length */
1893 /* state_length */
1901 /*
1902 * maximum_UDVM_cycles = (8 * n + 1000) * cycles_per_bit
1903 */
1907 proto_tree_add_uint(udvm_tree, hf_sigcomp_byte_code_length, bytecode_tvb, offset, 1, code_length);
1908 proto_tree_add_uint(udvm_tree, hf_sigcomp_max_udvm_cycles, bytecode_tvb, offset, 1, maximum_UDVM_cycles);
1910 /* Load bytecode into UDVM starting at "udvm_mem_dest" */
1913 proto_tree_add_uint(udvm_tree, hf_sigcomp_load_bytecode_into_udvm_start, bytecode_tvb, offset, 1, i);
1917 proto_tree_add_uint_format(udvm_tree, hf_sigcomp_instruction_code, bytecode_tvb, offset, 1, buff[i],
1920 i++;
1921 offset++;
1923 }
1924 /* Start executing code */
1928 proto_tree_add_uint_format(udvm_tree, hf_sigcomp_udvm_execution_stated, bytecode_tvb, offset, 1, current_address,
1931 /* Largest allowed size for a message is UDVM_MEMORY_SIZE = 65536 */
1934 /* Reset offset so proto_tree_add_xxx items below accurately reflect the bytes they represent */
1937 execute_next_instruction:
1942 }
1943 used_udvm_cycles++;
1947 addr_item = proto_tree_add_uint_format(udvm_tree, hf_sigcomp_current_instruction, bytecode_tvb, offset, 1, current_instruction,
1949 val_to_str_ext_const(current_instruction, &udvm_instruction_code_vals_ext, "INVALID INSTRUCTION"),
1950 current_instruction);
1951 }
1952 offset++;
1960 current_address);
1963 /* At least something got decompressed, show it */
1965 /* Add the tvbuff to the list of tvbuffs to which the tvbuff we
1966 * were handed refers, so it'll get cleaned up when that tvbuff
1967 * is cleaned up.
1968 */
1970 proto_tree_add_expert(udvm_tree, pinfo, &ei_sigcomp_sigcomp_message_decompression_failure, decomp_tvb, 0, -1);
1972 }
1978 }
1980 /* $operand_1*/
1982 next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
1986 proto_tree_add_uint_format(udvm_tree, hf_udvm_operand_1, bytecode_tvb, offset, (next_operand_address-operand_address), operand_1,
1988 }
1991 /* %operand_2*/
1996 proto_tree_add_uint_format(udvm_tree, hf_udvm_operand_2, bytecode_tvb, offset, (next_operand_address-operand_address), operand_2,
1998 }
2001 {
2002 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
2005 }
2006 /* execute the instruction */
2015 }
2024 }
2026 /* $operand_1*/
2028 next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
2032 proto_tree_add_uint_format(udvm_tree, hf_udvm_operand_1, bytecode_tvb, offset, (next_operand_address-operand_address), operand_1,
2034 }
2037 /* %operand_2*/
2042 proto_tree_add_uint_format(udvm_tree, hf_udvm_operand_2, bytecode_tvb, offset, (next_operand_address-operand_address), operand_2,
2044 }
2047 {
2048 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
2051 }
2052 /* execute the instruction */
2061 }
2070 }
2072 /* $operand_1*/
2074 next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
2078 proto_tree_add_uint_format(udvm_tree, hf_udvm_operand_1, bytecode_tvb, offset, (next_operand_address-operand_address), operand_1,
2080 }
2083 {
2084 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
2087 }
2088 /* execute the instruction */
2097 }
2105 }
2107 /* $operand_1*/
2109 next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
2113 proto_tree_add_uint_format(udvm_tree, hf_udvm_operand_1, bytecode_tvb, offset, (next_operand_address-operand_address), operand_1,
2115 }
2118 /* %operand_2*/
2123 ti = proto_tree_add_uint_format(udvm_tree, hf_udvm_operand_2, bytecode_tvb, offset, (next_operand_address-operand_address), operand_2,
2125 }
2129 }
2132 {
2133 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
2136 }
2137 /* execute the instruction */
2146 }
2154 }
2156 /* $operand_1*/
2158 next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
2162 proto_tree_add_uint_format(udvm_tree, hf_udvm_operand_1, bytecode_tvb, offset, (next_operand_address-operand_address), operand_1,
2164 }
2167 /* %operand_2*/
2172 ti = proto_tree_add_uint_format(udvm_tree, hf_udvm_operand_2, bytecode_tvb, offset, (next_operand_address-operand_address), operand_2,
2174 }
2178 }
2181 {
2182 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
2185 }
2186 /* execute the instruction */
2195 }
2202 }
2204 /* $operand_1*/
2206 next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
2210 proto_tree_add_uint_format(udvm_tree, hf_udvm_operand_1, bytecode_tvb, offset, (next_operand_address-operand_address), operand_1,
2212 }
2215 /* %operand_2*/
2220 proto_tree_add_uint_format(udvm_tree, hf_udvm_operand_2, bytecode_tvb, offset, (next_operand_address-operand_address), operand_2,
2222 }
2225 {
2226 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
2229 }
2230 /* execute the instruction */
2239 }
2246 }
2248 /* $operand_1*/
2250 next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
2254 proto_tree_add_uint_format(udvm_tree, hf_udvm_operand_1, bytecode_tvb, offset, (next_operand_address-operand_address), operand_1,
2256 }
2259 /* %operand_2*/
2264 proto_tree_add_uint_format(udvm_tree, hf_udvm_operand_2, bytecode_tvb, offset, (next_operand_address-operand_address), operand_2,
2266 }
2269 {
2270 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
2273 }
2274 /* execute the instruction */
2283 }
2291 }
2293 /* $operand_1*/
2295 next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
2299 proto_tree_add_uint_format(udvm_tree, hf_udvm_operand_1, bytecode_tvb, offset, (next_operand_address-operand_address), operand_1,
2301 }
2304 /* %operand_2*/
2309 proto_tree_add_uint_format(udvm_tree, hf_udvm_operand_2, bytecode_tvb, offset, (next_operand_address-operand_address), operand_2,
2311 }
2314 {
2315 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
2318 }
2319 /*
2320 * execute the instruction
2321 * MULTIPLY (m, n) := m * n (modulo 2^16)
2322 */
2326 }
2335 }
2343 }
2345 /* $operand_1*/
2347 next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
2351 proto_tree_add_uint_format(udvm_tree, hf_udvm_operand_1, bytecode_tvb, offset, (next_operand_address-operand_address), operand_1,
2353 }
2356 /* %operand_2*/
2361 proto_tree_add_uint_format(udvm_tree, hf_udvm_operand_2, bytecode_tvb, offset, (next_operand_address-operand_address), operand_2,
2363 }
2366 {
2367 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
2370 }
2371 /*
2372 * execute the instruction
2373 * DIVIDE (m, n) := floor(m / n)
2374 * Decompression failure occurs if a DIVIDE or REMAINDER instruction
2375 * encounters an operand_2 that is zero.
2376 */
2380 }
2389 }
2397 }
2399 /* $operand_1*/
2401 next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
2405 proto_tree_add_uint_format(udvm_tree, hf_udvm_operand_1, bytecode_tvb, offset, (next_operand_address-operand_address), operand_1,
2407 }
2410 /* %operand_2*/
2415 proto_tree_add_uint_format(udvm_tree, hf_udvm_operand_2, bytecode_tvb, offset, (next_operand_address-operand_address), operand_2,
2417 }
2420 {
2421 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
2424 }
2425 /*
2426 * execute the instruction
2427 * REMAINDER (m, n) := m - n * floor(m / n)
2428 * Decompression failure occurs if a DIVIDE or REMAINDER instruction
2429 * encounters an operand_2 that is zero.
2430 */
2434 }
2443 }
2448 /*
2449 * used_udvm_cycles = 1 + k * (ceiling(log2(k)) + n)
2450 */
2453 }
2454 proto_tree_add_expert(udvm_tree, pinfo, &ei_sigcomp_execution_of_this_instruction_is_not_implemented, bytecode_tvb, 0, -1);
2455 /*
2456 * used_udvm_cycles = 1 + k * (ceiling(log2(k)) + n)
2457 */
2463 }
2464 proto_tree_add_expert(udvm_tree, pinfo, &ei_sigcomp_execution_of_this_instruction_is_not_implemented, bytecode_tvb, 0, -1);
2465 /*
2466 * used_udvm_cycles = 1 + k * (ceiling(log2(k)) + n)
2467 */
2472 }
2474 /* %position */
2479 proto_tree_add_uint_format(udvm_tree, hf_udvm_position, bytecode_tvb, offset, (next_operand_address-operand_address), position,
2481 }
2485 /* %length */
2490 proto_tree_add_uint_format(udvm_tree, hf_udvm_length, bytecode_tvb, offset, (next_operand_address-operand_address), length,
2492 }
2496 /* $destination */
2497 next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &ref_destination, &result_dest);
2501 proto_tree_add_uint_format(udvm_tree, hf_udvm_ref_dest, bytecode_tvb, offset, (next_operand_address-operand_address), ref_destination,
2503 }
2517 }
2521 }
2528 }
2534 }
2542 }
2543 }
2555 n++;
2559 }
2560 }
2565 }
2574 }
2577 /* %address */
2582 proto_tree_add_uint_format(udvm_tree, hf_udvm_address, bytecode_tvb, offset, (next_operand_address-operand_address), addr,
2584 }
2587 /* %value */
2592 {
2593 proto_tree_add_uint_format(udvm_tree, hf_udvm_value, bytecode_tvb, offset, (next_operand_address-operand_address), value,
2595 }
2604 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
2609 }
2615 /* RFC 3320:
2616 * The MULTILOAD instruction sets a contiguous block of 2-byte words in
2617 * the UDVM memory to specified values.
2618 * Hmm what if the value to load only takes one byte ? Chose to always load two bytes.
2619 */
2622 }
2625 /* %address */
2630 proto_tree_add_uint_format(udvm_tree, hf_udvm_address, bytecode_tvb, offset, (next_operand_address-operand_address), addr,
2632 }
2636 /* #n */
2641 proto_tree_add_uint_format(udvm_tree, hf_udvm_literal_num, bytecode_tvb, offset, (next_operand_address-operand_address), n,
2643 }
2646 {
2647 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
2650 }
2655 /* %value */
2667 /* debug
2668 */
2673 "Addr: %u Value %5u - Loading bytes at %5u Value %5u 0x%x", operand_address, value, addr, value, value);
2674 }
2677 }
2686 }
2689 /* %value */
2694 proto_tree_add_uint_format(udvm_tree, hf_udvm_value, bytecode_tvb, offset, (next_operand_address-operand_address), value,
2696 }
2699 {
2700 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
2703 }
2706 /* Push the value address onto the stack */
2732 }
2735 /* %value */
2740 proto_tree_add_uint_format(udvm_tree, hf_udvm_address, bytecode_tvb, offset, (next_operand_address-operand_address), destination,
2742 }
2745 {
2746 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
2749 }
2752 /* Pop value from the top of the stack */
2757 {
2760 }
2777 /* ... and store the popped value. */
2790 }
2793 /* %position */
2798 proto_tree_add_uint_format(udvm_tree, hf_udvm_position, bytecode_tvb, offset, (next_operand_address-operand_address), position,
2800 }
2804 /* %length */
2809 proto_tree_add_uint_format(udvm_tree, hf_udvm_length, bytecode_tvb, offset, (next_operand_address-operand_address), length,
2811 }
2815 /* %destination */
2820 proto_tree_add_uint_format(udvm_tree, hf_udvm_ref_dest, bytecode_tvb, offset, (next_operand_address-operand_address), destination,
2822 }
2825 {
2826 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
2829 }
2831 /*
2832 * 8.4. Byte copying
2833 * :
2834 * The string of bytes is copied in ascending order of memory address,
2835 * respecting the bounds set by byte_copy_left and byte_copy_right.
2836 * More precisely, if a byte is copied from/to Address m then the next
2837 * byte is copied from/to Address n where n is calculated as follows:
2838 *
2839 * Set k := m + 1 (modulo 2^16)
2840 * If k = byte_copy_right then set n := byte_copy_left, else set n := k
2841 *
2842 */
2853 }
2861 }
2864 n++;
2866 /*
2867 * Check for circular buffer wrapping after the positions are
2868 * incremented. If either started at BCR then they should continue
2869 * to increment beyond BCR.
2870 */
2873 }
2876 }
2877 }
2885 }
2888 /* %position */
2893 proto_tree_add_uint_format(udvm_tree, hf_udvm_position, bytecode_tvb, offset, (next_operand_address-operand_address), position,
2895 }
2899 /* %length */
2904 proto_tree_add_uint_format(udvm_tree, hf_udvm_length, bytecode_tvb, offset, (next_operand_address-operand_address), length,
2906 }
2911 /* $destination */
2912 next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &ref_destination, &result_dest);
2916 proto_tree_add_uint_format(udvm_tree, hf_udvm_ref_dest, bytecode_tvb, offset, (next_operand_address-operand_address), ref_destination,
2918 }
2921 {
2922 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
2925 }
2929 /*
2930 * 8.4. Byte copying
2931 * :
2932 * The string of bytes is copied in ascending order of memory address,
2933 * respecting the bounds set by byte_copy_left and byte_copy_right.
2934 * More precisely, if a byte is copied from/to Address m then the next
2935 * byte is copied from/to Address n where n is calculated as follows:
2936 *
2937 * Set k := m + 1 (modulo 2^16)
2938 * If k = byte_copy_right then set n := byte_copy_left, else set n := k
2939 *
2940 */
2951 }
2959 }
2962 n++;
2964 /*
2965 * Check for circular buffer wrapping after the positions are
2966 * incremented. It is important that k cannot be left set
2967 * to BCR. Also, if either started at BCR then they should continue
2968 * to increment beyond BCR.
2969 */
2972 }
2975 }
2976 }
2987 }
2990 /* %offset */
2995 proto_tree_add_uint_format(udvm_tree, hf_udvm_offset, bytecode_tvb, offset, (next_operand_address-operand_address), multy_offset,
2997 }
3001 /* %length */
3006 proto_tree_add_uint_format(udvm_tree, hf_udvm_length, bytecode_tvb, offset, (next_operand_address-operand_address), length,
3008 }
3013 /* $destination */
3014 next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &ref_destination, &result_dest);
3018 proto_tree_add_uint_format(udvm_tree, hf_udvm_ref_dest, bytecode_tvb, offset, (next_operand_address-operand_address), ref_destination,
3020 }
3024 {
3025 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
3028 }
3031 /* Execute the instruction:
3032 * To derive the value of the position operand, starting at the memory
3033 * address specified by destination, the UDVM counts backwards a total
3034 * of offset memory addresses.
3035 *
3036 * If the memory address specified in byte_copy_left is reached, the
3037 * next memory address is taken to be (byte_copy_right - 1) modulo 2^16.
3038 */
3044 /*
3045 * In order to work out the position, simple arithmetic is tricky
3046 * to apply because there some nasty corner cases. A simple loop
3047 * is inefficient but the logic is simple.
3048 *
3049 * FUTURE: This could be optimised.
3050 */
3052 {
3054 {
3056 }
3057 else
3058 {
3060 }
3061 }
3067 }
3068 /* The COPY-OFFSET instruction then behaves as a COPY-LITERAL
3069 * instruction, taking the value of the position operand to be the last
3070 * memory address reached in the above step.
3071 */
3073 /*
3074 * 8.4. Byte copying
3075 * :
3076 * The string of bytes is copied in ascending order of memory address,
3077 * respecting the bounds set by byte_copy_left and byte_copy_right.
3078 * More precisely, if a byte is copied from/to Address m then the next
3079 * byte is copied from/to Address n where n is calculated as follows:
3080 *
3081 * Set k := m + 1 (modulo 2^16)
3082 * If k = byte_copy_right then set n := byte_copy_left, else set n := k
3083 *
3084 */
3089 proto_tree_add_bytes_format(udvm_tree, hf_sigcomp_byte_copy, message_tvb, input_address, 1, NULL,
3091 }
3098 }
3099 n++;
3103 /*
3104 * Check for circular buffer wrapping after the positions are
3105 * incremented. It is important that k cannot be left set
3106 * to BCR. Also, if either started at BCR then they should continue
3107 * to increment beyond BCR.
3108 */
3111 }
3114 }
3115 }
3125 }
3129 /* %address */
3134 proto_tree_add_uint_format(udvm_tree, hf_udvm_address, bytecode_tvb, offset, (next_operand_address-operand_address), addr,
3136 }
3140 /* %length, */
3145 proto_tree_add_uint_format(udvm_tree, hf_udvm_length, bytecode_tvb, offset, (next_operand_address-operand_address), length,
3147 }
3150 /* %start_value */
3155 proto_tree_add_uint_format(udvm_tree, hf_udvm_start_value, bytecode_tvb, offset, (next_operand_address-operand_address), start_value,
3157 }
3161 /* %offset */
3166 proto_tree_add_uint_format(udvm_tree, hf_udvm_offset, bytecode_tvb, offset, (next_operand_address-operand_address), multy_offset,
3168 }
3171 {
3172 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
3175 }
3177 /* execute the instruction
3178 * The sequence of values used by the MEMSET instruction is specified by
3179 * the following formula:
3180 *
3181 * Seq[n] := (start_value + n * offset) modulo 256
3182 */
3190 proto_tree_add_bytes_format(udvm_tree, hf_sigcomp_byte_copy, message_tvb, input_address, 1, NULL,
3192 }
3196 }
3202 }
3204 n++;
3214 }
3217 /* @address */
3218 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
3219 next_operand_address = decode_udvm_address_operand(buff,operand_address, &at_address, current_address);
3223 proto_tree_add_uint_format(udvm_tree, hf_udvm_at_address, bytecode_tvb, offset, (next_operand_address-operand_address), at_address,
3225 }
3228 {
3229 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
3232 }
3238 /* COMPARE (%value_1, %value_2, @address_1, @address_2, @address_3)
3239 */
3242 }
3246 /* %value_1 */
3251 proto_tree_add_uint_format(udvm_tree, hf_udvm_value, bytecode_tvb, offset, (next_operand_address-operand_address), value_1,
3253 }
3257 /* %value_2 */
3262 proto_tree_add_uint_format(udvm_tree, hf_udvm_value, bytecode_tvb, offset, (next_operand_address-operand_address), value_2,
3264 }
3268 /* @address_1 */
3269 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
3275 proto_tree_add_uint_format(udvm_tree, hf_udvm_at_address, bytecode_tvb, offset, (next_operand_address-operand_address), at_address_1,
3277 }
3282 /* @address_2 */
3283 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
3289 proto_tree_add_uint_format(udvm_tree, hf_udvm_at_address, bytecode_tvb, offset, (next_operand_address-operand_address), at_address_2,
3291 }
3295 /* @address_3 */
3296 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
3302 proto_tree_add_uint_format(udvm_tree, hf_udvm_at_address, bytecode_tvb, offset, (next_operand_address-operand_address), at_address_3,
3304 }
3307 {
3308 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
3311 }
3312 /* execute the instruction
3313 * If value_1 < value_2 then the UDVM continues instruction execution at
3314 * the memory address specified by address 1. If value_1 = value_2 then
3315 * it jumps to the address specified by address_2. If value_1 > value_2
3316 * then it jumps to the address specified by address_3.
3317 */
3330 }
3333 /* @address */
3334 next_operand_address = decode_udvm_address_operand(buff,operand_address, &at_address, current_address);
3338 proto_tree_add_uint_format(udvm_tree, hf_udvm_at_address, bytecode_tvb, offset, (next_operand_address-operand_address), at_address,
3340 }
3343 {
3344 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
3347 }
3350 /* Push the current address onto the stack */
3366 /* ... and jump to the destination address */
3374 /* Pop value from the top of the stack */
3379 {
3382 }
3394 /* ... and set the PC to the popped value */
3401 case SIGCOMP_INSTR_SWITCH: /* 26 SWITCH (#n, %j, @address_0, @address_1, ... , @address_n-1) */
3402 /*
3403 * When a SWITCH instruction is encountered the UDVM reads the value of
3404 * j. It then continues instruction execution at the address specified
3405 * by address j.
3406 *
3407 * Decompression failure occurs if j specifies a value of n or more, or
3408 * if the address lies beyond the overall UDVM memory size.
3409 */
3413 }
3415 /* #n
3416 * Number of addresses in the instruction
3417 */
3422 proto_tree_add_uint_format(udvm_tree, hf_udvm_literal_num, bytecode_tvb, offset, (next_operand_address-operand_address), n,
3424 }
3427 /* %j */
3432 proto_tree_add_uint_format(udvm_tree, hf_udvm_j, bytecode_tvb, offset, (next_operand_address-operand_address), j,
3434 }
3439 /* @address_n-1 */
3440 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
3446 proto_tree_add_uint_format(udvm_tree, hf_udvm_at_address, bytecode_tvb, offset, (next_operand_address-operand_address), at_address_1,
3448 }
3452 }
3454 m++;
3455 }
3456 /* Check decompression failure */
3460 }
3464 }
3473 }
3478 /* %value */
3483 proto_tree_add_uint_format(udvm_tree, hf_udvm_value, bytecode_tvb, offset, (next_operand_address-operand_address), value,
3485 }
3489 /* %position */
3494 proto_tree_add_uint_format(udvm_tree, hf_udvm_position, bytecode_tvb, offset, (next_operand_address-operand_address), position,
3496 }
3500 /* %length */
3505 proto_tree_add_uint_format(udvm_tree, hf_udvm_length, bytecode_tvb, offset, (next_operand_address-operand_address), length,
3507 }
3511 /* @address */
3517 proto_tree_add_uint_format(udvm_tree, hf_udvm_at_address, bytecode_tvb, offset, (next_operand_address-operand_address), at_address,
3519 }
3521 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
3535 }
3543 }
3554 }
3555 }
3560 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
3562 }
3565 }
3568 }
3576 }
3579 /* %length */
3584 proto_tree_add_uint_format(udvm_tree, hf_udvm_length, bytecode_tvb, offset, (next_operand_address-operand_address), length,
3586 }
3590 /* %destination */
3595 proto_tree_add_uint_format(udvm_tree, hf_udvm_destination, bytecode_tvb, offset, (next_operand_address-operand_address), destination,
3597 }
3601 /* @address */
3602 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
3608 proto_tree_add_uint_format(udvm_tree, hf_udvm_at_address, bytecode_tvb, offset, (next_operand_address-operand_address), at_address,
3610 }
3613 {
3614 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
3617 }
3618 /* execute the instruction TODO insert checks
3619 * RFC 3320 :
3620 *
3621 * 0 7 8 15
3622 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3623 * | byte_copy_left | 64 - 65
3624 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3625 * | byte_copy_right | 66 - 67
3626 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3627 * | input_bit_order | 68 - 69
3628 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3629 * | stack_location | 70 - 71
3630 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3631 *
3632 * Figure 7: Memory addresses of the UDVM registers
3633 * :
3634 * 8.4. Byte copying
3635 * :
3636 * The string of bytes is copied in ascending order of memory address,
3637 * respecting the bounds set by byte_copy_left and byte_copy_right.
3638 * More precisely, if a byte is copied from/to Address m then the next
3639 * byte is copied from/to Address n where n is calculated as follows:
3640 *
3641 * Set k := m + 1 (modulo 2^16)
3642 * If k = byte_copy_right then set n := byte_copy_left, else set n := k
3643 *
3644 */
3655 }
3656 /* clear out remaining bits if any */
3659 /* operand_address used as dummy */
3665 }
3669 }
3675 }
3676 input_address++;
3677 /*
3678 * If the instruction requests data that lies beyond the end of the
3679 * SigComp message, no data is returned. Instead the UDVM moves program
3680 * execution to the address specified by the address operand.
3681 */
3685 n++;
3686 }
3692 /*
3693 * The length operand indicates the requested number of bits.
3694 * Decompression failure occurs if this operand does not lie between 0
3695 * and 16 inclusive.
3696 *
3697 * The destination operand specifies the memory address to which the
3698 * compressed data should be copied. Note that the requested bits are
3699 * interpreted as a 2-byte integer ranging from 0 to 2^length - 1, as
3700 * explained in Section 8.2.
3701 *
3702 * If the instruction requests data that lies beyond the end of the
3703 * SigComp message, no data is returned. Instead the UDVM moves program
3704 * execution to the address specified by the address operand.
3705 */
3709 }
3713 /* %length */
3718 proto_tree_add_uint_format(udvm_tree, hf_udvm_length, bytecode_tvb, offset, (next_operand_address-operand_address), length,
3720 }
3723 /* %destination */
3728 proto_tree_add_uint_format(udvm_tree, hf_udvm_destination, bytecode_tvb, offset, (next_operand_address-operand_address), destination,
3730 }
3734 /* @address */
3735 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
3736 next_operand_address = decode_udvm_address_operand(buff,operand_address, &at_address, current_address);
3740 proto_tree_add_uint_format(udvm_tree, hf_udvm_at_address, bytecode_tvb, offset, (next_operand_address-operand_address), at_address,
3742 }
3745 {
3746 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
3749 }
3752 /*
3753 * Execute actual instr.
3754 * The input_bit_order register contains the following three flags:
3755 *
3756 * 0 7 8 15
3757 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3758 * | reserved |F|H|P| 68 - 69
3759 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3760 */
3763 /*
3764 * If the instruction requests data that lies beyond the end of the
3765 * SigComp message, no data is returned. Instead the UDVM moves program
3766 * execution to the address specified by the address operand.
3767 */
3772 }
3776 }
3778 /*
3779 * Transfer F bit to bit_order to tell decomp dispatcher which bit order to use
3780 */
3788 }
3796 proto_tree_add_none_format(udvm_tree, hf_sigcomp_loading_result, message_tvb, input_address, 1,
3797 " Loading value: %u (0x%x) at Addr: %u, remaining_bits: %u", value, value, destination, remaining_bits);
3798 }
3803 /*
3804 * INPUT-HUFFMAN (%destination, @address, #n, %bits_1, %lower_bound_1,
3805 * %upper_bound_1, %uncompressed_1, ... , %bits_n, %lower_bound_n,
3806 * %upper_bound_n, %uncompressed_n)
3807 */
3809 proto_item_append_text(addr_item, " (destination, @address, #n, bits_1, lower_bound_1,upper_bound_1, uncompressed_1, ... , bits_n, lower_bound_n,upper_bound_n, uncompressed_n)");
3810 }
3814 /* %destination */
3819 proto_tree_add_uint_format(udvm_tree, hf_udvm_destination, bytecode_tvb, offset, (next_operand_address-operand_address), destination,
3821 }
3825 /* @address */
3826 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
3827 next_operand_address = decode_udvm_address_operand(buff,operand_address, &at_address, current_address);
3831 proto_tree_add_uint_format(udvm_tree, hf_udvm_at_address, bytecode_tvb, offset, (next_operand_address-operand_address), at_address,
3833 }
3837 /* #n */
3842 proto_tree_add_uint_format(udvm_tree, hf_udvm_literal_num, bytecode_tvb, offset, (next_operand_address-operand_address), n,
3844 }
3848 {
3849 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
3850 "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)",
3852 }
3856 /*
3857 * Note that if n = 0 then the INPUT-HUFFMAN instruction is ignored and
3858 * program execution resumes at the following instruction.
3859 * Decompression failure occurs if (bits_1 + ... + bits_n) > 16.
3860 *
3861 * In all other cases, the behavior of the INPUT-HUFFMAN instruction is
3862 * defined below:
3863 *
3864 * 1. Set j := 1 and set H := 0.
3865 *
3866 * 2. Request bits_j compressed bits. Interpret the returned bits as an
3867 * integer k from 0 to 2^bits_j - 1, as explained in Section 8.2.
3868 *
3869 * 3. Set H := H * 2^bits_j + k.
3870 *
3871 * 4. If data is requested that lies beyond the end of the SigComp
3872 * message, terminate the INPUT-HUFFMAN instruction and move program
3873 * execution to the memory address specified by the address operand.
3874 *
3875 * 5. If (H < lower_bound_j) or (H > upper_bound_j) then set j := j + 1.
3876 * Then go back to Step 2, unless j > n in which case decompression
3877 * failure occurs.
3878 *
3879 * 6. Copy (H + uncompressed_j - lower_bound_j) modulo 2^16 to the
3880 * memory address specified by the destination operand.
3881 *
3882 */
3883 /*
3884 * The input_bit_order register contains the following three flags:
3885 *
3886 * 0 7 8 15
3887 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3888 * | reserved |F|H|P| 68 - 69
3889 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
3890 *
3891 * Transfer H bit to bit_order to tell decomp dispatcher which bit order to use
3892 */
3903 /* %bits_n */
3908 proto_tree_add_uint_format(udvm_tree, hf_udvm_bits, bytecode_tvb, offset, (next_operand_address-operand_address), bits_n,
3910 }
3917 /* %lower_bound_n */
3922 proto_tree_add_uint_format(udvm_tree, hf_udvm_lower_bound, bytecode_tvb, offset, (next_operand_address-operand_address), lower_bound_n,
3924 }
3927 /* %upper_bound_n */
3932 proto_tree_add_uint_format(udvm_tree, hf_udvm_upper_bound, bytecode_tvb, offset, (next_operand_address-operand_address), upper_bound_n,
3934 }
3937 /* %uncompressed_n */
3942 proto_tree_add_uint_format(udvm_tree, hf_udvm_uncompressed, bytecode_tvb, offset, (next_operand_address-operand_address), uncompressed_n,
3944 }
3947 /* execute instruction */
3949 /*
3950 * 2. Request bits_j compressed bits. Interpret the returned bits as an
3951 * integer k from 0 to 2^bits_j - 1, as explained in Section 8.2.
3952 */
3957 /*
3958 * 4. If data is requested that lies beyond the end of the SigComp
3959 * message, terminate the INPUT-HUFFMAN instruction and move program
3960 * execution to the memory address specified by the address operand.
3961 */
3964 }
3966 /*
3967 * 3. Set H := H * 2^bits_j + k.
3968 * [In practice is a shift+OR operation.]
3969 */
3976 }
3978 /*
3979 * 5. If (H < lower_bound_j) or (H > upper_bound_j) then set j := j + 1.
3980 * Then go back to Step 2, unless j > n in which case decompression
3981 * failure occurs.
3982 */
3988 /*
3989 * 6. Copy (H + uncompressed_j - lower_bound_j) modulo 2^16 to the
3990 * memory address specified by the destination operand.
3991 */
3996 }
4008 }
4010 }
4013 }
4015 }
4019 }
4026 /* STATE-ACCESS (%partial_identifier_start, %partial_identifier_length,
4027 * %state_begin, %state_length, %state_address, %state_instruction)
4028 */
4030 proto_item_append_text(addr_item, " (partial_identifier_start, partial_identifier_length,state_begin, state_length, state_address, state_instruction)");
4031 }
4035 /*
4036 * %partial_identifier_start
4037 */
4042 proto_tree_add_uint_format(udvm_tree, hf_partial_identifier_start, bytecode_tvb, offset, (next_operand_address-operand_address), p_id_start,
4044 }
4047 /*
4048 * %partial_identifier_length
4049 */
4055 proto_tree_add_uint_format(udvm_tree, hf_partial_identifier_length, bytecode_tvb, offset, (next_operand_address-operand_address), p_id_length,
4057 }
4059 /*
4060 * %state_begin
4061 */
4067 proto_tree_add_uint_format(udvm_tree, hf_state_begin, bytecode_tvb, offset, (next_operand_address-operand_address), state_begin,
4069 }
4071 /*
4072 * %state_length
4073 */
4079 proto_tree_add_uint_format(udvm_tree, hf_udvm_state_length, bytecode_tvb, offset, (next_operand_address-operand_address), state_length,
4081 }
4083 /*
4084 * %state_address
4085 */
4091 proto_tree_add_uint_format(udvm_tree, hf_udvm_state_address, bytecode_tvb, offset, (next_operand_address-operand_address), state_address,
4093 }
4095 /*
4096 * %state_instruction
4097 */
4099 next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_instruction);
4103 proto_tree_add_uint_format(udvm_tree, hf_udvm_state_instr, bytecode_tvb, offset, (next_operand_address-operand_address), state_instruction,
4105 }
4108 {
4109 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
4110 "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)",
4111 current_address, p_id_start, p_id_length, state_begin, state_length, state_address, state_instruction);
4112 }
4119 proto_tree_add_bytes_format(udvm_tree, hf_sigcomp_byte_copy, message_tvb, input_address, 1, NULL,
4121 }
4123 result_code = udvm_state_access(message_tvb, pinfo, udvm_tree, buff, p_id_start, p_id_length, state_begin, &state_length,
4127 }
4132 /*
4133 * STATE-CREATE (%state_length, %state_address, %state_instruction,
4134 * %minimum_access_length, %state_retention_priority)
4135 */
4137 proto_item_append_text(addr_item, " (state_length, state_address, state_instruction,minimum_access_length, state_retention_priority)");
4138 }
4142 /*
4143 * %state_length
4144 */
4149 proto_tree_add_uint_format(udvm_tree, hf_udvm_state_length, bytecode_tvb, offset, (next_operand_address-operand_address), state_length,
4151 }
4153 /*
4154 * %state_address
4155 */
4161 proto_tree_add_uint_format(udvm_tree, hf_udvm_state_address, bytecode_tvb, offset, (next_operand_address-operand_address), state_address,
4163 }
4165 /*
4166 * %state_instruction
4167 */
4169 next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_instruction);
4173 proto_tree_add_uint_format(udvm_tree, hf_udvm_state_instr, bytecode_tvb, offset, (next_operand_address-operand_address), state_instruction,
4175 }
4177 /*
4178 * %minimum_access_length
4179 */
4181 next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &minimum_access_length);
4185 proto_tree_add_uint_format(udvm_tree, hf_udvm_min_acc_len, bytecode_tvb, offset, (next_operand_address-operand_address), minimum_access_length,
4187 }
4189 /*
4190 * %state_retention_priority
4191 */
4193 next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_retention_priority);
4197 proto_tree_add_uint_format(udvm_tree, hf_udvm_state_ret_pri, bytecode_tvb, offset, (next_operand_address-operand_address), state_retention_priority,
4199 }
4202 {
4203 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
4204 "Addr: %u ## STATE-CREATE(32) (state_length=%u, state_address=%u, state_instruction=%u,minimum_access_length=%u, state_retention_priority=%u)",
4205 current_address, state_length, state_address, state_instruction,minimum_access_length, state_retention_priority);
4206 }
4208 /* Execute the instruction
4209 * TODO Implement the instruction
4210 * RFC3320:
4211 * Note that the new state item cannot be created until a valid
4212 * compartment identifier has been returned by the application.
4213 * Consequently, when a STATE-CREATE instruction is encountered the UDVM
4214 * simply buffers the five supplied operands until the END-MESSAGE
4215 * instruction is reached. The steps taken at this point are described
4216 * in Section 9.4.9.
4217 *
4218 * Decompression failure MUST occur if more than four state creation
4219 * requests are made before the END-MESSAGE instruction is encountered.
4220 * Decompression failure also occurs if the minimum_access_length does
4221 * not lie between 6 and 20 inclusive, or if the
4222 * state_retention_priority is 65535.
4223 */
4224 no_of_state_create++;
4228 }
4232 }
4236 }
4241 /* state_state_retention_priority_buff[no_of_state_create] = state_retention_priority; */
4243 /* Debug */
4253 }
4260 }
4262 n++;
4263 }
4264 /* End debug */
4269 /*
4270 * STATE-FREE (%partial_identifier_start, %partial_identifier_length)
4271 */
4274 }
4277 /*
4278 * %partial_identifier_start
4279 */
4284 proto_tree_add_uint_format(udvm_tree, hf_partial_identifier_start, bytecode_tvb, offset, (next_operand_address-operand_address), p_id_start,
4286 }
4290 /*
4291 * %partial_identifier_length
4292 */
4297 proto_tree_add_uint_format(udvm_tree, hf_partial_identifier_length, bytecode_tvb, offset, (next_operand_address-operand_address), p_id_length,
4299 }
4302 {
4303 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
4306 }
4309 /* Execute the instruction:
4310 * TODO implement it
4311 */
4319 }
4322 /*
4323 * %output_start
4324 */
4329 proto_tree_add_uint_format(udvm_tree, hf_udvm_output_start, bytecode_tvb, offset, (next_operand_address-operand_address), output_start,
4331 }
4334 /*
4335 * %output_length
4336 */
4341 proto_tree_add_uint_format(udvm_tree, hf_udvm_output_length, bytecode_tvb, offset, (next_operand_address-operand_address), output_length,
4343 }
4346 {
4347 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
4350 }
4353 /*
4354 * Execute instruction
4355 * 8.4. Byte copying
4356 * :
4357 * The string of bytes is copied in ascending order of memory address,
4358 * respecting the bounds set by byte_copy_left and byte_copy_right.
4359 * More precisely, if a byte is copied from/to Address m then the next
4360 * byte is copied from/to Address n where n is calculated as follows:
4361 *
4362 * Set k := m + 1 (modulo 2^16)
4363 * If k = byte_copy_right then set n := byte_copy_left, else set n := k
4364 *
4365 */
4376 }
4381 }
4389 }
4391 output_address ++;
4392 n++;
4393 }
4398 /*
4399 * END-MESSAGE (%requested_feedback_location,
4400 * %returned_parameters_location, %state_length, %state_address,
4401 * %state_instruction, %minimum_access_length,
4402 * %state_retention_priority)
4403 */
4405 proto_item_append_text(addr_item, " (requested_feedback_location,state_instruction, minimum_access_length,state_retention_priority)");
4406 }
4410 /* %requested_feedback_location */
4411 next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &requested_feedback_location);
4415 proto_tree_add_uint_format(udvm_tree, hf_udvm_req_feedback_loc, bytecode_tvb, offset, (next_operand_address-operand_address), requested_feedback_location,
4418 }
4421 /* returned_parameters_location */
4422 next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &returned_parameters_location);
4426 proto_tree_add_uint_format(udvm_tree, hf_udvm_ret_param_loc, bytecode_tvb, offset, (next_operand_address-operand_address), returned_parameters_location,
4428 }
4430 /*
4431 * %state_length
4432 */
4438 proto_tree_add_uint_format(udvm_tree, hf_udvm_state_length, bytecode_tvb, offset, (next_operand_address-operand_address), state_length,
4440 }
4442 /*
4443 * %state_address
4444 */
4450 proto_tree_add_uint_format(udvm_tree, hf_udvm_state_address, bytecode_tvb, offset, (next_operand_address-operand_address), state_address,
4452 }
4454 /*
4455 * %state_instruction
4456 */
4458 next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_instruction);
4462 proto_tree_add_uint_format(udvm_tree, hf_udvm_state_instr, bytecode_tvb, offset, (next_operand_address-operand_address), state_instruction,
4464 }
4467 /*
4468 * %minimum_access_length
4469 */
4471 next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &minimum_access_length);
4475 proto_tree_add_uint_format(udvm_tree, hf_udvm_min_acc_len, bytecode_tvb, offset, (next_operand_address-operand_address), minimum_access_length,
4477 }
4480 /*
4481 * %state_retention_priority
4482 */
4484 next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_retention_priority);
4488 proto_tree_add_uint_format(udvm_tree, hf_udvm_state_ret_pri, bytecode_tvb, offset, (next_operand_address-operand_address), state_retention_priority,
4490 }
4493 {
4494 proto_tree_add_none_format(udvm_tree, hf_sigcomp_decompress_instruction, bytecode_tvb, start_offset, offset-start_offset,
4495 "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)",
4496 current_address, requested_feedback_location, returned_parameters_location, state_length, state_address, state_instruction, minimum_access_length,state_retention_priority);
4497 }
4498 /* TODO: This isn't currently totally correct as END_INSTRUCTION might not create state */
4499 no_of_state_create++;
4503 }
4507 /* Not used ? */
4509 /* state_state_retention_priority_buff[no_of_state_create] = state_retention_priority; */
4511 /* Execute the instruction
4512 */
4513 proto_tree_add_uint(udvm_tree, hf_sigcomp_num_state_create, bytecode_tvb, 0, 0, no_of_state_create);
4532 proto_tree_add_bytes_with_length(udvm_tree, hf_sigcomp_sha1buff, bytecode_tvb, 0, -1, sha1buff, 8);
4533 }
4536 {
4539 }
4542 }
4544 gcry_md_hash_buffer(GCRY_MD_SHA1, sha1_digest_buf, (uint8_t *) sha1buff, state_length_buff[n] + 8);
4546 proto_tree_add_bytes_with_length(udvm_tree, hf_sigcomp_sha1_digest, bytecode_tvb, 0, -1, sha1_digest_buf, STATE_BUFFER_SIZE);
4547 }
4548 /* begin partial state-id change cco@iptel.org */
4549 #if 0
4551 #endif
4553 /* end partial state-id change cco@iptel.org */
4555 proto_tree_add_string(udvm_tree,hf_id, bytecode_tvb, 0, 0, bytes_to_str(pinfo->pool, sha1_digest_buf, STATE_MIN_ACCESS_LEN));
4557 n++;
4559 }
4560 }
4564 /* At least something got decompressed, show it */
4568 proto_tree_add_item(udvm_tree, hf_sigcomp_sigcomp_message_decompressed, decomp_tvb, 0, -1, ENC_NA);
4571 proto_tree_add_uint(udvm_tree, hf_sigcomp_max_udvm_cycles, bytecode_tvb, 0, 0, maximum_UDVM_cycles);
4572 proto_tree_add_uint(udvm_tree, hf_sigcomp_used_udvm_cycles, bytecode_tvb, 0, 0, used_udvm_cycles);
4577 "Addr %u Invalid instruction: %u (0x%x)", current_address,current_instruction,current_instruction);
4579 }
4581 decompression_failure:
4583 proto_tree_add_expert_format(udvm_tree, pinfo, &ei_sigcomp_decompression_failure, bytecode_tvb, 0, -1,
4587 }
4589 /**********************************************************************************************
4590 *
4591 * SIGCOMP DISSECTOR
4592 *
4593 **********************************************************************************************/
4596 /* Sigcomp over TCP record marking used
4597 * RFC 3320
4598 * 4.2.2. Record Marking
4599 *
4600 * For a stream-based transport, the dispatcher delimits messages by
4601 * parsing the compressed data stream for instances of 0xFF and taking
4602 * the following actions:
4603 * Occurs in data stream: Action:
4604 *
4605 * 0xFF 00 one 0xFF byte in the data stream
4606 * 0xFF 01 same, but the next byte is quoted (could
4607 * be another 0xFF)
4608 * : :
4609 * 0xFF 7F same, but the next 127 bytes are quoted
4610 * 0xFF 80 to 0xFF FE (reserved for future standardization)
4611 * 0xFF FF end of SigComp message
4612 * :
4613 * In UDVM version 0x01, any occurrence of the combinations 0xFF80 to
4614 * 0xFFFE that are not protected by quoting causes decompression
4615 * failure; the decompressor SHOULD close the stream-based transport in
4616 * this case.
4617 */
4619 /*
4620 * TODO: Reassembly, handle more than one message in a tcp segment.
4621 */
4623 static int
4625 {
4641 /* Is this SIGCOMP ? */
4644 /* delimiter */
4649 }
4653 /* Search for delimiter 0xffff in the remain tvb buffer */
4656 /* Loop end criteria is (length-1) because we take 2 bytes each loop */
4659 }
4661 /* SIGCOMP may be subdissector of SIP, so we use
4662 * pinfo->saved_can_desegment to determine whether do desegment
4663 * as well as pinfo->can_desegment */
4665 /* Delimiter oxffff was not found, not a complete SIGCOMP PDU */
4669 }
4670 }
4672 /* Make entries in Protocol column and Info column on summary display */
4679 try_again:
4680 /* create display subtree for the protocol */
4687 proto_tree_add_item(sigcomp_tree, hf_sigcomp_starting_to_remove_escape_digits, tvb, offset, -1, ENC_NA);
4692 /* if the tvb is short don't check for the second escape digit */
4693 offset++;
4695 }
4703 i++;
4705 }
4712 }
4715 proto_tree_add_none_format(sigcomp_tree, hf_sigcomp_end_of_sigcomp_message_indication_found, tvb, offset, 2,
4720 }
4725 i++;
4728 proto_tree_add_bytes_format(sigcomp_tree, hf_sigcomp_copying_bytes_literally, tvb, offset, octet,
4731 /* if the tvb is short don't copy further than the end */
4738 i++;
4739 offset++;
4740 }
4742 }
4748 i++;
4749 offset++;
4750 }
4755 proto_tree_add_item(sigcomp_tree, hf_sigcomp_data_for_sigcomp_dissector, unescaped_tvb, 0, -1, ENC_NA);
4760 }
4763 }
4766 }
4767 /* Code to actually dissect the packets */
4768 static int
4770 {
4776 /* If we got called from SIP this might be over TCP */
4780 /* Is this a SigComp message or not ? */
4785 /* Make entries in Protocol column and Info column on summary display */
4792 /* create display subtree for the protocol */
4797 }
4798 /* Code to actually dissect the packets */
4799 static int
4801 {
4803 /* Set up structures needed to add the protocol subtree and manage it */
4832 /* add an item to the subtree, see section 1.6 for more information */
4835 /* A SigComp message takes one of two forms depending on whether it
4836 * accesses a state item at the receiving endpoint. The two variants of
4837 * a SigComp message are given in Figure 3. (The T-bit controls the
4838 * format of the returned feedback item and is defined in Section 7.1.)
4839 *
4840 * 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
4841 * +---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
4842 * | 1 1 1 1 1 | T | len | | 1 1 1 1 1 | T | 0 |
4843 * +---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
4844 * | | | |
4845 * : returned feedback item : : returned feedback item :
4846 * | | | |
4847 * +---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
4848 * | | | code_len |
4849 * : partial state identifier : +---+---+---+---+---+---+---+---+
4850 *
4851 * | | | code_len | destination |
4852 * +---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
4853 * | | | |
4854 * : remaining SigComp message : : uploaded UDVM bytecode :
4855 * | | | |
4856 * +---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
4857 * | |
4858 * : remaining SigComp message :
4859 * | |
4860 * +---+---+---+---+---+---+---+---+
4861 *
4862 * RFC 4077:
4863 * The format of the NACK message and the use of the fields within it
4864 * are shown in Figure 1.
4865 *
4866 * 0 1 2 3 4 5 6 7
4867 * +---+---+---+---+---+---+---+---+
4868 * | 1 1 1 1 1 | T | 0 |
4869 * +---+---+---+---+---+---+---+---+
4870 * | |
4871 * : returned feedback item :
4872 * | |
4873 * +---+---+---+---+---+---+---+---+
4874 * | code_len = 0 |
4875 * +---+---+---+---+---+---+---+---+
4876 * | code_len = 0 | version = 1 |
4877 * +---+---+---+---+---+---+---+---+
4878 * | Reason Code |
4879 * +---+---+---+---+---+---+---+---+
4880 * | OPCODE of failed instruction |
4881 * +---+---+---+---+---+---+---+---+
4882 * | PC of failed instruction |
4883 * | |
4884 * +---+---+---+---+---+---+---+---+
4885 * | |
4886 * : SHA-1 Hash of failed message :
4887 * | |
4888 * +---+---+---+---+---+---+---+---+
4889 * | |
4890 * : Error Details :
4891 * | |
4892 * +---+---+---+---+---+---+---+---+
4893 * Figure 1: SigComp NACK Message Format
4894 */
4900 offset ++;
4902 /*
4903 * The len field encodes the number of transmitted bytes as follows:
4904 *
4905 * Encoding: Length of partial state identifier
4906 *
4907 * 01 6 bytes
4908 * 10 9 bytes
4909 * 11 12 bytes
4910 *
4911 */
4914 /*
4915 * Message format 1
4916 */
4920 /*
4921 * Returned feedback item exists
4922 */
4925 /* 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
4926 * +---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
4927 * | 0 | returned_feedback_field | | 1 | returned_feedback_length |
4928 * +---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
4929 * | |
4930 * : returned_feedback_field :
4931 * | |
4932 * +---+---+---+---+---+---+---+---+
4933 * Figure 4: Format of returned feedback item
4934 */
4940 offset ++;
4944 }
4948 }
4961 }
4965 /*
4966 * buff = Where "state" will be stored
4967 * p_id_start = Partial state identifier start pos in the buffer(buff)
4968 * partial_state_len = Partial state identifier length
4969 * state_begin = Where to start to read state from
4970 * state_length = Length of state
4971 * state_address = Address where to store the state in the buffer(buff)
4972 * state_instruction =
4973 * true = Indicates that state_* is in the stored state
4974 */
4975 /*
4976 * Note: The allocated buffer must be zeroed or some strange effects might occur.
4977 */
4983 /* These values will be loaded from the buffered state in sigcomp_state_hdlr
4984 */
4992 i++;
4993 }
4995 /* begin partial state-id change cco@iptel.org */
4996 #if 0
4997 result_code = udvm_state_access(tvb, pinfo, sigcomp_tree, buff, p_id_start, partial_state_len, state_begin, &state_length,
4999 #endif
5000 result_code = udvm_state_access(tvb, pinfo, sigcomp_tree, buff, p_id_start, STATE_MIN_ACCESS_LEN, state_begin, &state_length,
5003 /* end partial state-id change cco@iptel.org */
5005 proto_tree_add_expert_format(sigcomp_tree, pinfo, &ei_sigcomp_failed_to_access_state_wireshark_udvm_diagnostic, tvb, 0, -1,
5006 "Failed to Access state Wireshark UDVM diagnostic: %s", val_to_str(result_code, result_code_vals,"Unknown (%u)"));
5008 }
5010 udvm_tvb = tvb_new_child_real_data(tvb, buff,state_length+state_address,state_length+state_address);
5016 ENC_NA);
5030 /* Show compression ratio achieved */
5041 }
5044 }
5046 /*
5047 * Message format 2
5048 */
5051 /*
5052 * Returned feedback item exists
5053 */
5060 offset ++;
5061 }
5066 }
5070 /* NACK MESSAGE */
5073 offset++;
5075 offset++;
5077 reason_ti = proto_tree_add_item(sigcomp_tree,hf_sigcomp_nack_reason_code, tvb, offset, 1, ENC_BIG_ENDIAN);
5078 offset++;
5080 proto_tree_add_item(sigcomp_tree,hf_sigcomp_nack_failed_op_code, tvb, offset, 1, ENC_BIG_ENDIAN);
5081 offset++;
5083 /* Add expert item for NACK */
5094 /* Add NACK info to info column */
5103 /* State ID (6 - 20 bytes) */
5107 /* Cycles Per Bit (1 byte) */
5108 proto_tree_add_item(sigcomp_tree,hf_sigcomp_nack_cycles_per_bit, tvb, offset, 1, ENC_BIG_ENDIAN);
5111 /* Memory size (2 bytes) */
5116 }
5141 proto_item *ti = proto_tree_add_item(sigcomp_tree, hf_sigcomp_remaining_sigcomp_message, tvb, offset, -1, ENC_NA);
5143 }
5150 ENC_NA);
5161 /* Show compression ratio achieved */
5172 }
5176 }
5178 }
5180 static void
5181 dissect_udvm_bytecode(tvbuff_t *udvm_tvb, packet_info* pinfo, proto_tree *sigcomp_udvm_tree,unsigned start_address)
5182 {
5198 instruction_no ++;
5201 item = proto_tree_add_uint_format(sigcomp_udvm_tree, hf_sigcomp_udvm_instruction, udvm_tvb, offset, 1,
5205 proto_tree_add_item(sigcomp_udvm_tree, hf_sigcomp_udvm_instr, udvm_tvb, offset, 1, ENC_BIG_ENDIAN);
5206 offset ++;
5210 /* $operand_1*/
5211 offset = dissect_udvm_reference_operand(udvm_tvb, sigcomp_udvm_tree, offset, &start_offset, &value);
5215 /* %operand_2*/
5216 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5224 }
5228 /* $operand_1*/
5229 offset = dissect_udvm_reference_operand(udvm_tvb, sigcomp_udvm_tree, offset, &start_offset, &value);
5233 /* %operand_2*/
5234 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5242 }
5246 /* $operand_1*/
5247 offset = dissect_udvm_reference_operand(udvm_tvb, sigcomp_udvm_tree, offset, &start_offset, &value);
5254 /* $operand_1*/
5255 offset = dissect_udvm_reference_operand(udvm_tvb, sigcomp_udvm_tree, offset, &start_offset, &value);
5259 /* %operand_2*/
5260 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5268 }
5272 /* $operand_1*/
5273 offset = dissect_udvm_reference_operand(udvm_tvb, sigcomp_udvm_tree, offset, &start_offset, &value);
5277 /* %operand_2*/
5278 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5286 }
5290 /* $operand_1*/
5291 offset = dissect_udvm_reference_operand(udvm_tvb, sigcomp_udvm_tree, offset, &start_offset, &value);
5295 /* %operand_2*/
5296 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5304 }
5308 /* $operand_1*/
5309 offset = dissect_udvm_reference_operand(udvm_tvb, sigcomp_udvm_tree, offset, &start_offset, &value);
5313 /* %operand_2*/
5314 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5322 }
5326 /* $operand_1*/
5327 offset = dissect_udvm_reference_operand(udvm_tvb, sigcomp_udvm_tree, offset, &start_offset, &value);
5331 /* %operand_2*/
5332 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5340 }
5344 /* $operand_1*/
5345 offset = dissect_udvm_reference_operand(udvm_tvb, sigcomp_udvm_tree, offset, &start_offset, &value);
5349 /* %operand_2*/
5350 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5358 }
5362 /* $operand_1*/
5363 offset = dissect_udvm_reference_operand(udvm_tvb, sigcomp_udvm_tree, offset, &start_offset, &value);
5367 /* %operand_2*/
5368 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5376 }
5379 /* while programming stop while loop */
5387 /* %position */
5388 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5393 /* %length, */
5394 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5402 }
5404 /* $destination */
5405 offset = dissect_udvm_reference_operand(udvm_tvb, sigcomp_udvm_tree, offset, &start_offset, &value);
5412 /* %address */
5413 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true,&start_offset, &value, &is_memory_address);
5417 /* %value */
5418 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5426 }
5430 /* %address */
5431 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
5435 /* #n */
5436 offset = dissect_udvm_literal_operand(udvm_tvb, sigcomp_udvm_tree, offset, &start_offset, &value);
5443 /* %value */
5444 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5452 }
5453 }
5457 /* %value */
5458 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5466 }
5470 /* %address */
5471 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
5479 /* %position */
5480 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5485 /* %length, */
5486 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5494 }
5496 /* $destination */
5497 offset = dissect_udvm_reference_operand(udvm_tvb, sigcomp_udvm_tree, offset, &start_offset, &value);
5504 /* %position */
5505 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5510 /* %length, */
5511 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5519 }
5521 /* $destination */
5522 offset = dissect_udvm_reference_operand(udvm_tvb, sigcomp_udvm_tree, offset, &start_offset, &value);
5529 /* %offset */
5530 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5538 }
5540 /* %length, */
5541 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5549 }
5551 /* $destination */
5552 offset = dissect_udvm_reference_operand(udvm_tvb, sigcomp_udvm_tree, offset, &start_offset, &value);
5559 /* %address */
5560 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
5565 /* %length, */
5566 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false, &start_offset, &value, &is_memory_address);
5574 }
5576 /* %start_value */
5577 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5582 /* %offset */
5583 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5591 /* @address */
5592 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
5594 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
5601 /* COMPARE (%value_1, %value_2, @address_1, @address_2, @address_3)
5602 */
5603 /* %value_1 */
5604 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5612 }
5614 /* %value_2 */
5615 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5623 }
5625 /* @address_1 */
5626 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
5628 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
5633 /* @address_2 */
5634 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
5636 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
5641 /* @address_3 */
5642 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
5644 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
5651 /* @address */
5652 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
5654 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
5663 case SIGCOMP_INSTR_SWITCH: /* 26 SWITCH (#n, %j, @address_0, @address_1, ... , @address_n-1) */
5664 /* #n */
5665 offset = dissect_udvm_literal_operand(udvm_tvb, sigcomp_udvm_tree, offset, &start_offset, &value);
5670 /* Number of addresses in the instruction */
5672 /* %j */
5673 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5681 }
5685 /* @address_n-1 */
5686 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true,&start_offset, &value, &is_memory_address);
5688 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
5692 }
5695 /* %value */
5696 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5704 }
5706 /* %position */
5707 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5712 /* %length */
5713 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5721 }
5723 /* @address */
5724 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
5726 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
5734 /* %length */
5735 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5743 }
5745 /* %destination */
5746 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5754 }
5756 /* @address */
5757 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
5759 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
5765 /* %length */
5766 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5774 }
5776 /* %destination */
5777 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5785 }
5787 /* @address */
5788 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
5790 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
5796 /*
5797 * INPUT-HUFFMAN (%destination, @address, #n, %bits_1, %lower_bound_1,
5798 * %upper_bound_1, %uncompressed_1, ... , %bits_n, %lower_bound_n,
5799 * %upper_bound_n, %uncompressed_n)
5800 */
5801 /* %destination */
5802 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5810 }
5811 /* @address */
5812 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
5814 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
5818 /* #n */
5819 offset = dissect_udvm_literal_operand(udvm_tvb, sigcomp_udvm_tree, offset, &start_offset, &value);
5826 /* %bits_n */
5827 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5831 /* %lower_bound_n*/
5832 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5836 /* %upper_bound_n */
5837 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5841 /* %uncompressed_n */
5842 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, false,&start_offset, &value, &is_memory_address);
5846 }
5850 /* STATE-ACCESS (%partial_identifier_start, %partial_identifier_length,
5851 * %state_begin, %state_length, %state_address, %state_instruction)
5852 */
5854 /*
5855 * %partial_identifier_start
5856 */
5857 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value ,&is_memory_address);
5862 /*
5863 * %partial_identifier_length
5864 */
5865 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value ,&is_memory_address);
5869 /*
5870 * %state_begin
5871 */
5872 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
5877 /*
5878 * %state_length
5879 */
5880 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
5888 }
5889 /*
5890 * %state_address
5891 */
5892 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value ,&is_memory_address);
5900 }
5901 /*
5902 * %state_instruction
5903 */
5904 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
5910 /*
5911 * STATE-CREATE (%state_length, %state_address, %state_instruction,
5912 * %minimum_access_length, %state_retention_priority)
5913 */
5915 /*
5916 * %state_length
5917 */
5918 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
5926 }
5927 /*
5928 * %state_address
5929 */
5930 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
5938 }
5939 /*
5940 * %state_instruction
5941 */
5942 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
5946 /*
5947 * %minimum_access_length
5948 */
5949 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
5953 /*
5954 * %state_retention_priority
5955 */
5956 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
5963 /*
5964 * STATE-FREE (%partial_identifier_start, %partial_identifier_length)
5965 */
5966 /*
5967 * %partial_identifier_start
5968 */
5969 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
5974 /*
5975 * %partial_identifier_length
5976 */
5977 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
5983 /*
5984 * %output_start
5985 */
5986 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
5994 }
5995 /*
5996 * %output_length
5997 */
5998 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
6006 }
6009 /*
6010 * END-MESSAGE (%requested_feedback_location,
6011 * %returned_parameters_location, %state_length, %state_address,
6012 * %state_instruction, %minimum_access_length,
6013 * %state_retention_priority)
6014 */
6015 /* %requested_feedback_location */
6017 proto_tree_add_expert(sigcomp_udvm_tree, pinfo, &ei_sigcomp_all_remaining_parameters_zero, udvm_tvb, 0, -1);
6019 }
6020 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
6024 /* returned_parameters_location */
6026 proto_tree_add_expert(sigcomp_udvm_tree, pinfo, &ei_sigcomp_all_remaining_parameters_zero, udvm_tvb, offset-1, -1);
6028 }
6029 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
6033 /*
6034 * %state_length
6035 */
6036 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
6044 }
6045 /*
6046 * %state_address
6047 */
6048 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
6056 }
6057 /*
6058 * %state_instruction
6059 */
6060 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
6064 /*
6065 * %minimum_access_length
6066 */
6067 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
6071 /*
6072 * %state_retention_priority
6073 */
6075 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, true, &start_offset, &value, &is_memory_address);
6080 item2 = proto_tree_add_uint_format_value(sigcomp_udvm_tree, hf_udvm_state_ret_pri, udvm_tvb, offset, 1, 0,
6083 }
6087 proto_tree_add_bytes_format(sigcomp_udvm_tree, hf_sigcomp_remaining_bytes, udvm_tvb, offset, len, NULL,
6088 "Remaining %u bytes starting at UDVM addr %u (0x%x)- State information ?",len, UDVM_address, UDVM_address);
6089 }
6096 }
6099 }
6101 }
6102 /* The simplest operand type is the literal (#), which encodes a
6103 * constant integer from 0 to 65535 inclusive. A literal operand may
6104 * require between 1 and 3 bytes depending on its value.
6105 * Bytecode: Operand value: Range:
6106 * 0nnnnnnn N 0 - 127
6107 * 10nnnnnn nnnnnnnn N 0 - 16383
6108 * 11000000 nnnnnnnn nnnnnnnn N 0 - 65535
6109 *
6110 * Figure 8: Bytecode for a literal (#) operand
6111 *
6112 */
6113 static int
6116 {
6127 /*
6128 * 10nnnnnn nnnnnnnn N 0 - 16383
6129 */
6140 /*
6141 * 111000000 nnnnnnnn nnnnnnnn N 0 - 65535
6142 */
6147 offset ++;
6153 }
6155 /*
6156 * 0nnnnnnn N 0 - 127
6157 */
6165 offset ++;
6166 }
6170 }
6171 /*
6172 * The second operand type is the reference ($), which is always used to
6173 * access a 2-byte value located elsewhere in the UDVM memory. The
6174 * bytecode for a reference operand is decoded to be a constant integer
6175 * from 0 to 65535 inclusive, which is interpreted as the memory address
6176 * containing the actual value of the operand.
6177 * Bytecode: Operand value: Range:
6178 *
6179 * 0nnnnnnn memory[2 * N] 0 - 65535
6180 * 10nnnnnn nnnnnnnn memory[2 * N] 0 - 65535
6181 * 11000000 nnnnnnnn nnnnnnnn memory[N] 0 - 65535
6182 *
6183 * Figure 9: Bytecode for a reference ($) operand
6184 */
6185 static int
6188 {
6199 /*
6200 * 10nnnnnn nnnnnnnn memory[2 * N] 0 - 65535
6201 */
6212 /*
6213 * 11000000 nnnnnnnn nnnnnnnn memory[N] 0 - 65535
6214 */
6219 offset ++;
6225 }
6227 /*
6228 * 0nnnnnnn memory[2 * N] 0 - 65535
6229 */
6237 offset ++;
6238 }
6241 }
6243 /*
6244 *The fourth operand type is the address (@). This operand is decoded
6245 * as a multitype operand followed by a further step: the memory address
6246 * of the UDVM instruction containing the address operand is added to
6247 * obtain the correct operand value. So if the operand value from
6248 * Figure 10 is D then the actual operand value of an address is
6249 * calculated as follows:
6250 *
6251 * operand_value = (is_memory_address_of_instruction + D) modulo 2^16
6252 * TODO calculate correct value for operand in case of ADDR
6253 */
6254 static int
6257 {
6263 /* RFC3320
6264 * Figure 10: Bytecode for a multitype (%) operand
6265 * Bytecode: Operand value: Range: HEX val
6266 * 00nnnnnn N 0 - 63 0x00
6267 * 01nnnnnn memory[2 * N] 0 - 65535 0x40
6268 * 1000011n 2 ^ (N + 6) 64 , 128 0x86
6269 * 10001nnn 2 ^ (N + 8) 256 , ... , 32768 0x88
6270 * 111nnnnn N + 65504 65504 - 65535 0xe0
6271 * 1001nnnn nnnnnnnn N + 61440 61440 - 65535 0x90
6272 * 101nnnnn nnnnnnnn N 0 - 8191 0xa0
6273 * 110nnnnn nnnnnnnn memory[N] 0 - 65535 0xc0
6274 * 10000000 nnnnnnnn nnnnnnnn N 0 - 65535 0x80
6275 * 10000001 nnnnnnnn nnnnnnnn memory[N] 0 - 65535 0x81
6276 */
6282 /*
6283 * 00nnnnnn N 0 - 63
6284 */
6292 offset ++;
6295 /*
6296 * 01nnnnnn memory[2 * N] 0 - 65535
6297 */
6306 offset ++;
6309 /* Check tree most significant bits */
6312 /*
6313 * 101nnnnn nnnnnnnn N 0 - 8191
6314 */
6326 /*
6327 * 1001nnnn nnnnnnnn N + 61440 61440 - 65535
6328 */
6340 /*
6341 * 10001nnn 2 ^ (N + 8) 256 , ... , 32768
6342 */
6351 offset ++;
6355 /*
6356 * 1000 011n 2 ^ (N + 6) 64 , 128
6357 */
6366 offset ++;
6368 /*
6369 * 1000 0000 nnnnnnnn nnnnnnnn N 0 - 65535
6370 * 1000 0001 nnnnnnnn nnnnnnnn memory[N] 0 - 65535
6371 */
6378 offset ++;
6383 }
6386 }
6387 }
6388 }
6394 /*
6395 * 111nnnnn N + 65504 65504 - 65535
6396 */
6404 offset ++;
6406 /*
6407 * 110nnnnn nnnnnnnn memory[N] 0 - 65535
6408 */
6418 }
6422 }
6424 }
6426 static void
6428 {
6436 }
6445 }
6446 }
6448 /* Register the protocol with Wireshark */
6450 void
6452 {
6453 /* Setup list of header fields See Section 1.6.1 for details*/
6459 },
6464 },
6469 },
6474 },
6479 },
6484 },
6489 },
6494 },
6499 },
6504 },
6509 },
6514 },
6519 },
6524 },
6529 },
6530 #if 0
6535 },
6536 #endif
6541 },
6546 },
6551 },
6556 },
6561 },
6566 },
6571 },
6576 },
6581 },
6586 },
6591 },
6596 },
6601 },
6607 },
6612 },
6617 },
6622 },
6627 },
6632 },
6637 },
6642 },
6647 },
6652 },
6657 },
6662 },
6667 },
6672 },
6677 },
6682 },
6687 },
6692 },
6697 },
6702 },
6707 },
6712 },
6717 },
6722 },
6727 },
6732 },
6737 },
6742 },
6747 },
6752 },
6757 },
6762 },
6767 },
6772 },
6777 },
6782 },
6787 },
6788 /* Generated from convert_proto_tree_add_text.pl */
6789 { &hf_sigcomp_accessing_state, { "### Accessing state ###", "sigcomp.accessing_state", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
6790 { &hf_sigcomp_getting_value, { "Getting value", "sigcomp.getting_value", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
6791 { &hf_sigcomp_load_bytecode_into_udvm_start, { "Load bytecode into UDVM starting at", "sigcomp.load_bytecode_into_udvm_start", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
6792 { &hf_sigcomp_instruction_code, { "Instruction code", "sigcomp.instruction_code", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
6793 { &hf_sigcomp_current_instruction, { "Addr", "sigcomp.current_instruction", FT_UINT8, BASE_DEC|BASE_EXT_STRING, &udvm_instruction_code_vals_ext, 0x0, NULL, HFILL }},
6794 { &hf_sigcomp_decompression_failure, { "DECOMPRESSION-FAILURE", "sigcomp.decompression_failure", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }},
6795 { &hf_sigcomp_wireshark_udvm_diagnostic, { "Wireshark UDVM diagnostic", "sigcomp.wireshark_udvm_diagnostic", FT_UINT32, BASE_DEC, VALS(result_code_vals), 0x0, NULL, HFILL }},
6796 { &hf_sigcomp_calculated_sha_1, { "Calculated SHA-1", "sigcomp.calculated_sha_1", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
6797 { &hf_sigcomp_copying_value, { "Copying value", "sigcomp.copying_value", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
6798 { &hf_sigcomp_storing_value, { "Storing value", "sigcomp.storing_value", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
6799 { &hf_sigcomp_loading_value, { "Loading value", "sigcomp.loading_value", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
6800 { &hf_sigcomp_set_hu, { "Set Hu", "sigcomp.set_hu", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
6801 { &hf_sigcomp_loading_h, { "Loading H", "sigcomp.loading_h", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
6802 { &hf_sigcomp_state_value, { "Addr", "sigcomp.state_value", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
6803 { &hf_sigcomp_output_value, { "Output value", "sigcomp.output_value", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
6804 { &hf_sigcomp_num_state_create, { "no_of_state_create", "sigcomp.num_state_create", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }},
6805 { &hf_sigcomp_sha1_digest, { "SHA1 digest", "sigcomp.sha1_digest", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
6806 { &hf_sigcomp_creating_state, { "### Creating state ###", "sigcomp.creating_state", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
6807 { &hf_sigcomp_sigcomp_message_decompressed, { "SigComp message Decompressed", "sigcomp.message_decompressed", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
6808 { &hf_sigcomp_starting_to_remove_escape_digits, { "Starting to remove escape digits", "sigcomp.starting_to_remove_escape_digits", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }},
6809 { &hf_sigcomp_escape_digit_found, { "Escape digit found", "sigcomp.escape_digit_found", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }},
6810 { &hf_sigcomp_illegal_escape_code, { "Illegal escape code", "sigcomp.illegal_escape_code", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }},
6811 { &hf_sigcomp_end_of_sigcomp_message_indication_found, { "End of SigComp message indication found", "sigcomp.end_of_sigcomp_message_indication_found", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }},
6812 { &hf_sigcomp_addr_value, { "Addr", "sigcomp.addr", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
6813 { &hf_sigcomp_copying_bytes_literally, { "Copying bytes literally", "sigcomp.copying_bytes_literally", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
6814 { &hf_sigcomp_data_for_sigcomp_dissector, { "Data handed to the Sigcomp dissector", "sigcomp.data_for_sigcomp_dissector", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
6815 { &hf_sigcomp_remaining_sigcomp_message, { "Remaining SigComp message", "sigcomp.remaining_sigcomp_message", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
6816 { &hf_sigcomp_sha1buff, { "sha1buff", "sigcomp.sha1buff", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
6817 { &hf_sigcomp_udvm_instruction, { "UDVM instruction", "sigcomp.udvm_instruction", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
6818 { &hf_sigcomp_remaining_bytes, { "Remaining bytes", "sigcomp.remaining_bytes", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
6819 { &hf_sigcomp_max_udvm_cycles, { "maximum_UDVM_cycles", "sigcomp.max_udvm_cycles", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }},
6820 { &hf_sigcomp_used_udvm_cycles, { "used_udvm_cycles", "sigcomp.used_udvm_cycles", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }},
6821 { &hf_sigcomp_udvm_execution_stated, { "UDVM EXECUTION STARTED", "sigcomp.udvm_execution_stated", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
6822 { &hf_sigcomp_message_length, { "Message Length", "sigcomp.message_length", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
6823 { &hf_sigcomp_byte_code_length, { "Byte code length", "sigcomp.byte_code_length", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
6824 };
6826 /* Setup protocol subtree array */
6831 };
6834 };
6837 { &ei_sigcomp_nack_failed_op_code, { "sigcomp.nack.failed_op_code.expert", PI_SEQUENCE, PI_WARN, "SigComp NACK", EXPFILL }},
6838 { &ei_sigcomp_invalid_instruction, { "sigcomp.invalid_instruction", PI_PROTOCOL, PI_WARN, "Invalid instruction", EXPFILL }},
6839 { &ei_sigcomp_invalid_shift_value, { "sigcomp.invalid_shift_value", PI_PROTOCOL, PI_WARN, "Invalid shift value", EXPFILL }},
6840 /* Generated from convert_proto_tree_add_text.pl */
6841 { &ei_sigcomp_sigcomp_message_decompression_failure, { "sigcomp.message_decompression_failure", PI_PROTOCOL, PI_WARN, "SigComp message Decompression failure", EXPFILL }},
6842 { &ei_sigcomp_execution_of_this_instruction_is_not_implemented, { "sigcomp.execution_of_this_instruction_is_not_implemented", PI_UNDECODED, PI_WARN, "Execution of this instruction is NOT implemented", EXPFILL }},
6843 { &ei_sigcomp_decompression_failure, { "sigcomp.decompression_failure_expert", PI_PROTOCOL, PI_WARN, "DECOMPRESSION FAILURE", EXPFILL }},
6844 { &ei_sigcomp_tcp_fragment, { "sigcomp.tcp_fragment", PI_MALFORMED, PI_ERROR, "TCP Fragment", EXPFILL }},
6845 { &ei_sigcomp_failed_to_access_state_wireshark_udvm_diagnostic, { "sigcomp.failed_to_access_state_wireshark_udvm_diagnostic", PI_PROTOCOL, PI_WARN, "Failed to Access state Wireshark UDVM diagnostic", EXPFILL }},
6846 { &ei_sigcomp_all_remaining_parameters_zero, { "sigcomp.all_remaining_parameters", PI_PROTOCOL, PI_NOTE, "All remaining parameters = 0(Not in the uploaded code as UDVM buffer initialized to Zero", EXPFILL }},
6847 };
6858 };
6861 /* Register the protocol name and description */
6863 proto_raw_sigcomp = proto_register_protocol("Decompressed SigComp message as raw text", "Raw_SigComp", "raw_sigcomp");
6868 /* Required function calls to register the header fields and subtrees used */
6875 /* Register a configuration option for port */
6885 "preference whether to display the bytecode in "
6894 "preference whether to display the decompressed message "
6899 "'No-Printout' = UDVM executes silently, then increasing detail "
6900 "about execution of UDVM instructions; "
6909 }
6911 void
6913 {
6915 dissector_add_uint_range_with_preference("tcp.port", SIGCOMP_TCP_PORT_RANGE, sigcomp_tcp_handle);
6917 }
6919 /*
6920 * Editor modelines - https://www.wireshark.org/tools/modelines.html
6921 *
6922 * Local variables:
6923 * c-basic-offset: 4
6924 * tab-width: 8
6925 * indent-tabs-mode: nil
6926 * End:
6927 *
6928 * vi: set shiftwidth=4 tabstop=8 expandtab:
6929 * :indentSize=4:tabSize=8:noTabs=true:
6930 */