/* packet-wbxml.c

 *

 * Routines for WAP Binary XML dissection

 * Copyright 2003, 2004, Olivier Biot.

 *

 * Routines for WV-CSP 1.3 dissection

 * Copyright 2007, Andrei Rubaniuk.

 *

 * Refer to the AUTHORS file or the AUTHORS section in the man page

 * for contacting the author(s) of this file.

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

 * WAP Binary XML decoding functionality provided by Olivier Biot.

 * WV-CSP 1.2 updated to Release version and WV-CSP 1.3 protocol

 * decoding functionality provided by Andrei Rubaniuk.

 *

 * The WAP specifications used to be found at the WAP Forum:

 *  <http://www.wapforum.org/what/Technical.htm>

 * But now the correct link is at the Open Mobile Alliance:

 *  <http://www.openmobilealliance.org/tech/affiliates/wap/wapindex.html>

 * Media types defined by OMA affiliates will have their standards at:

 *  <http://www.openmobilealliance.org/tech/affiliates/index.html>

 *  <http://www.openmobilealliance.org/release_program/index.html>

 *

 * SPDX-License-Identifier: GPL-2.0-or-later

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/exceptions.h>

#include <epan/prefs.h>

#include <epan/expert.h>

#include <epan/proto_data.h>

#include <epan/strutil.h>

#include <epan/iana_charsets.h>

/* We need the function tvb_get_uintvar() */

#include "packet-wap.h"

void proto_register_wbxml(void);

void proto_reg_handoff_wbxml(void);

/* General-purpose debug logger.

 * Requires double parentheses because of variable arguments of printf().

 *

 * Enable debug logging for WBXML by defining AM_FLAGS

 * so that it contains "-DDEBUG_wbxml"

 */

#ifdef DEBUG_wbxml

#define DebugLog(x)       \

  g_print("%s:%u: ", __FILE__, __LINE__); \

  g_print x

#else

#define DebugLog(x) ;

#endif

/* The code in this source file dissects the WAP Binary XML content,

 * and if possible renders it. WBXML mappings are defined in the

 * "wbxml_decoding" structure.

 *

 * NOTES:

 *

 *  - Some WBXML content is *not* backwards compatible across minor versions.

 *    This painful remark is true for:

 *      o  WMLC 1.0 with respect to later WMLC 1.x

 *      o  All WV-CSP versions (never backwards compatible)

 *    The only way of correctly rendering the WBXML is to let the end-user

 *    choose from the possible renderings. This only applies to the case when

 *    the WBXML DocType is not included in the WBXML header (unknown/missing).

 *

 *  - Some WBXML content uses EXT_T_* in a non-tableref manner. This is the

 *    case with WV-CSP 1.1 and up, where the index points to a value_string

 *    containing WV-CSP specific token values. This is allowed as it is not

 *    explicitly forbidden in the WBXML specifications. Hence the global token

 *    map for content must also contain a function pointer if no tableref

 *    string is used.

 *

 *  - Code page switches apply until a new code page switch. In the WBXML/1.x

 *    ABNF notation, it can be proven that the switch_page can only precede

 *    the following tokens:

 *      o  stag      : TAG | LITERAL | LITERAL_A | LITERAL_C | LITERAL_AC

 *      o  attr      : ATTRSTART | ATTRVALUE

 *      o  extension : EXT_I | EXT_T | EXT

 *    Code page switches are displayed in a separate column.

 *

 *  - The WBXML spec states that code pages are static to both the tag and the

 *    attribute state parser. A SWITCH_PAGE within a state switches the code

 *    page of the active state only. Note that code page 255 is reserved for

 *    application-specific (read: testing) purposes.

 *

 *  - In order to render the XML content, recursion is inevitable at some

 *    point (when a tag with content occurs in the content of a tag with

 *    content). The code will however not recurse if this is not strictly

 *    required (e.g., tag without content in the content of a tag with

 *    content).

 *

 *  - I found it useful to display the XML nesting level as a first "column",

 *    followed by the abbreviated WBXML token interpretation. When a mapping

 *    is defined for the parsed WBXML content, then the XML rendering is

 *    displayed with appropriate indentation (maximum nesting level = 255,

 *    after which the nesting and level will safely roll-over to 0).

 *

 *  - The WAP Forum defines the order of precedence for finding out the

 *    WBXML content type (same rules for charset) as follows:

 *      1. Look in the Content-Type WSP header

 *      2. Look in the WBXML header

 *    Currently there is no means of using content type parameters:

 *      o  Type=<some_type>

 *      o  Charset=<charset_of_the_content>

 *    So it is possible some WBXML content types are incorrectly parsed.

 *    This would only be the case when the content type declaration in the

 *    WSP Content-Type header would be different (or would have parameters

 *    which are relevant to the WBXML decoding) from the content type

 *    identifier specified in the WBXML header. This has to do with the

 *    decoding of terminated text strings in the different character codings.

 *    TODO: investigate this and provide correct decoding at all times.

 */

/************************** Variable declarations **************************/

/* Initialize the protocol and registered fields */

static int proto_wbxml;

static int hf_wbxml_version;

static int hf_wbxml_public_id_known;

static int hf_wbxml_public_id_literal;

static int hf_wbxml_charset;

static int hf_wbxml_string_table_item_offset;

static int hf_wbxml_string_table_item_string;

static int hf_wbxml_switch_page;

static int hf_wbxml_known_tag;

static int hf_wbxml_end_known_tag;

static int hf_wbxml_end_known_tag_uint;

static int hf_wbxml_str_i;

static int hf_wbxml_str_t;

static int hf_wbxml_opaque_data;

static int hf_wbxml_entity;

static int hf_wbxml_literal;

static int hf_wbxml_ext_i;

static int hf_wbxml_ext_t;

static int hf_wbxml_extension_token;

static int hf_wbxml_reserved_2;

static int hf_wbxml_invalid_token;

static int hf_wbxml_known_attrvalue;

static int hf_wbxml_known_attrstart;

static int hf_wbxml_end_literal_tag;

static int hf_wbxml_literal_a;

static int hf_wbxml_literal_c;

static int hf_wbxml_literal_ac;

static int hf_wbxml_end_pi;

static int hf_wbxml_end_attribute_list;

static int hf_wbxml_pi_xml;

/* Initialize the subtree pointers */

static int ett_wbxml;

static int ett_wbxml_str_tbl;

static int ett_wbxml_content;

static int ett_wbxml_tags;

static int ett_wbxml_string_table_item;

static expert_field ei_wbxml_data_not_shown;

static expert_field ei_wbxml_content_type_not_supported;

static expert_field ei_wbxml_content_type_disabled;

static expert_field ei_wbxml_oversized_uintvar;

static expert_field ei_wbxml_too_much_recursion;

static dissector_handle_t wbxml_handle;

/* WBXML Preferences */

static bool skip_wbxml_token_mapping;

static bool disable_wbxml_token_parsing;

typedef struct _value_valuestring {

  uint32_t value;

  const value_string *valstrptr;

} value_valuestring;

/* Tries to match val against each element in the value_value_string array vvs.

 * Returns the associated value_string ptr on a match, or NULL on failure. */

static const value_string *

val_to_valstr(uint32_t val, const value_valuestring *vvs)

{

  int i = 0;

  while (vvs[i].valstrptr) {

    if (vvs[i].value == val)

      return vvs[i].valstrptr;

    i++;

  }

  return NULL;

}

/* Note on Token mapping

 * ---------------------

 *

 * The WBXML dissector will try mapping the token decoding to their textual

 * representation if the media type has a defined token representation. The

 * following logic applies:

 *

 * a. Inspect the WBXML PublicID

 *  This means that I need a list { PublicID, decoding }

 *

 * b. Inspect the literal media type

 *  This requires a list { "media/type", discriminator, { decodings } }

 *

 *   b.1. Use a discriminator to choose an appropriate token mapping;

 *  The discriminator needs a small number of bytes from the data tvbuff_t.

 *

 * else

 *   b.2. Provide a list to the end-user with all possible token mappings.

 *

 * c. If none match then only show the tokens without mapping.

 *

 */

/* ext_t_func_ptr is a pointer to a function handling the EXT_T_i tokens:

 *

 * char * ext_t_function(tvbuff_t *tvb, uint32_t value, uint32_t strtbl);

 */

typedef char * (* ext_t_func_ptr)(wmem_allocator_t*, tvbuff_t *, uint32_t, uint32_t);

/* Note on parsing of OPAQUE data

 * ------------------------------

 *

 * The WBXML encapsulation allows the insertion of opaque binary data in the

 * WBXML body. Although this opaque data has no meaning in WBXML, the media

 * type itself may define compact encoding of given input by encoding it in

 * such a OPAQUE blob of bytes.

 *

 * The WBXML dissector now supports dissection of OPAQUE data by means of a

 * mapping function that will operate based on the token (well-known or literal)

 * and the active code page.

 *

 * For well-known tokens the simplest approach is to use a switch for the code

 * pages and another switch for the relevant tokens within a code page.

 *

 * For literal tokens (tags and attribute names), the only approach is a string

 * comparison with the literal representation of the given tag or attribute

 * name.

 *

 * opaque_token_func_ptr is a pointer to a function handling OPAQUE values

 * for binary tokens representing tags or attribute starts.

 * opaque_literal_func_ptr is a pointer to a function handling OPAQUE values

 * for literal tokens representing tags or attribute starts.

 *

 * The length field of the OPAQUE entry starts at offset (not offset + 1).

 *

 * The length of the processed OPAQUE value is returned by reference.

 *

 * char * opaque_token_function(tvbuff_t *tvb, uint32_t offset,

 *    uint8_t token, uint8_t codepage, uint32_t *length);

 * char * opaque_literal_function(tvbuff_t *tvb, uint32_t offset,

 *    const char *token, uint8_t codepage, uint32_t *length);

 */

typedef char * (* opaque_token_func_ptr)(tvbuff_t *, uint32_t, uint8_t, uint8_t, uint32_t *, packet_info *);

typedef char * (* opaque_literal_func_ptr)(tvbuff_t *, uint32_t, const char *, uint8_t, uint32_t *, packet_info *);

static char *

default_opaque_binary_tag(tvbuff_t *tvb, uint32_t offset,

        uint8_t token _U_, uint8_t codepage _U_, uint32_t *length, packet_info *pinfo)

{

  uint32_t data_len = tvb_get_uintvar(tvb, offset, length, pinfo, &ei_wbxml_oversized_uintvar);

  char *str = wmem_strdup_printf(pinfo->pool, "(%u bytes of opaque data)", data_len);

  *length += data_len;

  return str;

}

static char *

default_opaque_literal_tag(tvbuff_t *tvb, uint32_t offset,

         const char *token _U_, uint8_t codepage _U_, uint32_t *length, packet_info *pinfo)

{

  uint32_t data_len = tvb_get_uintvar(tvb, offset, length, pinfo, &ei_wbxml_oversized_uintvar);

  char *str = wmem_strdup_printf(pinfo->pool, "(%u bytes of opaque data)", data_len);

  *length += data_len;

  return str;

}

static char *

default_opaque_binary_attr(tvbuff_t *tvb, uint32_t offset,

         uint8_t token _U_, uint8_t codepage _U_, uint32_t *length, packet_info *pinfo)

{

  uint32_t data_len = tvb_get_uintvar(tvb, offset, length, pinfo, &ei_wbxml_oversized_uintvar);

  char *str = wmem_strdup_printf(pinfo->pool, "(%u bytes of opaque data)", data_len);

  *length += data_len;

  return str;

}

static char *

default_opaque_literal_attr(tvbuff_t *tvb, uint32_t offset,

          const char *token _U_, uint8_t codepage _U_, uint32_t *length, packet_info *pinfo)

{

  uint32_t data_len = tvb_get_uintvar(tvb, offset, length, pinfo, &ei_wbxml_oversized_uintvar);

  char *str = wmem_strdup_printf(pinfo->pool, "(%u bytes of opaque data)", data_len);

  *length += data_len;

  return str;

}

/* Render a hex %dateTime encoded timestamp as a string.

 * 0x20011231123456 becomes "2001-12-31T12:34:56Z" */

static char *

date_time_from_opaque(wmem_allocator_t *pool, tvbuff_t *tvb, uint32_t offset, uint32_t data_len)

{

  char *str;

  switch (data_len) {

  case 4: /* YYYY-MM-DD[T00:00:00Z] */

    str = wmem_strdup_printf(pool, "%%DateTime: "

              "%02x%02x-%02x-%02xT00:00:00Z",

              tvb_get_uint8(tvb, offset),

              tvb_get_uint8(tvb, offset + 1),

              tvb_get_uint8(tvb, offset + 2),

              tvb_get_uint8(tvb, offset + 3));

    break;

  case 5: /* YYYY-MM-DDThh[:00:00Z] */

    str = wmem_strdup_printf(pool, "%%DateTime: "

              "%02x%02x-%02x-%02xT%02x:00:00Z",

              tvb_get_uint8(tvb, offset),

              tvb_get_uint8(tvb, offset + 1),

              tvb_get_uint8(tvb, offset + 2),

              tvb_get_uint8(tvb, offset + 3),

              tvb_get_uint8(tvb, offset + 4));

    break;

  case 6: /* YYYY-MM-DDThh:mm[:00Z] */

    str = wmem_strdup_printf(pool, "%%DateTime: "

              "%02x%02x-%02x-%02xT%02x:%02x:00Z",

              tvb_get_uint8(tvb, offset),

              tvb_get_uint8(tvb, offset + 1),

              tvb_get_uint8(tvb, offset + 2),

              tvb_get_uint8(tvb, offset + 3),

              tvb_get_uint8(tvb, offset + 4),

              tvb_get_uint8(tvb, offset + 5));

    break;

  case 7: /* YYYY-MM-DDThh:mm[:00Z] */

    str = wmem_strdup_printf(pool, "%%DateTime: "

              "%02x%02x-%02x-%02xT%02x:%02x:%02xZ",

              tvb_get_uint8(tvb, offset),

              tvb_get_uint8(tvb, offset + 1),

              tvb_get_uint8(tvb, offset + 2),

              tvb_get_uint8(tvb, offset + 3),

              tvb_get_uint8(tvb, offset + 4),

              tvb_get_uint8(tvb, offset + 5),

              tvb_get_uint8(tvb, offset + 6));

    break;

  default:

    str = wmem_strdup_printf(pool, "<Error: invalid binary %%DateTime "

              "(%u bytes of opaque data)>", data_len);

    break;

  }

  return str;

}

/* Is ALWAYS 6 bytes long:

 * 00YY YYYY  YYYY YYMM  MMDD DDDh  hhhh mmmm  mmss ssss  ZZZZ ZZZZ */

static char *

wv_datetime_from_opaque(wmem_allocator_t *pool, tvbuff_t *tvb, uint32_t offset, uint32_t data_len)

{

  char *str;

  uint16_t year;

  uint8_t month, day, hour, minute, second, time_zone;

  uint8_t peek;

  if (data_len == 6) { /* Valid */

    /* Octet 1: 00YY YYYY */

    year = tvb_get_uint8(tvb, offset) & 0x3F; /* ..11 1111 */

    year <<=6;

    /* Octet 2: YYYY YYMM */

    peek = tvb_get_uint8(tvb, offset + 1);

    year += (peek >> 2); /* 1111 11.. */

    month = (peek & 0x03) << 2; /* .... ..11 */

    /* Octet 3: MMDD DDDh */

    peek = tvb_get_uint8(tvb, offset + 2);

    month += (peek >> 6); /* 11.. .... */

    day = (peek & 0x3E) >> 1; /* ..11 111. */

    hour = (peek & 0x01) << 4; /* .... ...1 */

    /* Octet 4: hhhh mmmm */

    peek = tvb_get_uint8(tvb, offset + 3);

    hour += (peek >> 4);

    minute = (peek & 0x0F) << 2; /* .... 1111 */

    /* Octet 5: mmss ssss */

    peek = tvb_get_uint8(tvb, offset + 4);

    minute += (peek >> 6); /* 11.. .... */

    second = peek & 0x3F; /* ..11 1111 */

    /* octet 6: ZZZZZZZZ */

    time_zone = tvb_get_uint8(tvb, offset + 5);

    /* Now construct the string */

    str = wmem_strdup_printf(pool, "WV-CSP DateTime: "

              "%04d-%02d-%02dT%02d:%02d:%02d%s",

              year, month, day, hour, minute, second, format_char(pool, time_zone));

  } else { /* Invalid length for a WV-CSP DateTime tag value */

    str = wmem_strdup_printf(pool, "<Error: invalid binary WV-CSP DateTime value "

              "(%u bytes of opaque data)>", data_len);

  }

  return str;

}

/* WV-CSP integer values for tag content is encoded in a fashion similar

 * to a Long-Integer in WSP */

static char *

wv_integer_from_opaque(wmem_allocator_t *pool, tvbuff_t *tvb, uint32_t offset, uint32_t data_len)

{

  char *str;

  switch (data_len) {

  case 1:

    str = wmem_strdup_printf(pool, "WV-CSP Integer: %d",

              tvb_get_uint8(tvb, offset));

    break;

  case 2:

    str = wmem_strdup_printf(pool, "WV-CSP Integer: %d",

              tvb_get_ntohs(tvb, offset));

    break;

  case 3:

    str = wmem_strdup_printf(pool, "WV-CSP Integer: %d",

              tvb_get_ntoh24(tvb, offset));

    break;

  case 4:

    str = wmem_strdup_printf(pool, "WV-CSP Integer: %d",

              tvb_get_ntohl(tvb, offset));

    break;

  default:

    str = wmem_strdup_printf(pool, "<Error: invalid binary WV-CSP Integer value "

              "(%u bytes of opaque data)>", data_len);

    break;

  }

  return str;

}

static char *

wv_csp10_opaque_binary_tag(tvbuff_t *tvb, uint32_t offset,

         uint8_t token, uint8_t codepage, uint32_t *length, packet_info *pinfo)

{

  uint32_t data_len = tvb_get_uintvar(tvb, offset, length, pinfo, &ei_wbxml_oversized_uintvar);

  char *str = NULL;

  switch (codepage) {

  case 0: /* Common code page */

    switch (token) {

    case 0x0B: /* <Code> */

    case 0x0F: /* <ContentSize> */

    case 0x1A: /* <MessageCount> */

    case 0x3C: /* <Validity> */

      str = wv_integer_from_opaque(pinfo->pool, tvb,

                 offset + *length, data_len);

      break;

    case 0x11: /* <DateTime> */

      str = wv_datetime_from_opaque(pinfo->pool, tvb,

                  offset + *length, data_len);

      break;

    default:

      break;

    }

    break;

  case 1: /* Access code page */

    switch (token) {

    case 0x1C: /* <KeepAliveTime> */

    case 0x32: /* <TimeToLive> */

      str = wv_integer_from_opaque(pinfo->pool, tvb,

                 offset + *length, data_len);

      break;

    default:

      break;

    }

    break;

  case 3: /* Client capability code page */

    switch (token) {

    case 0x06: /* <AcceptedContentLength> */

    case 0x0C: /* <MultiTrans> */

    case 0x0D: /* <ParserSize> */

    case 0x0E: /* <ServerPollMin> */

    case 0x11: /* <TCPAddress> */

    case 0x12: /* <TCPPort> */

    case 0x13: /* <UDPPort> */

      str = wv_integer_from_opaque(pinfo->pool, tvb,

                 offset + *length, data_len);

      break;

    default:

      break;

    }

    break;

  default:

    break;

  }

  if (str == NULL) { /* Error, or not parsed */

    str = wmem_strdup_printf(pinfo->pool, "(%u bytes of unparsed opaque data)", data_len);

  }

  *length += data_len;

  return str;

}

static char *

wv_csp10_opaque_literal_tag(tvbuff_t *tvb, uint32_t offset,

          const char *token, uint8_t codepage _U_, uint32_t *length, packet_info *pinfo)

{

  uint32_t data_len = tvb_get_uintvar(tvb, offset, length, pinfo, &ei_wbxml_oversized_uintvar);

  char *str = NULL;

  if ( token && ( (strcmp(token, "Code") == 0)

      || (strcmp(token, "ContentSize") == 0)

      || (strcmp(token, "MessageCount") == 0)

      || (strcmp(token, "Validity") == 0)

      || (strcmp(token, "KeepAliveTime") == 0)

      || (strcmp(token, "TimeToLive") == 0)

      || (strcmp(token, "AcceptedContentLength") == 0)

      || (strcmp(token, "MultiTrans") == 0)

      || (strcmp(token, "ParserSize") == 0)

      || (strcmp(token, "ServerPollMin") == 0)

      || (strcmp(token, "TCPAddress") == 0)

      || (strcmp(token, "TCPPort") == 0)

      || (strcmp(token, "UDPPort") == 0) ) )

    {

      str = wv_integer_from_opaque(pinfo->pool, tvb, offset + *length, data_len);

    }

  else if ( token && ( strcmp(token, "DateTime") == 0) )

    {

      str = wv_datetime_from_opaque(pinfo->pool, tvb, offset + *length, data_len);

    }

  if (str == NULL) { /* Error, or not parsed */

    str = wmem_strdup_printf(pinfo->pool, "(%d bytes of unparsed opaque data)", data_len);

  }

  *length += data_len;

  return str;

}

static char *

wv_csp11_opaque_binary_tag(tvbuff_t *tvb, uint32_t offset,

         uint8_t token, uint8_t codepage, uint32_t *length, packet_info *pinfo)

{

  uint32_t data_len = tvb_get_uintvar(tvb, offset, length, pinfo, &ei_wbxml_oversized_uintvar);

  char *str = NULL;

  switch (codepage) {

  case 0: /* Common code page */

    switch (token) {

    case 0x0B: /* <Code> */

    case 0x0F: /* <ContentSize> */

    case 0x1A: /* <MessageCount> */

    case 0x3C: /* <Validity> */

      str = wv_integer_from_opaque(pinfo->pool, tvb,

                 offset + *length, data_len);

      break;

    case 0x11: /* <DateTime> */

      str = wv_datetime_from_opaque(pinfo->pool, tvb,

                  offset + *length, data_len);

      break;

    default:

      break;

    }

    break;

  case 1: /* Access code page */

    switch (token) {

    case 0x1C: /* <KeepAliveTime> */

    case 0x32: /* <TimeToLive> */

      str = wv_integer_from_opaque(pinfo->pool, tvb,

                 offset + *length, data_len);

      break;

    default:

      break;

    }

    break;

  case 3: /* Client capability code page */

    switch (token) {

    case 0x06: /* <AcceptedContentLength> */

    case 0x0C: /* <MultiTrans> */

    case 0x0D: /* <ParserSize> */

    case 0x0E: /* <ServerPollMin> */

    case 0x12: /* <TCPPort> */

    case 0x13: /* <UDPPort> */

      str = wv_integer_from_opaque(pinfo->pool, tvb,

                 offset + *length, data_len);

      break;

    default:

      break;

    }

    break;

  case 6: /* Messaging code page */

    switch (token) {

    case 0x1A: /* <DeliveryTime> - not in 1.0 */

      str = wv_datetime_from_opaque(pinfo->pool, tvb,

                  offset + *length, data_len);

      break;

    default:

      break;

    }

    break;

  default:

    break;

  }

  if (str == NULL) { /* Error, or not parsed */

    str = wmem_strdup_printf(pinfo->pool, "(%d bytes of unparsed opaque data)", data_len);

  }

  *length += data_len;

  return str;

}

static char *

wv_csp11_opaque_literal_tag(tvbuff_t *tvb, uint32_t offset,

          const char *token, uint8_t codepage _U_, uint32_t *length, packet_info *pinfo)

{

  uint32_t data_len = tvb_get_uintvar(tvb, offset, length, pinfo, &ei_wbxml_oversized_uintvar);

  char *str = NULL;

  if ( token && ( (strcmp(token, "Code") == 0)

      || (strcmp(token, "ContentSize") == 0)

      || (strcmp(token, "MessageCount") == 0)

      || (strcmp(token, "Validity") == 0)

      || (strcmp(token, "KeepAliveTime") == 0)

      || (strcmp(token, "TimeToLive") == 0)

      || (strcmp(token, "AcceptedContentLength") == 0)

      || (strcmp(token, "MultiTrans") == 0)

      || (strcmp(token, "ParserSize") == 0)

      || (strcmp(token, "ServerPollMin") == 0)

      || (strcmp(token, "TCPPort") == 0)

      || (strcmp(token, "UDPPort") == 0) ) )

    {

      str = wv_integer_from_opaque(pinfo->pool, tvb, offset + *length, data_len);

    }

  else

    if ( token && ( (strcmp(token, "DateTime") == 0)

        || (strcmp(token, "DeliveryTime") == 0) ) )

      {

        str = wv_datetime_from_opaque(pinfo->pool, tvb, offset + *length, data_len);

      }

  if (str == NULL) { /* Error, or not parsed */

    str = wmem_strdup_printf(pinfo->pool, "(%d bytes of unparsed opaque data)", data_len);

  }

  *length += data_len;

  return str;

}

static char *

wv_csp12_opaque_binary_tag(tvbuff_t *tvb, uint32_t offset,

         uint8_t token, uint8_t codepage, uint32_t *length, packet_info *pinfo)

{

  uint32_t data_len = tvb_get_uintvar(tvb, offset, length, pinfo, &ei_wbxml_oversized_uintvar);

  char *str = NULL;

  switch (codepage) {

  case 0: /* Common code page */

    switch (token) {

    case 0x0B: /* <Code> */

    case 0x0F: /* <ContentSize> */

    case 0x1A: /* <MessageCount> */

    case 0x3C: /* <Validity> */

      str = wv_integer_from_opaque(pinfo->pool, tvb,

                 offset + *length, data_len);

      break;

    case 0x11: /* <DateTime> */

      str = wv_datetime_from_opaque(pinfo->pool, tvb,

                  offset + *length, data_len);

      break;

    default:

      break;

    }

    break;

  case 1: /* Access code page */

    switch (token) {

    case 0x1C: /* <KeepAliveTime> */

    case 0x32: /* <TimeToLive> */

      str = wv_integer_from_opaque(pinfo->pool, tvb,

                 offset + *length, data_len);

      break;

    default:

      break;

    }

    break;

  case 3: /* Client capability code page */

    switch (token) {

    case 0x06: /* <AcceptedContentLength> */

    case 0x0C: /* <MultiTrans> */

    case 0x0D: /* <ParserSize> */

    case 0x0E: /* <ServerPollMin> */

    case 0x12: /* <TCPPort> */

    case 0x13: /* <UDPPort> */

      str = wv_integer_from_opaque(pinfo->pool, tvb,

                 offset + *length, data_len);

      break;

    default:

      break;

    }

    break;

  case 6: /* Messaging code page */

    switch (token) {

    case 0x1A: /* <DeliveryTime> - not in 1.0 */

      str = wv_datetime_from_opaque(pinfo->pool, tvb,

                  offset + *length, data_len);

      break;

    default:

      break;

    }

    break;

  case 9: /* Common code page (continued) */

    switch (token) {

    case 0x08: /* <HistoryPeriod> - 1.2 only */

    case 0x0A: /* <MaxWatcherList> - 1.2 only */

      str = wv_integer_from_opaque(pinfo->pool, tvb,

                 offset + *length, data_len);

      break;

    default:

      break;

    }

    break;

  default:

    break;

  }

  if (str == NULL) { /* Error, or not parsed */

    str = wmem_strdup_printf(pinfo->pool, "(%d bytes of unparsed opaque data)", data_len);

  }

  *length += data_len;

  return str;

}

static char *

wv_csp12_opaque_literal_tag(tvbuff_t *tvb, uint32_t offset,

          const char *token, uint8_t codepage _U_, uint32_t *length, packet_info *pinfo)

{

  uint32_t data_len = tvb_get_uintvar(tvb, offset, length, pinfo, &ei_wbxml_oversized_uintvar);

  char *str = NULL;

  if ( token && ( (strcmp(token, "Code") == 0)

      || (strcmp(token, "ContentSize") == 0)

      || (strcmp(token, "MessageCount") == 0)

      || (strcmp(token, "Validity") == 0)

      || (strcmp(token, "KeepAliveTime") == 0)

      || (strcmp(token, "TimeToLive") == 0)

      || (strcmp(token, "AcceptedContentLength") == 0)

      || (strcmp(token, "MultiTrans") == 0)

      || (strcmp(token, "ParserSize") == 0)

      || (strcmp(token, "ServerPollMin") == 0)

      || (strcmp(token, "TCPPort") == 0)

      || (strcmp(token, "UDPPort") == 0)

      || (strcmp(token, "HistoryPeriod") == 0)

      || (strcmp(token, "MaxWatcherList") == 0) ) )

    {

      str = wv_integer_from_opaque(pinfo->pool, tvb, offset + *length, data_len);

    }

  else

    if ( token && ( (strcmp(token, "DateTime") == 0)

        || (strcmp(token, "DeliveryTime") == 0) ) )

      {

        str = wv_datetime_from_opaque(pinfo->pool, tvb, offset + *length, data_len);

      }

  if (str == NULL) { /* Error, or not parsed */

    str = wmem_strdup_printf(pinfo->pool, "(%d bytes of unparsed opaque data)", data_len);

  }

  *length += data_len;

  return str;

}

static char *

wv_csp13_opaque_binary_tag(tvbuff_t *tvb, uint32_t offset,

         uint8_t token, uint8_t codepage, uint32_t *length, packet_info *pinfo)

{

  uint32_t data_len = tvb_get_uintvar(tvb, offset, length, pinfo, &ei_wbxml_oversized_uintvar);

  char *str = NULL;

  switch (codepage)

    {

    case 0: /* Common code page */

      switch (token)

        {

        case 0x0B: /* <Code> */

        case 0x0F: /* <ContentSize> */

        case 0x1A: /* <MessageCount> */

        case 0x3C: /* <Validity> */

          str = wv_integer_from_opaque(pinfo->pool, tvb, offset + *length, data_len);

          break;

        case 0x11: /* <DateTime> */

          str = wv_datetime_from_opaque(pinfo->pool, tvb, offset + *length, data_len);

          break;

        default:

          break;

        }

      break;

    case 1: /* Access code page */

      switch (token)

        {

        case 0x1C: /* <KeepAliveTime> */

        case 0x25: /* <SearchFindings> */

        case 0x26: /* <SearchID> */

        case 0x27: /* <SearchIndex> */

        case 0x28: /* <SearchLimit> */

        case 0x32: /* <TimeToLive> */

          str = wv_integer_from_opaque(pinfo->pool, tvb, offset + *length, data_len);

          break;

        default:

          break;

        }

      break;

    case 3: /* Client capability code page */

      switch (token)

        {

        case 0x06: /* <AcceptedContentLength> */

        case 0x0C: /* <MultiTrans> */

        case 0x0D: /* <ParserSize> */

        case 0x0E: /* <ServerPollMin> */

        case 0x12: /* <TCPPort> */

        case 0x13: /* <UDPPort> */

          /* New in WV-CSP 1.3*/

        case 0x16: /* <AcceptedPullLength> */

        case 0x17: /* <AcceptedPushLength> */

        case 0x18: /* <AcceptedRichContentLength> */

        case 0x19: /* <AcceptedTextContentLength> */

        case 0x1B: /* <PlainTextCharset> MIBenum number - character set, i.e. UTF-8, windows-1251, etc. */

        case 0x1C: /* <SessionPriority> */

        case 0x1F: /* <UserSessionLimit> */

        case 0x21: /* <MultiTransPerMessage> */

        case 0x24: /* <ContentPolicyLimit> */

          str = wv_integer_from_opaque(pinfo->pool, tvb, offset + *length, data_len);

          break;

        default:

          break;

        }

      break;

    case 5: /* Presence attribute code page */

      switch (token)

        {

          /* New in WV-CSP 1.3*/

          /*    case 0x3B: */ /* <ClientContentLimit> */

        case 0x3C: /* <ClientIMPriority> */

        case 0x3D: /* <MaxPullLength> */

        case 0x3E: /* <MaxPushLength> */

          str = wv_integer_from_opaque(pinfo->pool, tvb, offset + *length, data_len);

          break;

        default:

          break;

        }

      break;

    case 6: /* Messaging code page */

      switch (token)

        {

        case 0x1A: /* <DeliveryTime> - not in 1.0 */

          /* New in WV-CSP 1.3*/

        case 0x1C: /* <AnswerOptionID> */

          str = wv_datetime_from_opaque(pinfo->pool, tvb, offset + *length, data_len);

          break;

        default:

          break;

        }

      break;

    case 9: /* Common code page (continued) */

      switch (token)

        {

        case 0x08: /* <HistoryPeriod> - 1.2 only */

        case 0x0A: /* <MaxWatcherList> - 1.2 only */

          /* New in WV-CSP 1.3*/

        case 0x25: /* <SegmentCount> */

        case 0x28: /* <SegmentReference> */

        case 0x30: /* <TryAgainTimeout> */

        case 0x3A: /* <GroupContentLimit> */

        case 0x3B: /* <MessageTotalCount> */

          str = wv_integer_from_opaque(pinfo->pool, tvb, offset + *length, data_len);

          break;

        default:

          break;

        }

      break;

    case 10:

      switch (token)

        {

          /* New in WV-CSP 1.3*/

        case 0x0C: /* <PairID> */

          str = wv_integer_from_opaque(pinfo->pool, tvb, offset + *length, data_len);

          break;

        default:

          break;

        }

      break;

    default:

      break;

    }

  if (str == NULL)

    { /* Error, or not parsed */

      str = wmem_strdup_printf(pinfo->pool, "(%d bytes of unparsed opaque data)", data_len);

    }

  *length += data_len;

  return str;

}

static char *

wv_csp13_opaque_literal_tag(tvbuff_t *tvb, uint32_t offset,

          const char *token, uint8_t codepage _U_, uint32_t *length, packet_info *pinfo)

{

  uint32_t data_len = tvb_get_uintvar(tvb, offset, length, pinfo, &ei_wbxml_oversized_uintvar);

  char *str = NULL;

  if ( token && ( (strcmp(token, "Code") == 0)

      || (strcmp(token, "ContentSize") == 0)

      || (strcmp(token, "MessageCount") == 0)

      || (strcmp(token, "Validity") == 0)

      || (strcmp(token, "KeepAliveTime") == 0)

      || (strcmp(token, "TimeToLive") == 0)

      || (strcmp(token, "AcceptedContentLength") == 0)

      || (strcmp(token, "MultiTrans") == 0)

      || (strcmp(token, "ParserSize") == 0)

      || (strcmp(token, "ServerPollMin") == 0)

      || (strcmp(token, "TCPPort") == 0)

      || (strcmp(token, "UDPPort") == 0)

      || (strcmp(token, "HistoryPeriod") == 0)

      || (strcmp(token, "MaxWatcherList") == 0)

      /* New in WV-CSP 1.3*/

      || (strcmp(token, "SearchFindings") == 0)

      || (strcmp(token, "SearchID") == 0)

      || (strcmp(token, "SearchIndex") == 0)

      || (strcmp(token, "SearchLimit") == 0)

      || (strcmp(token, "AcceptedPullLength") == 0)

      || (strcmp(token, "AcceptedPushLength") == 0)

      || (strcmp(token, "AcceptedRichContentLength") == 0)

      || (strcmp(token, "AcceptedTextContentLength") == 0)

      || (strcmp(token, "SessionPriority") == 0)

      || (strcmp(token, "UserSessionLimit") == 0)

      || (strcmp(token, "MultiTransPerMessage") == 0)

      || (strcmp(token, "ContentPolicyLimit") == 0)

      || (strcmp(token, "AnswerOptionID") == 0)

      || (strcmp(token, "SegmentCount") == 0)

      || (strcmp(token, "SegmentReference") == 0)

      || (strcmp(token, "TryAgainTimeout") == 0)

      || (strcmp(token, "GroupContentLimit") == 0)

      || (strcmp(token, "MessageTotalCount") == 0)

      || (strcmp(token, "PairID") == 0) ) )

    {

      str = wv_integer_from_opaque(pinfo->pool, tvb, offset + *length, data_len);

    }

  else

    if ( token && ( (strcmp(token, "DateTime") == 0)

        || (strcmp(token, "DeliveryTime") == 0) ) )

      {

        str = wv_datetime_from_opaque(pinfo->pool, tvb, offset + *length, data_len);

      }

  if (str == NULL) { /* Error, or not parsed */

    str = wmem_strdup_printf(pinfo->pool, "(%d bytes of unparsed opaque data)", data_len);

  }

  *length += data_len;

  return str;

}

static char *

sic10_opaque_literal_attr(tvbuff_t *tvb, uint32_t offset,

        const char *token, uint8_t codepage _U_, uint32_t *length, packet_info *pinfo)

{

  uint32_t data_len = tvb_get_uintvar(tvb, offset, length, pinfo, &ei_wbxml_oversized_uintvar);

  char *str = NULL;

  if ( token && ( (strcmp(token, "created") == 0)

      || (strcmp(token, "si-expires") == 0) ) )

    {