/builds/wireshark/wireshark/epan/tvbuff.c

Bug Summary

File:	builds/wireshark/wireshark/epan/tvbuff.c
Warning:	line 520, column 10 Potential leak of memory pointed to by 'buf'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name tvbuff.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -ffloat16-excess-precision=fast -fbfloat16-excess-precision=fast -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/builds/wireshark/wireshark/build -fcoverage-compilation-dir=/builds/wireshark/wireshark/build -resource-dir /usr/lib/llvm-22/lib/clang/22 -isystem /usr/include/glib-2.0 -isystem /usr/lib/x86_64-linux-gnu/glib-2.0/include -isystem /builds/wireshark/wireshark/epan -isystem /builds/wireshark/wireshark/build/epan -isystem /usr/include/mit-krb5 -isystem /usr/include/lua5.5 -isystem /usr/include/libxml2 -D CARES_NO_DEPRECATED -D G_DISABLE_DEPRECATED -D G_DISABLE_SINGLE_INCLUDES -D REX_API=extern -D WS_BUILD_DLL -D WS_DEBUG -D WS_DEBUG_UTF_8 -D epan_EXPORTS -I /builds/wireshark/wireshark/build -I /builds/wireshark/wireshark -I /builds/wireshark/wireshark/include -I /builds/wireshark/wireshark/wiretap -D _GLIBCXX_ASSERTIONS -internal-isystem /usr/lib/llvm-22/lib/clang/22/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/16/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/builds/wireshark/wireshark/= -fmacro-prefix-map=/builds/wireshark/wireshark/build/= -fmacro-prefix-map=../= -Wno-format-nonliteral -std=gnu17 -ferror-limit 19 -fvisibility=hidden -fwrapv -fwrapv-pointer -fstrict-flex-arrays=3 -stack-protector 2 -fstack-clash-protection -fcf-protection=full -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fexceptions -fcolor-diagnostics -analyzer-output=html -faddrsig -fdwarf2-cfi-asm -o /builds/wireshark/wireshark/sbout/2026-08-30-100350-3660-1 -x c /builds/wireshark/wireshark/epan/tvbuff.c
1/* tvbuff.c
*
* Testy, Virtual(-izable) Buffer of uint8_t*'s
*
* "Testy" -- the buffer gets mad when an attempt to access data
*		beyond the bounds of the buffer. An exception is thrown.
*
* "Virtual" -- the buffer can have its own data, can use a subset of
*		the data of a backing tvbuff, or can be a composite of
*		other tvbuffs.
*
* Copyright (c) 2000 by Gilbert Ramirez <gram@alumni.rice.edu>
*
* Code to convert IEEE floating point formats to native floating point
* derived from code Copyright (c) Ashok Narayanan, 2000
*
* Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* Copyright 1998 Gerald Combs
*
* SPDX-License-Identifier: GPL-2.0-or-later
*/

24#include "config.h"

26#include <string.h>
27#include <stdio.h>
28#include <errno(*__errno_location ()).h>

30#include <glib.h>

32#include "wsutil/pint.h"
33#include "wsutil/sign_ext.h"
34#include "wsutil/strtoi.h"
35#include "wsutil/unicode-utils.h"
36#include "wsutil/nstime.h"
37#include "wsutil/time_util.h"
38#include <wsutil/ws_assert.h>
39#include "tvbuff.h"
40#include "tvbuff-int.h"
41#include "strutil.h"
42#include "to_str.h"
43#include "charsets.h"
44#include "proto.h"	/* XXX - only used for DISSECTOR_ASSERT, probably a new header file? */
45#include "exceptions.h"

47#include <time.h>

49static uint64_t
50_tvb_get_bits64(tvbuff_t *tvb, unsigned bit_offset, const unsigned total_no_of_bits);

52static uint64_t
53_tvb_get_bits64_le(tvbuff_t *tvb, unsigned bit_offset, const unsigned total_no_of_bits);

55static inline unsigned
56_tvb_captured_length_remaining(const tvbuff_t *tvb, const unsigned offset);

58static inline const uint8_t*
59ensure_contiguous(tvbuff_t *tvb, const int offset, const int length);

61/* coverity[ +taint_sanitize : arg-1 ] */
62/* coverity[ +taint_sanitize : arg-2 ] */
63static inline const uint8_t*
64ensure_contiguous_unsigned(tvbuff_t *tvb, const unsigned offset, const unsigned length);

66static inline uint8_t *
67tvb_get_raw_string(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, const unsigned length);

69tvbuff_t *
70tvb_new(const struct tvb_ops *ops)
71{
tvbuff_t *tvb;
size_t    size = ops->tvb_size;

ws_assert(size >= sizeof(*tvb))do { if ((1) && !(size >= sizeof(*tvb))) ws_log_fatal_full
("", LOG_LEVEL_ERROR, "epan/tvbuff.c", 75, __func__, "assertion failed: %s"
, "size >= sizeof(*tvb)"); } while (0);

tvb = (tvbuff_t *) g_slice_alloc(size);

tvb->next		 = NULL((void*)0);
tvb->ops		 = ops;
tvb->initialized	 = false0;
tvb->flags		 = 0;
tvb->length		 = 0;
tvb->reported_length	 = 0;
tvb->contained_length	 = 0;
tvb->real_data		 = NULL((void*)0);
tvb->raw_offset		 = 0;
tvb->ds_tvb		 = NULL((void*)0);

return tvb;
91}

93static void
94tvb_free_internal(tvbuff_t *tvb)
95{
size_t    size;

DISSECTOR_ASSERT(tvb)((void) ((tvb) ? (void)0 : (proto_report_dissector_bug("%s:%u: failed assertion \"%s\""
, "epan/tvbuff.c", 98, "tvb"))));

if (tvb->ops->tvb_free)
tvb->ops->tvb_free(tvb);

size = tvb->ops->tvb_size;

g_slice_free1(size, tvb);
106}

108/* XXX: just call tvb_free_chain();
*      Not removed so that existing dissectors using tvb_free() need not be changed.
*      I'd argue that existing calls to tvb_free() should have actually been
*      calls to tvb_free_chain() although the calls were OK as long as no
*      subsets, etc had been created on the tvb. */
113void
114tvb_free(tvbuff_t *tvb)
115{
tvb_free_chain(tvb);
117}

119void
120tvb_free_chain(tvbuff_t  *tvb)
121{
tvbuff_t *next_tvb;
DISSECTOR_ASSERT(tvb)((void) ((tvb) ? (void)0 : (proto_report_dissector_bug("%s:%u: failed assertion \"%s\""
, "epan/tvbuff.c", 123, "tvb"))));
while (tvb) {
next_tvb = tvb->next;
tvb_free_internal(tvb);
tvb  = next_tvb;
}
129}

131tvbuff_t *
132tvb_new_chain(tvbuff_t *parent, tvbuff_t *backing)
133{
tvbuff_t *tvb = tvb_new_proxy(backing);

tvb_add_to_chain(parent, tvb);
return tvb;
138}

140void
141tvb_add_to_chain(tvbuff_t *parent, tvbuff_t *child)
142{
tvbuff_t *tmp;

DISSECTOR_ASSERT(parent)((void) ((parent) ? (void)0 : (proto_report_dissector_bug("%s:%u: failed assertion \"%s\""
, "epan/tvbuff.c", 145, "parent"))));
DISSECTOR_ASSERT(child)((void) ((child) ? (void)0 : (proto_report_dissector_bug("%s:%u: failed assertion \"%s\""
, "epan/tvbuff.c", 146, "child"))));

while (child) {
tmp   = child;
child = child->next;

tmp->next    = parent->next;
parent->next = tmp;
}
155}

157/*
* Check whether that offset goes more than one byte past the
* end of the buffer.
*
* If not, return 0; otherwise, return exception
*/
163static inline int
164validate_offset(const tvbuff_t *tvb, const unsigned abs_offset)
165{
if (G_LIKELY(abs_offset <= tvb->length)(abs_offset <= tvb->length)) {
/* It's OK. */
return 0;
}

/*
* It's not OK, but why?  Which boundaries is it
* past?
*/
if (abs_offset <= tvb->contained_length) {
/*
 * It's past the captured length, but not past
 * the reported end of any parent tvbuffs from
 * which this is constructed, or the reported
 * end of this tvbuff, so it's out of bounds
 * solely because we're past the end of the
 * captured data.
 */
return BoundsError1;
}

/*
* There's some actual packet boundary, not just the
* artificial boundary imposed by packet slicing, that
* we're past.
*/

if (tvb->flags & TVBUFF_FRAGMENT0x00000001) {
/*
 * This tvbuff is the first fragment of a larger
 * packet that hasn't been reassembled, so we
 * assume that's the source of the problem - if
 * we'd reassembled the packet, we wouldn't have
 * gone past the end.
 *
 * That might not be true, but for at least
 * some forms of reassembly, such as IP
 * reassembly, you don't know how big the
 * reassembled packet is unless you reassemble
 * it, so, in those cases, we can't determine
 * whether we would have gone past the end
 * had we reassembled the packet.
 */
return FragmentBoundsError4;
}

/* OK, we're not an unreassembled fragment (that we know of). */
if (abs_offset <= tvb->reported_length) {
/*
 * We're within the bounds of what this tvbuff
 * purportedly contains, based on some length
 * value, but we're not within the bounds of
 * something from which this tvbuff was
 * extracted, so that length value ran past
 * the end of some parent tvbuff.
 */
return ContainedBoundsError2;
}

/*
* OK, it looks as if we ran past the claimed length
* of data.
*/
return ReportedBoundsError3;
230}

232static inline int
233validate_offset_and_remaining(const tvbuff_t *tvb, const unsigned offset, unsigned *rem_len)
234{
int exception;

exception = validate_offset(tvb, offset);
if (!exception)
*rem_len = tvb->length - offset;

return exception;
242}

244/* Returns integer indicating whether the given offset and the end offset
* calculated from that offset and the given length are in bounds (0) or
* not (exception number).
* No exception is thrown; on success, we return 0, otherwise we return an
* exception for the caller to throw if appropriate.
*
* N.B. - we return success (0), if the offset is positive and right
* after the end of the tvbuff (i.e., equal to the length).  We do this
* so that a dissector constructing a subset tvbuff for the next protocol
* will get a zero-length tvbuff, not an exception, if there's no data
* left for the next protocol - we want the next protocol to be the one
* that gets an exception, so the error is reported as an error in that
* protocol rather than the containing protocol.  */
257static inline int
258validate_offset_length_no_exception(const tvbuff_t *tvb,
		    const unsigned offset, const unsigned length)
260{
unsigned end_offset;
int   exception;

/* Compute the offset */
/* Since offset is unsigned, the only effect of validation is to throw
* a possibly different exception if offset is outside the captured
* bytes. E.g., offset could be outside the captured bytes but in the
* reported length, but end_offset outside the reported length.
* XXX - Which *is* the proper exception? Compare fast_ensure_contiguous
* which only throws the exception related to the end offset.
*/
exception = validate_offset(tvb, offset);
if (exception)
return exception;

/*
* Compute the offset of the first byte past the length,
* checking for an overflow.
*/
if (ckd_add(&end_offset, offset, length)__builtin_add_overflow((offset), (length), (&end_offset)))
return BoundsError1;

return validate_offset(tvb, end_offset);
284}

286/* Checks offset and length and throws an exception if
* either is out of bounds. Sets integer ptrs to the new length. */
288static inline void
289validate_offset_length(const tvbuff_t *tvb,
    const unsigned offset, const unsigned length)
291{
int exception;

exception = validate_offset_length_no_exception(tvb, offset, length);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));
297}

299/* Internal function so that other translation units can use
* validate_offset_length. */
301void
302tvb_validate_offset_length(const tvbuff_t *tvb,
	   const unsigned offset, const unsigned length)
304{
validate_offset_length(tvb, offset, length);
306}

308/* Internal function so that other translation units can use
* validate_offset_and_remaining. This throws the exception
* from validate_offset_and_remaining. */
311void
312tvb_validate_offset_and_remaining(const tvbuff_t *tvb,
		  const unsigned offset, unsigned *rem_len)
314{
int exception;

exception = validate_offset_and_remaining(tvb, offset, rem_len);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));
320}

322/*
* The same as validate_offset except this accepts negative offsets, meaning
* relative to the end of (captured) length. (That it's captured, not reported,
* length is one reason to deprecate signed offsets, #20103.)
*/
327static inline int
328compute_offset(const tvbuff_t *tvb, const int offset, unsigned *offset_ptr)
329{
if (offset >= 0) {
/* Positive offset - relative to the beginning of the packet. */
if (G_LIKELY((unsigned) offset <= tvb->length)((unsigned) offset <= tvb->length)) {
	*offset_ptr = offset;
} else if ((unsigned) offset <= tvb->contained_length) {
	return BoundsError1;
} else if (tvb->flags & TVBUFF_FRAGMENT0x00000001) {
	return FragmentBoundsError4;
} else if ((unsigned) offset <= tvb->reported_length) {
	return ContainedBoundsError2;
} else {
	return ReportedBoundsError3;
}
}
else {
/* Negative offset - relative to the end of the packet. */
/* Prevent UB on 2's complement platforms. All tested compilers
 * (gcc, clang, MSVC) compile this to a single instruction on
 * x86, ARM, RISC-V, S390x, SPARC, etc. at -O1 and higher
 * according to godbolt.org. */
unsigned abs_offset = ((unsigned)-(offset + 1)) + 1;
if (G_LIKELY(abs_offset <= tvb->length)(abs_offset <= tvb->length)) {
	*offset_ptr = tvb->length - abs_offset;
} else if (abs_offset <= tvb->contained_length) {
	return BoundsError1;
} else if (tvb->flags & TVBUFF_FRAGMENT0x00000001) {
	return FragmentBoundsError4;
} else if (abs_offset <= tvb->reported_length) {
	return ContainedBoundsError2;
} else {
	return ReportedBoundsError3;
}
}

return 0;
365}

367/* Computes the absolute offset and length based on a possibly-negative offset
* and a length that is possible -1 (which means "to the end of the data").
* Returns integer indicating whether the offset is in bounds (0) or
* not (exception number). The integer ptrs are modified with the new offset,
* captured (available) length, and contained length (amount that's present
* in the parent tvbuff based on its reported length).
* No exception is thrown; on success, we return 0, otherwise we return an
* exception for the caller to throw if appropriate.
*
* XXX - we return success (0), if the offset is positive and right
* after the end of the tvbuff (i.e., equal to the length).  We do this
* so that a dissector constructing a subset tvbuff for the next protocol
* will get a zero-length tvbuff, not an exception, if there's no data
* left for the next protocol - we want the next protocol to be the one
* that gets an exception, so the error is reported as an error in that
* protocol rather than the containing protocol.  */
383static inline int
384check_offset_length_no_exception(const tvbuff_t *tvb,
		 const int offset, int const length_val,
		 unsigned *offset_ptr, unsigned *length_ptr)
387{
unsigned end_offset;
int   exception;

DISSECTOR_ASSERT(offset_ptr)((void) ((offset_ptr) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 391, "offset_ptr"
))));
DISSECTOR_ASSERT(length_ptr)((void) ((length_ptr) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 392, "length_ptr"
))));

/* Compute the offset */
exception = compute_offset(tvb, offset, offset_ptr);
if (exception)
return exception;

if (length_val < -1) {
/* XXX - ReportedBoundsError? */
return BoundsError1;
}

/* Compute the length */
if (length_val == -1)
*length_ptr = tvb->length - *offset_ptr;
else
*length_ptr = length_val;

/*
* Compute the offset of the first byte past the length.
*/
end_offset = *offset_ptr + *length_ptr;

/*
* Check for an overflow
*/
if (end_offset < *offset_ptr)
return BoundsError1;

return validate_offset(tvb, end_offset);
422}

424/* Checks (+/-) offset and length and throws an exception if
* either is out of bounds. Sets integer ptrs to the new offset
* and length. */
427static inline void
428check_offset_length(const tvbuff_t *tvb,
    const int offset, int const length_val,
    unsigned *offset_ptr, unsigned *length_ptr)
431{
int exception;

exception = check_offset_length_no_exception(tvb, offset, length_val, offset_ptr, length_ptr);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));
437}

439/* Internal function so that other translation units can use
* check_offset_length. */
441void
442tvb_check_offset_length(const tvbuff_t *tvb,
	const int offset, int const length_val,
	unsigned *offset_ptr, unsigned *length_ptr)
445{
check_offset_length(tvb, offset, length_val, offset_ptr, length_ptr);
447}

449static const unsigned char left_aligned_bitmask[] = {
0xff,
0x80,
0xc0,
0xe0,
0xf0,
0xf8,
0xfc,
0xfe
458};

460/* tvb_new_octet_aligned used to support -1 no_of_bits as meaning "to the
* end of the buffer." Nothing every used it. It could be supported with
* a _remaining() function if necessary. Note that the previous implementation
* didn't properly keep the extra reported length if the reported length
* was greater than the captured length.
*/

467tvbuff_t *
468tvb_new_octet_aligned(tvbuff_t *tvb, uint32_t bit_offset, uint32_t no_of_bits)
469{
tvbuff_t     *sub_tvb = NULL((void*)0);
uint32_t      byte_offset;
uint32_t      datalen, i;
uint8_t       left, right, remaining_bits, *buf;
const uint8_t *data;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 476, "tvb && tvb->initialized"
))));
4
←
Assuming 'tvb' is non-null→
5
←
Assuming field 'initialized' is true→
6
←
'?' condition is true→

byte_offset = bit_offset >> 3;
left = bit_offset % 8; /* for left-shifting */
right = 8 - left; /* for right-shifting */

datalen = no_of_bits >> 3;
remaining_bits = no_of_bits % 8;
if (remaining_bits) {
7
←
Assuming 'remaining_bits' is 0→
datalen++;
}

/* already aligned -> shortcut */
if (((left == 0) && (remaining_bits == 0)) || datalen == 0) {
8
←
Assuming 'left' is not equal to 0→
9
←
Assuming 'datalen' is not equal to 0→
10
←
Taking false branch→
return tvb_new_subset_length_caplen(tvb, byte_offset, datalen, datalen);
}

/* If at least one trailing byte is available, we must use the content
* of that byte for the last shift (i.e. tvb_get_ptr() must use datalen + 1).
* If no extra byte is available, the last shifted byte requires
* special treatment.
*/
if (_tvb_captured_length_remaining(tvb, byte_offset) > datalen) {
11
←
Assuming the condition is true→
12
←
Taking true branch→
data = ensure_contiguous_unsigned(tvb, byte_offset, datalen + 1); /* tvb_get_ptr */

/* Do this allocation AFTER tvb_get_ptr() (which could throw an exception) */
buf = (uint8_t *)g_malloc(datalen);
13
←
Memory is allocated→

/* shift tvb data bit_offset bits to the left */
for (i = 0; i13.1
'i' is < 'datalen'
 < datalen; i++)
14
←
Loop condition is true.  Entering loop body→
16
←
Assuming 'i' is >= 'datalen'→
17
←
Loop condition is false. Execution continues on line 518→
	buf[i] = (data[i] << left) | (data[i+1] >> right);
15
←
Assuming right operand of bit shift is non-negative but less than 32→
} else {
data = ensure_contiguous_unsigned(tvb, byte_offset, datalen); /* tvb_get_ptr() */

/* Do this allocation AFTER tvb_get_ptr() (which could throw an exception) */
buf = (uint8_t *)g_malloc(datalen);

/* shift tvb data bit_offset bits to the left */
for (i = 0; i < (datalen-1); i++)
	buf[i] = (data[i] << left) | (data[i+1] >> right);
buf[datalen-1] = data[datalen-1] << left; /* set last octet */
}
buf[datalen-1] &= left_aligned_bitmask[remaining_bits];

sub_tvb = tvb_new_child_real_data(tvb, buf, datalen, datalen);
18
←
Potential leak of memory pointed to by 'buf'
tvb_set_free_cb(sub_tvb, g_free);

return sub_tvb;
524}

526tvbuff_t *
527tvb_new_octet_right_aligned(tvbuff_t *tvb, uint32_t bit_offset, uint32_t no_of_bits)
528{
tvbuff_t     *sub_tvb = NULL((void*)0);
uint32_t      byte_offset;
unsigned      src_len, dst_len, i;
uint8_t       left, right, remaining_bits, *buf;
const uint8_t *data;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 535, "tvb && tvb->initialized"
))));

byte_offset = bit_offset / 8;
/* right shift to put bits in place and discard least significant bits */
right = bit_offset % 8;
/* left shift to get most significant bits from next octet */
left = 8 - right;

dst_len = no_of_bits / 8;
remaining_bits = no_of_bits % 8;
if (remaining_bits) {
dst_len++;
}

/* already aligned -> shortcut */
if (((right == 0) && (remaining_bits == 0)) || dst_len == 0) {
return tvb_new_subset_length_caplen(tvb, byte_offset, dst_len, dst_len);
}

if (_tvb_captured_length_remaining(tvb, byte_offset) > dst_len) {
/* last octet will get data from trailing octet */
src_len = dst_len + 1;
} else {
/* last octet will be zero padded */
src_len = dst_len;
}

data = ensure_contiguous_unsigned(tvb, byte_offset, src_len); /* tvb_get_ptr */

/* Do this allocation AFTER tvb_get_ptr() (which could throw an exception) */
buf = (uint8_t *)g_malloc(dst_len);

for (i = 0; i < (dst_len - 1); i++)
buf[i] = (data[i] >> right) | (data[i+1] << left);

/* Special handling for last octet */
buf[i] = (data[i] >> right);
/* Shift most significant bits from trailing octet if available */
if (src_len > dst_len)
buf[i] |= (data[i+1] << left);
/* Preserve only remaining bits in last octet if not multiple of 8 */
if (remaining_bits)
buf[i] &= ((1 << remaining_bits) - 1);

sub_tvb = tvb_new_child_real_data(tvb, buf, dst_len, dst_len);
tvb_set_free_cb(sub_tvb, g_free);

return sub_tvb;
583}

585static tvbuff_t *
586tvb_generic_clone_offset_len(tvbuff_t *tvb, unsigned offset, unsigned len)
587{
tvbuff_t *cloned_tvb;
uint8_t *data;

DISSECTOR_ASSERT(tvb_bytes_exist(tvb, offset, len))((void) ((tvb_bytes_exist(tvb, offset, len)) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 591, "tvb_bytes_exist(tvb, offset, len)"
))));

data = (uint8_t *) g_malloc(len);

tvb_memcpy(tvb, data, offset, len);

cloned_tvb = tvb_new_real_data(data, len, len);
tvb_set_free_cb(cloned_tvb, g_free);

return cloned_tvb;
601}

603tvbuff_t *
604tvb_clone_offset_len(tvbuff_t *tvb, unsigned offset, unsigned len)
605{
if (tvb->ops->tvb_clone) {
tvbuff_t *cloned_tvb;

cloned_tvb = tvb->ops->tvb_clone(tvb, offset, len);
if (cloned_tvb)
	return cloned_tvb;
}

return tvb_generic_clone_offset_len(tvb, offset, len);
615}

617tvbuff_t *
618tvb_clone(tvbuff_t *tvb)
619{
return tvb_clone_offset_len(tvb, 0, tvb->length);
621}

623inline unsigned
624tvb_captured_length(const tvbuff_t *tvb)
625{
DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 626, "tvb && tvb->initialized"
))));

return tvb->length;
629}

631/* For tvbuff internal use */
632static inline unsigned
633_tvb_captured_length_remaining(const tvbuff_t *tvb, const unsigned offset)
634{
unsigned rem_length;
int   exception;

exception = validate_offset_and_remaining(tvb, offset, &rem_length);
if (exception)
return 0;

return rem_length;
643}

645unsigned
646tvb_captured_length_remaining(const tvbuff_t *tvb, const unsigned offset)
647{
DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 648, "tvb && tvb->initialized"
))));

return _tvb_captured_length_remaining(tvb, offset);
651}

653unsigned
654tvb_ensure_captured_length_remaining(const tvbuff_t *tvb, const unsigned offset)
655{
unsigned rem_length = 0;
int   exception;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 659, "tvb && tvb->initialized"
))));

exception = validate_offset(tvb, offset);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));

rem_length = tvb->length - offset;

if (rem_length == 0) {
/*
 * This routine ensures there's at least one byte available.
 * There aren't any bytes available, so throw the appropriate
 * exception.
 */
if (offset < tvb->contained_length) {
	THROW(BoundsError)except_throw(1, (1), ((void*)0));
} else if (tvb->flags & TVBUFF_FRAGMENT0x00000001) {
	THROW(FragmentBoundsError)except_throw(1, (4), ((void*)0));
} else if (offset < tvb->reported_length) {
	THROW(ContainedBoundsError)except_throw(1, (2), ((void*)0));
} else {
	THROW(ReportedBoundsError)except_throw(1, (3), ((void*)0));
}
}
return rem_length;
684}

686/* Validates that 'length' bytes are available starting from
* offset. Does not throw an exception. */
688bool_Bool
689tvb_bytes_exist(const tvbuff_t *tvb, const unsigned offset, const int length)
690{
unsigned end_offset;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 693, "tvb && tvb->initialized"
))));

/*
* Negative lengths are not possible and indicate a bug (e.g. arithmetic
* error or an overly large value from packet data).
*/
if (length < 0)
return false0;

/*
* Compute the offset of the first byte past the length.
* Make sure it doesn't overflow.
*/
if (ckd_add(&end_offset, offset, length)__builtin_add_overflow((offset), (length), (&end_offset)))
return false0;

/*
* Check that bytes exist up to right before that offset. (As length is
* positive and there was no overflow we don't need to check offset.)
*/
if (end_offset > tvb->length)
return false0;

return true1;
717}

719/* Validates that 'length' bytes, where 'length' is a 64-bit unsigned
* integer, are available starting from offset (pos/neg). Throws an
* exception if they aren't. */
722/* coverity[ +taint_sanitize : arg-1 ] */
723/* coverity[ +taint_sanitize : arg-2 ] */
724void
725tvb_ensure_bytes_exist64(const tvbuff_t *tvb, const unsigned offset, const uint64_t length)
726{
/*
* Make sure the value fits in a signed integer; if not, assume
* that means that it's too big.
*/
if (length > INT_MAX2147483647) {
THROW(ReportedBoundsError)except_throw(1, (3), ((void*)0));
}

/* OK, now cast it and try it with tvb_ensure_bytes_exist(). */
tvb_ensure_bytes_exist(tvb, offset, (int)length);
737}

739/* Validates that 'length' bytes are available starting from
* offset (pos/neg). Throws an exception if they aren't. */
741/* coverity[ +taint_sanitize : arg-1 ] */
742/* coverity[ +taint_sanitize : arg-2 ] */
743void
744tvb_ensure_bytes_exist(const tvbuff_t *tvb, const unsigned offset, const int length)
745{
unsigned end_offset;
int exception;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 749, "tvb && tvb->initialized"
))));

/*
* -1 doesn't mean "until end of buffer", as that's pointless
* for this routine.  We must treat it as a Really Large Positive
* Number, so that we throw an exception; we throw
* ReportedBoundsError, as if it were past even the end of a
* reassembled packet, and past the end of even the data we
* didn't capture.
*
* We do the same with other negative lengths.
*/
if (length < 0) {
THROW(ReportedBoundsError)except_throw(1, (3), ((void*)0));
}

exception = validate_offset(tvb, offset);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));

/*
* Compute the offset of the first byte past the length.
*/
end_offset = offset + length;

/*
* Check for an overflow
*/
if (end_offset < offset)
THROW(BoundsError)except_throw(1, (1), ((void*)0));

if (G_LIKELY(end_offset <= tvb->length)(end_offset <= tvb->length))
return;
else if (end_offset <= tvb->contained_length)
THROW(BoundsError)except_throw(1, (1), ((void*)0));
else if (tvb->flags & TVBUFF_FRAGMENT0x00000001)
THROW(FragmentBoundsError)except_throw(1, (4), ((void*)0));
else if (end_offset <= tvb->reported_length)
THROW(ContainedBoundsError)except_throw(1, (2), ((void*)0));
else
THROW(ReportedBoundsError)except_throw(1, (3), ((void*)0));
790}

792bool_Bool
793tvb_offset_exists(const tvbuff_t *tvb, const unsigned offset)
794{
DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 795, "tvb && tvb->initialized"
))));

/* We don't care why the offset doesn't exist, and unlike some
* other functions we don't accept an offset one past the end,
* so we check ourselves... */
return offset < tvb->length;
801}

803unsigned
804tvb_reported_length(const tvbuff_t *tvb)
805{
DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 806, "tvb && tvb->initialized"
))));

return tvb->reported_length;
809}

811unsigned
812tvb_reported_length_remaining(const tvbuff_t *tvb, const unsigned offset)
813{
int   exception;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 816, "tvb && tvb->initialized"
))));

exception = validate_offset(tvb, offset);
if (exception)
return 0;

if (tvb->reported_length >= offset)
return tvb->reported_length - offset;
else
return 0;
826}

828unsigned
829tvb_ensure_reported_length_remaining(const tvbuff_t *tvb, const unsigned offset)
830{
int   exception;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 833, "tvb && tvb->initialized"
))));

exception = validate_offset(tvb, offset);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));

if (tvb->reported_length >= offset)
return tvb->reported_length - offset;
else
THROW(ReportedBoundsError)except_throw(1, (3), ((void*)0));
843}

845/* Set the reported length of a tvbuff to a given value; used for protocols
* whose headers contain an explicit length and where the calling
* dissector's payload may include padding as well as the packet for
* this protocol.
* Also adjusts the available and contained length. */
850void
851tvb_set_reported_length(tvbuff_t *tvb, const unsigned reported_length)
852{
DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 853, "tvb && tvb->initialized"
))));

if (reported_length > tvb->reported_length)
THROW(ReportedBoundsError)except_throw(1, (3), ((void*)0));

tvb->reported_length = reported_length;
if (reported_length < tvb->length)
tvb->length = reported_length;
if (reported_length < tvb->contained_length)
tvb->contained_length = reported_length;
863}

865/* Repair a tvbuff where the captured length is greater than the
* reported length; such a tvbuff makes no sense, as it's impossible
* to capture more data than is in the packet.
*/
869void
870tvb_fix_reported_length(tvbuff_t *tvb)
871{
DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 872, "tvb && tvb->initialized"
))));
DISSECTOR_ASSERT(tvb->reported_length < tvb->length)((void) ((tvb->reported_length < tvb->length) ? (void
)0 : (proto_report_dissector_bug("%s:%u: failed assertion \"%s\""
, "epan/tvbuff.c", 873, "tvb->reported_length < tvb->length"
))));

tvb->reported_length = tvb->length;
if (tvb->contained_length < tvb->length)
tvb->contained_length = tvb->length;
878}

880unsigned
881tvb_offset_from_real_beginning_counter(const tvbuff_t *tvb, const unsigned counter)
882{
if (tvb->ops->tvb_offset)
return tvb->ops->tvb_offset(tvb, counter);

DISSECTOR_ASSERT_NOT_REACHED()(proto_report_dissector_bug("%s:%u: failed assertion \"DISSECTOR_ASSERT_NOT_REACHED\""
, "epan/tvbuff.c", 886));
return 0;
888}

890unsigned
891tvb_offset_from_real_beginning(const tvbuff_t *tvb)
892{
return tvb_offset_from_real_beginning_counter(tvb, 0);
894}

896static inline const uint8_t*
897ensure_contiguous_unsigned_no_exception(tvbuff_t *tvb, const unsigned offset, const unsigned length, int *pexception)
898{
int   exception;

exception = validate_offset_length_no_exception(tvb, offset, length);
if (exception) {
if (pexception)
	*pexception = exception;
return NULL((void*)0);
}

/*
* Special case: if the caller (e.g. tvb_get_ptr) requested no data,
* then it is acceptable to have an empty tvb (!tvb->real_data).
*/
if (length == 0) {
return NULL((void*)0);
}

/*
* We know that all the data is present in the tvbuff, so
* no exceptions should be thrown.
*/
if (tvb->real_data)
return tvb->real_data + offset;

if (tvb->ops->tvb_get_ptr)
return tvb->ops->tvb_get_ptr(tvb, offset, length);

DISSECTOR_ASSERT_NOT_REACHED()(proto_report_dissector_bug("%s:%u: failed assertion \"DISSECTOR_ASSERT_NOT_REACHED\""
, "epan/tvbuff.c", 926));
return NULL((void*)0);
928}

930static inline const uint8_t*
931ensure_contiguous_unsigned(tvbuff_t *tvb, const unsigned offset, const unsigned length)
932{
int           exception = 0;
const uint8_t *p;

p = ensure_contiguous_unsigned_no_exception(tvb, offset, length, &exception);
if (p == NULL((void*)0) && length != 0) {
DISSECTOR_ASSERT(exception > 0)((void) ((exception > 0) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 938, "exception > 0"
))));
THROW(exception)except_throw(1, (exception), ((void*)0));
}
return p;
942}

944static inline const uint8_t*
945ensure_contiguous_no_exception(tvbuff_t *tvb, const int offset, const int length, int *pexception)
946{
unsigned abs_offset = 0, abs_length = 0;
int   exception;

exception = check_offset_length_no_exception(tvb, offset, length, &abs_offset, &abs_length);
if (exception) {
if (pexception)
	*pexception = exception;
return NULL((void*)0);
}

/*
* Special case: if the caller (e.g. tvb_get_ptr) requested no data,
* then it is acceptable to have an empty tvb (!tvb->real_data).
*/
if (length == 0) {
return NULL((void*)0);
}

/*
* We know that all the data is present in the tvbuff, so
* no exceptions should be thrown.
*/
if (tvb->real_data)
return tvb->real_data + abs_offset;

if (tvb->ops->tvb_get_ptr)
return tvb->ops->tvb_get_ptr(tvb, abs_offset, abs_length);

DISSECTOR_ASSERT_NOT_REACHED()(proto_report_dissector_bug("%s:%u: failed assertion \"DISSECTOR_ASSERT_NOT_REACHED\""
, "epan/tvbuff.c", 975));
return NULL((void*)0);
977}

979static inline const uint8_t*
980ensure_contiguous(tvbuff_t *tvb, const int offset, const int length)
981{
int           exception = 0;
const uint8_t *p;

p = ensure_contiguous_no_exception(tvb, offset, length, &exception);
if (p == NULL((void*)0) && length != 0) {
DISSECTOR_ASSERT(exception > 0)((void) ((exception > 0) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 987, "exception > 0"
))));
THROW(exception)except_throw(1, (exception), ((void*)0));
}
return p;
991}

993static inline const uint8_t*
994fast_ensure_contiguous(tvbuff_t *tvb, const unsigned offset, const unsigned length)
995{
unsigned end_offset;

/* Since offset is unsigned, we have to check for overflow. */
DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 999, "tvb && tvb->initialized"
))));

/* This is only called internally, never with zero. Try to satisfy
* Coverity that we don't run off the end. */
ws_assert(length != 0)do { if ((1) && !(length != 0)) ws_log_fatal_full("",
 LOG_LEVEL_ERROR, "epan/tvbuff.c", 1003, __func__, "assertion failed: %s"
, "length != 0"); } while (0);

if (!tvb->real_data) {
      return ensure_contiguous_unsigned(tvb, offset, length);
}

/* XXX - Is this really faster now (other than the slight difference
* in behavior from only throwing the exception related to the end
* offset?) */
if (ckd_add(&end_offset, offset, length)__builtin_add_overflow((offset), (length), (&end_offset)))
THROW(BoundsError)except_throw(1, (1), ((void*)0));

if (G_LIKELY(end_offset <= tvb->length)(end_offset <= tvb->length)) {
return tvb->real_data + offset;
} else if (end_offset <= tvb->contained_length) {
THROW(BoundsError)except_throw(1, (1), ((void*)0));
} else if (tvb->flags & TVBUFF_FRAGMENT0x00000001) {
THROW(FragmentBoundsError)except_throw(1, (4), ((void*)0));
} else if (end_offset <= tvb->reported_length) {
THROW(ContainedBoundsError)except_throw(1, (2), ((void*)0));
} else {
THROW(ReportedBoundsError)except_throw(1, (3), ((void*)0));
}
/* not reached */
return NULL((void*)0);
1028}



1032/************** ACCESSORS **************/

1034void *
1035tvb_memcpy(tvbuff_t *tvb, void *target, const unsigned offset, size_t length)
1036{
DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 1037, "tvb && tvb->initialized"
))));

/*
* XXX - The length is a size_t, but the tvb length and tvb_ops
* only supports an unsigned.
*/
DISSECTOR_ASSERT(length <= UINT_MAX)((void) ((length <= (2147483647 *2U +1U)) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 1043, "length <= (2147483647 *2U +1U)"
))));
validate_offset_length(tvb, offset, (unsigned)length);

if (target && tvb->real_data) {
return memcpy(target, tvb->real_data + offset, length);
}

if (target && tvb->ops->tvb_memcpy)
return tvb->ops->tvb_memcpy(tvb, target, offset, (unsigned)length);

/*
* If the length is 0, there's nothing to do.
* (tvb->real_data could be null if it's allocated with
* a size of length.)
*/
if (length != 0) {
/*
 * XXX, fallback to slower method
 */
DISSECTOR_ASSERT_NOT_REACHED()(proto_report_dissector_bug("%s:%u: failed assertion \"DISSECTOR_ASSERT_NOT_REACHED\""
, "epan/tvbuff.c", 1062));
}
return NULL((void*)0);
1065}


1068/*
* XXX - This could replace some code that calls "tvb_ensure_bytes_exist()"
* and then allocates a buffer and copies data to it.
*
* If scope is NULL, memory is allocated with g_malloc() and user must
* explicitly free it with g_free().
* If scope is not NULL, memory is allocated with the corresponding pool
* lifetime.
*/
1077void *
1078tvb_memdup(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, size_t length)
1079{
void  *duped;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 1082, "tvb && tvb->initialized"
))));

/*
* XXX - The length is a size_t, but the tvb length and tvb_ops
* only supports an unsigned.
*/
DISSECTOR_ASSERT(length <= UINT_MAX)((void) ((length <= (2147483647 *2U +1U)) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 1088, "length <= (2147483647 *2U +1U)"
))));
validate_offset_length(tvb, offset, (unsigned)length);

if (length == 0)
return NULL((void*)0);

duped = wmem_alloc(scope, length);
return tvb_memcpy(tvb, duped, offset, length);
1096}

1098#if 0
1099/* XXX - Is a _remaining variant of this necessary? The user would still need
* to get the length from tvb_captured_length_remaining() to productively use
* the (not necessarily null terminated) byte array. See also tvb_get_ptr(),
* which is similar. */
1103void *
1104tvb_memdup_remaining(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset)
1105{
void  *duped;
unsigned length;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 1109, "tvb && tvb->initialized"
))));

validate_offset_and_remaining(tvb, offset, &length);

if (length == 0)
return NULL((void*)0);

duped = wmem_alloc(scope, length);
return tvb_memcpy(tvb, duped, offset, length);
1118}
1119#endif

1121const uint8_t*
1122tvb_get_ptr(tvbuff_t *tvb, const unsigned offset, const unsigned length)
1123{
DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 1124, "tvb && tvb->initialized"
))));
return ensure_contiguous_unsigned(tvb, offset, length);
1126}

1128/* ---------------- */
1129uint8_t
1130tvb_get_uint8(tvbuff_t *tvb, const unsigned offset)
1131{
const uint8_t *ptr;

ptr = fast_ensure_contiguous(tvb, offset, 1);
return *ptr;
1136}

1138int8_t
1139tvb_get_int8(tvbuff_t *tvb, const unsigned offset)
1140{
const uint8_t *ptr;

ptr = fast_ensure_contiguous(tvb, offset, 1);
return *ptr;
1145}

1147uint16_t
1148tvb_get_ntohs(tvbuff_t *tvb, const unsigned offset)
1149{
const uint8_t *ptr;

ptr = fast_ensure_contiguous(tvb, offset, 2);
return pntohu16(ptr);
1154}

1156int16_t
1157tvb_get_ntohis(tvbuff_t *tvb, const unsigned offset)
1158{
const uint8_t *ptr;

ptr = fast_ensure_contiguous(tvb, offset, 2);
return pntohu16(ptr);
1163}

1165uint32_t
1166tvb_get_ntoh24(tvbuff_t *tvb, const unsigned offset)
1167{
const uint8_t *ptr;

ptr = fast_ensure_contiguous(tvb, offset, 3);
return pntohu24(ptr);
1172}

1174int32_t
1175tvb_get_ntohi24(tvbuff_t *tvb, const unsigned offset)
1176{
uint32_t ret;

ret = ws_sign_ext32(tvb_get_ntoh24(tvb, offset), 24);

return (int32_t)ret;
1182}

1184uint32_t
1185tvb_get_ntohl(tvbuff_t *tvb, const unsigned offset)
1186{
const uint8_t *ptr;

ptr = fast_ensure_contiguous(tvb, offset, 4);
return pntohu32(ptr);
1191}

1193int32_t
1194tvb_get_ntohil(tvbuff_t *tvb, const unsigned offset)
1195{
const uint8_t *ptr;

ptr = fast_ensure_contiguous(tvb, offset, 4);
return pntohu32(ptr);
1200}

1202uint64_t
1203tvb_get_ntoh40(tvbuff_t *tvb, const unsigned offset)
1204{
const uint8_t *ptr;

ptr = fast_ensure_contiguous(tvb, offset, 5);
return pntohu40(ptr);
1209}

1211int64_t
1212tvb_get_ntohi40(tvbuff_t *tvb, const unsigned offset)
1213{
uint64_t ret;

ret = ws_sign_ext64(tvb_get_ntoh40(tvb, offset), 40);

return (int64_t)ret;
1219}

1221uint64_t
1222tvb_get_ntoh48(tvbuff_t *tvb, const unsigned offset)
1223{
const uint8_t *ptr;

ptr = fast_ensure_contiguous(tvb, offset, 6);
return pntohu48(ptr);
1228}

1230int64_t
1231tvb_get_ntohi48(tvbuff_t *tvb, const unsigned offset)
1232{
uint64_t ret;

ret = ws_sign_ext64(tvb_get_ntoh48(tvb, offset), 48);

return (int64_t)ret;
1238}

1240uint64_t
1241tvb_get_ntoh56(tvbuff_t *tvb, const unsigned offset)
1242{
const uint8_t *ptr;

ptr = fast_ensure_contiguous(tvb, offset, 7);
return pntohu56(ptr);
1247}

1249int64_t
1250tvb_get_ntohi56(tvbuff_t *tvb, const unsigned offset)
1251{
uint64_t ret;

ret = ws_sign_ext64(tvb_get_ntoh56(tvb, offset), 56);

return (int64_t)ret;
1257}

1259uint64_t
1260tvb_get_ntoh64(tvbuff_t *tvb, const unsigned offset)
1261{
const uint8_t *ptr;

ptr = fast_ensure_contiguous(tvb, offset, 8);
return pntohu64(ptr);
1266}

1268int64_t
1269tvb_get_ntohi64(tvbuff_t *tvb, const unsigned offset)
1270{
const uint8_t *ptr;

ptr = fast_ensure_contiguous(tvb, offset, 8);
return pntohu64(ptr);
1275}

1277uint16_t
1278tvb_get_uint16(tvbuff_t *tvb, const unsigned offset, const unsigned encoding) {
if (encoding & ENC_LITTLE_ENDIAN0x80000000) {
return tvb_get_letohs(tvb, offset);
} else {
return tvb_get_ntohs(tvb, offset);
}
1284}

1286int16_t
1287tvb_get_int16(tvbuff_t *tvb, const unsigned offset, const unsigned encoding) {
if (encoding & ENC_LITTLE_ENDIAN0x80000000) {
return tvb_get_letohis(tvb, offset);
} else {
return tvb_get_ntohis(tvb, offset);
}
1293}

1295uint32_t
1296tvb_get_uint24(tvbuff_t *tvb, const unsigned offset, const unsigned encoding) {
if (encoding & ENC_LITTLE_ENDIAN0x80000000) {
return tvb_get_letoh24(tvb, offset);
} else {
return tvb_get_ntoh24(tvb, offset);
}
1302}

1304int32_t
1305tvb_get_int24(tvbuff_t *tvb, const unsigned offset, const unsigned encoding) {
if (encoding & ENC_LITTLE_ENDIAN0x80000000) {
return tvb_get_letohi24(tvb, offset);
} else {
return tvb_get_ntohi24(tvb, offset);
}
1311}

1313uint32_t
1314tvb_get_uint32(tvbuff_t *tvb, const unsigned offset, const unsigned encoding) {
if (encoding & ENC_LITTLE_ENDIAN0x80000000) {
return tvb_get_letohl(tvb, offset);
} else {
return tvb_get_ntohl(tvb, offset);
}
1320}

1322int32_t
1323tvb_get_int32(tvbuff_t *tvb, const unsigned offset, const unsigned encoding) {
if (encoding & ENC_LITTLE_ENDIAN0x80000000) {
return tvb_get_letohil(tvb, offset);
} else {
return tvb_get_ntohil(tvb, offset);
}
1329}

1331uint64_t
1332tvb_get_uint40(tvbuff_t *tvb, const unsigned offset, const unsigned encoding) {
if (encoding & ENC_LITTLE_ENDIAN0x80000000) {
return tvb_get_letoh40(tvb, offset);
} else {
return tvb_get_ntoh40(tvb, offset);
}
1338}

1340int64_t
1341tvb_get_int40(tvbuff_t *tvb, const unsigned offset, const unsigned encoding) {
if (encoding & ENC_LITTLE_ENDIAN0x80000000) {
return tvb_get_letohi40(tvb, offset);
} else {
return tvb_get_ntohi40(tvb, offset);
}
1347}

1349uint64_t
1350tvb_get_uint48(tvbuff_t *tvb, const unsigned offset, const unsigned encoding) {
if (encoding & ENC_LITTLE_ENDIAN0x80000000) {
return tvb_get_letoh48(tvb, offset);
} else {
return tvb_get_ntoh48(tvb, offset);
}
1356}

1358int64_t
1359tvb_get_int48(tvbuff_t *tvb, const unsigned offset, const unsigned encoding) {
if (encoding & ENC_LITTLE_ENDIAN0x80000000) {
return tvb_get_letohi48(tvb, offset);
} else {
return tvb_get_ntohi48(tvb, offset);
}
1365}

1367uint64_t
1368tvb_get_uint56(tvbuff_t *tvb, const unsigned offset, const unsigned encoding) {
if (encoding & ENC_LITTLE_ENDIAN0x80000000) {
return tvb_get_letoh56(tvb, offset);
} else {
return tvb_get_ntoh56(tvb, offset);
}
1374}

1376int64_t
1377tvb_get_int56(tvbuff_t *tvb, const unsigned offset, const unsigned encoding) {
if (encoding & ENC_LITTLE_ENDIAN0x80000000) {
return tvb_get_letohi56(tvb, offset);
} else {
return tvb_get_ntohi56(tvb, offset);
}
1383}

1385uint64_t
1386tvb_get_uint64(tvbuff_t *tvb, const unsigned offset, const unsigned encoding) {
if (encoding & ENC_LITTLE_ENDIAN0x80000000) {
return tvb_get_letoh64(tvb, offset);
} else {
return tvb_get_ntoh64(tvb, offset);
}
1392}

1394uint64_t
1395tvb_get_uint64_with_length(tvbuff_t *tvb, const unsigned offset, unsigned length, const unsigned encoding)
1396{
uint64_t value;

switch (length) {

case 1:
value = tvb_get_uint8(tvb, offset);
break;

case 2:
value = (encoding & ENC_LITTLE_ENDIAN0x80000000) ? tvb_get_letohs(tvb, offset)
				       : tvb_get_ntohs(tvb, offset);
break;

case 3:
value = (encoding & ENC_LITTLE_ENDIAN0x80000000) ? tvb_get_letoh24(tvb, offset)
				       : tvb_get_ntoh24(tvb, offset);
break;

case 4:
value = (encoding & ENC_LITTLE_ENDIAN0x80000000) ? tvb_get_letohl(tvb, offset)
				       : tvb_get_ntohl(tvb, offset);
break;

case 5:
value = (encoding & ENC_LITTLE_ENDIAN0x80000000) ? tvb_get_letoh40(tvb, offset)
				       : tvb_get_ntoh40(tvb, offset);
break;

case 6:
value = (encoding & ENC_LITTLE_ENDIAN0x80000000) ? tvb_get_letoh48(tvb, offset)
				       : tvb_get_ntoh48(tvb, offset);
break;

case 7:
value = (encoding & ENC_LITTLE_ENDIAN0x80000000) ? tvb_get_letoh56(tvb, offset)
				       : tvb_get_ntoh56(tvb, offset);
break;

case 8:
value = (encoding & ENC_LITTLE_ENDIAN0x80000000) ? tvb_get_letoh64(tvb, offset)
				       : tvb_get_ntoh64(tvb, offset);
break;

default:
if (length < 1) {
	value = 0;
} else {
	value = (encoding & ENC_LITTLE_ENDIAN0x80000000) ? tvb_get_letoh64(tvb, offset)
					       : tvb_get_ntoh64(tvb, offset);
}
break;
}
return value;
1450}

1452int64_t
1453tvb_get_int64(tvbuff_t *tvb, const unsigned offset, const unsigned encoding) {
if (encoding & ENC_LITTLE_ENDIAN0x80000000) {
return tvb_get_letohi64(tvb, offset);
} else {
return tvb_get_ntohi64(tvb, offset);
}
1459}

1461float
1462tvb_get_ieee_float(tvbuff_t *tvb, const unsigned offset, const unsigned encoding) {
if (encoding & ENC_LITTLE_ENDIAN0x80000000) {
return tvb_get_letohieee_float(tvb, offset);
} else {
return tvb_get_ntohieee_float(tvb, offset);
}
1468}

1470double
1471tvb_get_ieee_double(tvbuff_t *tvb, const unsigned offset, const unsigned encoding) {
if (encoding & ENC_LITTLE_ENDIAN0x80000000) {
return tvb_get_letohieee_double(tvb, offset);
} else {
return tvb_get_ntohieee_double(tvb, offset);
}
1477}

1479/*
* Stuff for IEEE float handling on platforms that don't have IEEE
* format as the native floating-point format.
*
* For now, we treat only the VAX as such a platform.
*
* XXX - other non-IEEE boxes that can run UN*X include some Crays,
* and possibly other machines.  However, I don't know whether there
* are any other machines that could run Wireshark and that don't use
* IEEE format.  As far as I know, all of the main current and past
* commercial microprocessor families on which OSes that support
* Wireshark can run use IEEE format (x86, ARM, 68k, SPARC, MIPS,
* PA-RISC, Alpha, IA-64, and so on), and it appears that the official
* Linux port to System/390 and zArchitecture uses IEEE format floating-
* point rather than IBM hex floating-point (not a huge surprise), so
* I'm not sure that leaves any 32-bit or larger UN*X or Windows boxes,
* other than VAXes, that don't use IEEE format.  If you're not running
* UN*X or Windows, the floating-point format is probably going to be
* the least of your problems in a port.
*/

1500#if defined(vax)

1502#include <math.h>

1504/*
* Single-precision.
*/
1507#define IEEE_SP_NUMBER_WIDTH	32	/* bits in number */
1508#define IEEE_SP_EXP_WIDTH	8	/* bits in exponent */
1509#define IEEE_SP_MANTISSA_WIDTH	23	/* IEEE_SP_NUMBER_WIDTH - 1 - IEEE_SP_EXP_WIDTH */

1511#define IEEE_SP_SIGN_MASK	0x80000000
1512#define IEEE_SP_EXPONENT_MASK	0x7F800000
1513#define IEEE_SP_MANTISSA_MASK	0x007FFFFF
1514#define IEEE_SP_INFINITY	IEEE_SP_EXPONENT_MASK

1516#define IEEE_SP_IMPLIED_BIT (1 << IEEE_SP_MANTISSA_WIDTH)
1517#define IEEE_SP_INFINITE ((1 << IEEE_SP_EXP_WIDTH) - 1)
1518#define IEEE_SP_BIAS ((1 << (IEEE_SP_EXP_WIDTH - 1)) - 1)

1520static int
1521ieee_float_is_zero(const uint32_t w)
1522{
return ((w & ~IEEE_SP_SIGN_MASK) == 0);
1524}

1526static float
1527get_ieee_float(const uint32_t w)
1528{
long sign;
long exponent;
long mantissa;

sign = w & IEEE_SP_SIGN_MASK;
exponent = w & IEEE_SP_EXPONENT_MASK;
mantissa = w & IEEE_SP_MANTISSA_MASK;

if (ieee_float_is_zero(w)) {
/* number is zero, unnormalized, or not-a-number */
return 0.0;
}
1541#if 0
/*
* XXX - how to handle this?
*/
if (IEEE_SP_INFINITY == exponent) {
/*
 * number is positive or negative infinity, or a special value
 */
return (sign? MINUS_INFINITY: PLUS_INFINITY);
}
1551#endif

exponent = ((exponent >> IEEE_SP_MANTISSA_WIDTH) - IEEE_SP_BIAS) -
IEEE_SP_MANTISSA_WIDTH;
mantissa |= IEEE_SP_IMPLIED_BIT;

if (sign)
return -mantissa * pow(2, exponent);
else
return mantissa * pow(2, exponent);
1561}

1563/*
* Double-precision.
* We assume that if you don't have IEEE floating-point, you have a
* compiler that understands 64-bit integral quantities.
*/
1568#define IEEE_DP_NUMBER_WIDTH	64	/* bits in number */
1569#define IEEE_DP_EXP_WIDTH	11	/* bits in exponent */
1570#define IEEE_DP_MANTISSA_WIDTH	52	/* IEEE_DP_NUMBER_WIDTH - 1 - IEEE_DP_EXP_WIDTH */

1572#define IEEE_DP_SIGN_MASK	INT64_C(0x8000000000000000)0x8000000000000000L
1573#define IEEE_DP_EXPONENT_MASK	INT64_C(0x7FF0000000000000)0x7FF0000000000000L
1574#define IEEE_DP_MANTISSA_MASK	INT64_C(0x000FFFFFFFFFFFFF)0x000FFFFFFFFFFFFFL
1575#define IEEE_DP_INFINITY	IEEE_DP_EXPONENT_MASK

1577#define IEEE_DP_IMPLIED_BIT (INT64_C(1)1L << IEEE_DP_MANTISSA_WIDTH)
1578#define IEEE_DP_INFINITE ((1 << IEEE_DP_EXP_WIDTH) - 1)
1579#define IEEE_DP_BIAS ((1 << (IEEE_DP_EXP_WIDTH - 1)) - 1)

1581static int
1582ieee_double_is_zero(const uint64_t w)
1583{
return ((w & ~IEEE_SP_SIGN_MASK) == 0);
1585}

1587static double
1588get_ieee_double(const uint64_t w)
1589{
int64_t sign;
int64_t exponent;
int64_t mantissa;

sign = w & IEEE_DP_SIGN_MASK;
exponent = w & IEEE_DP_EXPONENT_MASK;
mantissa = w & IEEE_DP_MANTISSA_MASK;

if (ieee_double_is_zero(w)) {
/* number is zero, unnormalized, or not-a-number */
return 0.0;
}
1602#if 0
/*
* XXX - how to handle this?
*/
if (IEEE_DP_INFINITY == exponent) {
/*
 * number is positive or negative infinity, or a special value
 */
return (sign? MINUS_INFINITY: PLUS_INFINITY);
}
1612#endif

exponent = ((exponent >> IEEE_DP_MANTISSA_WIDTH) - IEEE_DP_BIAS) -
IEEE_DP_MANTISSA_WIDTH;
mantissa |= IEEE_DP_IMPLIED_BIT;

if (sign)
return -mantissa * pow(2, exponent);
else
return mantissa * pow(2, exponent);
1622}
1623#endif

1625/*
* Fetches an IEEE single-precision floating-point number, in
* big-endian form, and returns a "float".
*
* XXX - should this be "double", in case there are IEEE single-
* precision numbers that won't fit in some platform's native
* "float" format?
*/
1633float
1634tvb_get_ntohieee_float(tvbuff_t *tvb, const unsigned offset)
1635{
1636#if defined(vax)
return get_ieee_float(tvb_get_ntohl(tvb, offset));
1638#else
union {
float	f;
uint32_t w;
} ieee_fp_union;

ieee_fp_union.w = tvb_get_ntohl(tvb, offset);
return ieee_fp_union.f;
1646#endif
1647}

1649/*
* Fetches an IEEE double-precision floating-point number, in
* big-endian form, and returns a "double".
*/
1653double
1654tvb_get_ntohieee_double(tvbuff_t *tvb, const unsigned offset)
1655{
1656#if defined(vax)
union {
uint32_t w[2];
uint64_t dw;
} ieee_fp_union;
1661#else
union {
double d;
uint32_t w[2];
} ieee_fp_union;
1666#endif

1668#if G_BYTE_ORDER1234 == G_BIG_ENDIAN4321
ieee_fp_union.w[0] = tvb_get_ntohl(tvb, offset);
ieee_fp_union.w[1] = tvb_get_ntohl(tvb, offset+4);
1671#else
ieee_fp_union.w[0] = tvb_get_ntohl(tvb, offset+4);
ieee_fp_union.w[1] = tvb_get_ntohl(tvb, offset);
1674#endif
1675#if defined(vax)
return get_ieee_double(ieee_fp_union.dw);
1677#else
return ieee_fp_union.d;
1679#endif
1680}

1682uint16_t
1683tvb_get_letohs(tvbuff_t *tvb, const unsigned offset)
1684{
const uint8_t *ptr;

ptr = fast_ensure_contiguous(tvb, offset, 2);
return pletohu16(ptr);
1689}

1691int16_t
1692tvb_get_letohis(tvbuff_t *tvb, const unsigned offset)
1693{
const uint8_t *ptr;

ptr = fast_ensure_contiguous(tvb, offset, 2);
return pletohu16(ptr);
1698}

1700uint32_t
1701tvb_get_letoh24(tvbuff_t *tvb, const unsigned offset)
1702{
const uint8_t *ptr;

ptr = fast_ensure_contiguous(tvb, offset, 3);
return pletohu24(ptr);
1707}

1709int32_t
1710tvb_get_letohi24(tvbuff_t *tvb, const unsigned offset)
1711{
uint32_t ret;

ret = ws_sign_ext32(tvb_get_letoh24(tvb, offset), 24);

return (int32_t)ret;
1717}

1719uint32_t
1720tvb_get_letohl(tvbuff_t *tvb, const unsigned offset)
1721{
const uint8_t *ptr;

ptr = fast_ensure_contiguous(tvb, offset, 4);
return pletohu32(ptr);
1726}

1728int32_t
1729tvb_get_letohil(tvbuff_t *tvb, const unsigned offset)
1730{
const uint8_t *ptr;

ptr = fast_ensure_contiguous(tvb, offset, 4);
return pletohu32(ptr);
1735}

1737uint64_t
1738tvb_get_letoh40(tvbuff_t *tvb, const unsigned offset)
1739{
const uint8_t *ptr;

ptr = fast_ensure_contiguous(tvb, offset, 5);
return pletohu40(ptr);
1744}

1746int64_t
1747tvb_get_letohi40(tvbuff_t *tvb, const unsigned offset)
1748{
uint64_t ret;

ret = ws_sign_ext64(tvb_get_letoh40(tvb, offset), 40);

return (int64_t)ret;
1754}

1756uint64_t
1757tvb_get_letoh48(tvbuff_t *tvb, const unsigned offset)
1758{
const uint8_t *ptr;

ptr = fast_ensure_contiguous(tvb, offset, 6);
return pletohu48(ptr);
1763}

1765int64_t
1766tvb_get_letohi48(tvbuff_t *tvb, const unsigned offset)
1767{
uint64_t ret;

ret = ws_sign_ext64(tvb_get_letoh48(tvb, offset), 48);

return (int64_t)ret;
1773}

1775uint64_t
1776tvb_get_letoh56(tvbuff_t *tvb, const unsigned offset)
1777{
const uint8_t *ptr;

ptr = fast_ensure_contiguous(tvb, offset, 7);
return pletohu56(ptr);
1782}

1784int64_t
1785tvb_get_letohi56(tvbuff_t *tvb, const unsigned offset)
1786{
uint64_t ret;

ret = ws_sign_ext64(tvb_get_letoh56(tvb, offset), 56);

return (int64_t)ret;
1792}

1794uint64_t
1795tvb_get_letoh64(tvbuff_t *tvb, const unsigned offset)
1796{
const uint8_t *ptr;

ptr = fast_ensure_contiguous(tvb, offset, 8);
return pletohu64(ptr);
1801}

1803int64_t
1804tvb_get_letohi64(tvbuff_t *tvb, const unsigned offset)
1805{
const uint8_t *ptr;

ptr = fast_ensure_contiguous(tvb, offset, 8);
return pletohu64(ptr);
1810}

1812/*
* Fetches an IEEE single-precision floating-point number, in
* little-endian form, and returns a "float".
*
* XXX - should this be "double", in case there are IEEE single-
* precision numbers that won't fit in some platform's native
* "float" format?
*/
1820float
1821tvb_get_letohieee_float(tvbuff_t *tvb, const unsigned offset)
1822{
1823#if defined(vax)
return get_ieee_float(tvb_get_letohl(tvb, offset));
1825#else
union {
float f;
uint32_t w;
} ieee_fp_union;

ieee_fp_union.w = tvb_get_letohl(tvb, offset);
return ieee_fp_union.f;
1833#endif
1834}

1836/*
* Fetches an IEEE double-precision floating-point number, in
* little-endian form, and returns a "double".
*/
1840double
1841tvb_get_letohieee_double(tvbuff_t *tvb, const unsigned offset)
1842{
1843#if defined(vax)
union {
uint32_t w[2];
uint64_t dw;
} ieee_fp_union;
1848#else
union {
double d;
uint32_t w[2];
} ieee_fp_union;
1853#endif

1855#if G_BYTE_ORDER1234 == G_BIG_ENDIAN4321
ieee_fp_union.w[0] = tvb_get_letohl(tvb, offset+4);
ieee_fp_union.w[1] = tvb_get_letohl(tvb, offset);
1858#else
ieee_fp_union.w[0] = tvb_get_letohl(tvb, offset);
ieee_fp_union.w[1] = tvb_get_letohl(tvb, offset+4);
1861#endif
1862#if defined(vax)
return get_ieee_double(ieee_fp_union.dw);
1864#else
return ieee_fp_union.d;
1866#endif
1867}

1869/* This function is a slight misnomer. It accepts all encodings that are
* ASCII "enough", which means encodings that are the same as US-ASCII
* for textual representations of dates and hex bytes; i.e., the same
* for the hex digits and Z (in practice, all alphanumerics), and the
* four separators ':' '-' '.' and ' '
* That means that any encoding that keeps the ISO/IEC 646 invariant
* characters the same (including the T.61 8 bit encoding and multibyte
* encodings like EUC-KR and GB18030) are OK, even if they replace characters
* like '$' '#' and '\' with national variants, but not encodings like UTF-16
* that include extra null bytes.
* For our current purposes, the unpacked GSM 7-bit default alphabet (but not
* all National Language Shift Tables) also satisfies this requirement, but
* note that it does *not* keep all ISO/IEC 646 invariant characters the same.
* If this internal function gets used for additional purposes than currently,
* the set of encodings that it accepts could change.
* */
1885static inline void
1886validate_single_byte_ascii_encoding(const unsigned encoding)
1887{
const unsigned enc = encoding & ~ENC_CHARENCODING_MASK0x0000FFFE;

switch (enc) {
   case ENC_UTF_160x00000004:
   case ENC_UCS_20x00000006:
   case ENC_UCS_40x00000008:
   case ENC_3GPP_TS_23_038_7BITS_PACKED0x0000002C:
   case ENC_ASCII_7BITS0x00000034:
   case ENC_EBCDIC0x0000002E:
   case ENC_EBCDIC_CP0370x00000038:
   case ENC_EBCDIC_CP5000x00000060:
   case ENC_BCD_DIGITS_0_90x00000044:
   case ENC_KEYPAD_ABC_TBCD0x00000046:
   case ENC_KEYPAD_BC_TBCD0x00000048:
   case ENC_ETSI_TS_102_221_ANNEX_A0x0000004E:
   case ENC_APN_STR0x00000054:
   case ENC_DECT_STANDARD_4BITS_TBCD0x00000058:
   REPORT_DISSECTOR_BUG("Invalid string encoding type passed to tvb_get_string_XXX")proto_report_dissector_bug("Invalid string encoding type passed to tvb_get_string_XXX"
);
   break;
   default:
   break;
}
/* make sure something valid was set */
if (enc == 0)
   REPORT_DISSECTOR_BUG("No string encoding type passed to tvb_get_string_XXX")proto_report_dissector_bug("No string encoding type passed to tvb_get_string_XXX"
);
1913}

1915GByteArray*
1916tvb_get_string_bytes(tvbuff_t *tvb, const unsigned offset, const unsigned length,
     const unsigned encoding, GByteArray *bytes, unsigned *endoff)
1918{
char *ptr;
const char *begin;
const char *end    = NULL((void*)0);
GByteArray  *retval = NULL((void*)0);

validate_single_byte_ascii_encoding(encoding);

ptr = (char*) tvb_get_raw_string(NULL((void*)0), tvb, offset, length);
begin = ptr;

if (endoff) *endoff = offset;

while (*begin == ' ') begin++;

if (*begin && bytes) {
if (hex_str_to_bytes_encoding(begin, bytes, &end, encoding, false0)) {
	if (bytes->len > 0) {
		if (endoff) *endoff = offset + (unsigned)(end - ptr);
		retval = bytes;
	}
}
}

wmem_free(NULL((void*)0), ptr);

return retval;
1945}

1947static bool_Bool
1948parse_month_name(const char *name, int *tm_mon)
1949{
static const char months[][4] = { "Jan", "Feb", "Mar", "Apr", "May",
"Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
for (int i = 0; i < 12; i++) {
if (memcmp(months[i], name, 4) == 0) {
	*tm_mon = i;
	return true1;
}
}
return false0;
1959}

1961bool_Bool
1962tvb_get_string_uint64(tvbuff_t *tvb, const unsigned offset, const unsigned length,
      const unsigned encoding, uint64_t *value, unsigned *endoff)
1964{
const uint8_t *ptr;
const uint8_t *endptr;
const uint8_t **endptrptr = endoff ? &endptr : NULL((void*)0);
bool_Bool success;

validate_single_byte_ascii_encoding(encoding);

ptr = ensure_contiguous_unsigned(tvb, offset, length);

if (ptr == NULL((void*)0)) {
*value = 0;
if (endoff) {
	*endoff = offset;
}
return false0;
}

switch (encoding & ENC_STRING0x07000000) {
case ENC_STR_HEX0x02000000:
success = ws_hexbuftou64(ptr, length, endptrptr, value);
break;
case ENC_STR_DEC0x04000000:
success = ws_buftou64(ptr, length, endptrptr, value);
break;
case ENC_STR_NUM0x01000000:
default:
success = ws_basebuftou64(ptr, length, endptrptr, value, 0);
}

if (endoff) {
// 0 <= endptr - ptr <= length
*endoff = offset + (uint32_t)(endptr - ptr);
}

return success;
2000}

2002bool_Bool
2003tvb_get_string_uint(tvbuff_t *tvb, const unsigned offset, const unsigned length,
    const unsigned encoding, uint32_t *value, unsigned *endoff)
2005{
const uint8_t *ptr;
const uint8_t *endptr;
const uint8_t **endptrptr = endoff ? &endptr : NULL((void*)0);
bool_Bool success;

validate_single_byte_ascii_encoding(encoding);

ptr = ensure_contiguous_unsigned(tvb, offset, length);

if (ptr == NULL((void*)0)) {
*value = 0;
if (endoff) {
	*endoff = offset;
}
return false0;
}

switch (encoding & ENC_STRING0x07000000) {
case ENC_STR_HEX0x02000000:
success = ws_hexbuftou32(ptr, length, endptrptr, value);
break;
case ENC_STR_DEC0x04000000:
success = ws_buftou32(ptr, length, endptrptr, value);
break;
case ENC_STR_NUM0x01000000:
default:
success = ws_basebuftou32(ptr, length, endptrptr, value, 0);
}

if (endoff) {
// 0 <= endptr - ptr <= length
*endoff = offset + (uint32_t)(endptr - ptr);
}

return success;
2041}

2043bool_Bool
2044tvb_get_string_uint16(tvbuff_t *tvb, const unsigned offset, const unsigned length,
    const unsigned encoding, uint16_t *value, unsigned *endoff)
2046{
const uint8_t *ptr;
const uint8_t *endptr;
const uint8_t **endptrptr = endoff ? &endptr : NULL((void*)0);
bool_Bool success;

validate_single_byte_ascii_encoding(encoding);

ptr = ensure_contiguous_unsigned(tvb, offset, length);

if (ptr == NULL((void*)0)) {
*value = 0;
if (endoff) {
	*endoff = offset;
}
return false0;
}

switch (encoding & ENC_STRING0x07000000) {
case ENC_STR_HEX0x02000000:
success = ws_hexbuftou16(ptr, length, endptrptr, value);
break;
case ENC_STR_DEC0x04000000:
success = ws_buftou16(ptr, length, endptrptr, value);
break;
case ENC_STR_NUM0x01000000:
default:
success = ws_basebuftou16(ptr, length, endptrptr, value, 0);
}

if (endoff) {
// 0 <= endptr - ptr <= length
*endoff = offset + (uint32_t)(endptr - ptr);
}

return success;
2082}

2084bool_Bool
2085tvb_get_string_uint8(tvbuff_t *tvb, const unsigned offset, const unsigned length,
    const unsigned encoding, uint8_t *value, unsigned *endoff)
2087{
const uint8_t *ptr;
const uint8_t *endptr;
const uint8_t **endptrptr = endoff ? &endptr : NULL((void*)0);
bool_Bool success;

validate_single_byte_ascii_encoding(encoding);

ptr = ensure_contiguous_unsigned(tvb, offset, length);

if (ptr == NULL((void*)0)) {
*value = 0;
if (endoff) {
	*endoff = offset;
}
return false0;
}

switch (encoding & ENC_STRING0x07000000) {
case ENC_STR_HEX0x02000000:
success = ws_hexbuftou8(ptr, length, endptrptr, value);
break;
case ENC_STR_DEC0x04000000:
success = ws_buftou8(ptr, length, endptrptr, value);
break;
case ENC_STR_NUM0x01000000:
default:
success = ws_basebuftou8(ptr, length, endptrptr, value, 0);
}

if (endoff) {
// 0 <= endptr - ptr <= length
*endoff = offset + (uint32_t)(endptr - ptr);
}

return success;
2123}

2125bool_Bool
2126tvb_get_string_int64(tvbuff_t *tvb, const unsigned offset, const unsigned length,
     const unsigned encoding, int64_t *value, unsigned *endoff)
2128{
const uint8_t *ptr;
const uint8_t *endptr;
const uint8_t **endptrptr = endoff ? &endptr : NULL((void*)0);
bool_Bool success;

validate_single_byte_ascii_encoding(encoding);

ptr = ensure_contiguous_unsigned(tvb, offset, length);

if (ptr == NULL((void*)0)) {
*value = 0;
if (endoff) {
	*endoff = offset;
}
return false0;
}

switch (encoding & ENC_STRING0x07000000) {
case ENC_STR_HEX0x02000000:
success = ws_hexbuftoi64(ptr, length, endptrptr, value);
break;
case ENC_STR_DEC0x04000000:
success = ws_buftoi64(ptr, length, endptrptr, value);
break;
case ENC_STR_NUM0x01000000:
default:
success = ws_basebuftoi64(ptr, length, endptrptr, value, 0);
}

if (endoff) {
// 0 <= endptr - ptr <= length
*endoff = offset + (uint32_t)(endptr - ptr);
}

return success;
2164}

2166bool_Bool
2167tvb_get_string_int(tvbuff_t *tvb, const unsigned offset, const unsigned length,
   const unsigned encoding, int32_t *value, unsigned *endoff)
2169{
const uint8_t *ptr;
const uint8_t *endptr;
const uint8_t **endptrptr = endoff ? &endptr : NULL((void*)0);
bool_Bool success;

validate_single_byte_ascii_encoding(encoding);

ptr = ensure_contiguous_unsigned(tvb, offset, length);

if (ptr == NULL((void*)0)) {
*value = 0;
if (endoff) {
	*endoff = offset;
}
return false0;
}

switch (encoding & ENC_STRING0x07000000) {
case ENC_STR_HEX0x02000000:
success = ws_hexbuftoi32(ptr, length, endptrptr, value);
break;
case ENC_STR_DEC0x04000000:
success = ws_buftoi32(ptr, length, endptrptr, value);
break;
case ENC_STR_NUM0x01000000:
default:
success = ws_basebuftoi32(ptr, length, endptrptr, value, 0);
}

if (endoff) {
// 0 <= endptr - ptr <= length
*endoff = offset + (uint32_t)(endptr - ptr);
}

return success;
2205}

2207bool_Bool
2208tvb_get_string_int16(tvbuff_t *tvb, const unsigned offset, const unsigned length,
    const unsigned encoding, int16_t *value, unsigned *endoff)
2210{
const uint8_t *ptr;
const uint8_t *endptr;
const uint8_t **endptrptr = endoff ? &endptr : NULL((void*)0);
bool_Bool success;

validate_single_byte_ascii_encoding(encoding);

ptr = ensure_contiguous_unsigned(tvb, offset, length);

if (ptr == NULL((void*)0)) {
*value = 0;
if (endoff) {
	*endoff = offset;
}
return false0;
}

switch (encoding & ENC_STRING0x07000000) {
case ENC_STR_HEX0x02000000:
success = ws_hexbuftoi16(ptr, length, endptrptr, value);
break;
case ENC_STR_DEC0x04000000:
success = ws_buftoi16(ptr, length, endptrptr, value);
break;
case ENC_STR_NUM0x01000000:
default:
success = ws_basebuftoi16(ptr, length, endptrptr, value, 0);
}

if (endoff) {
// 0 <= endptr - ptr <= length
*endoff = offset + (uint32_t)(endptr - ptr);
}

return success;
2246}

2248bool_Bool
2249tvb_get_string_int8(tvbuff_t *tvb, const unsigned offset, const unsigned length,
    const unsigned encoding, int8_t *value, unsigned *endoff)
2251{
const uint8_t *ptr;
const uint8_t *endptr;
const uint8_t **endptrptr = endoff ? &endptr : NULL((void*)0);
bool_Bool success;

validate_single_byte_ascii_encoding(encoding);

ptr = ensure_contiguous_unsigned(tvb, offset, length);

if (ptr == NULL((void*)0)) {
*value = 0;
if (endoff) {
	*endoff = offset;
}
return false0;
}

switch (encoding & ENC_STRING0x07000000) {
case ENC_STR_HEX0x02000000:
success = ws_hexbuftoi8(ptr, length, endptrptr, value);
break;
case ENC_STR_DEC0x04000000:
success = ws_buftoi8(ptr, length, endptrptr, value);
break;
case ENC_STR_NUM0x01000000:
default:
success = ws_basebuftoi8(ptr, length, endptrptr, value, 0);
}

if (endoff) {
// 0 <= endptr - ptr <= length
*endoff = offset + (uint32_t)(endptr - ptr);
}

return success;
2287}

2289/*
* Is the character a WSP character, as per RFC 5234?  (space or tab).
*/
2292#define IS_WSP(c)((c) == ' ' || (c) == '\t')	((c) == ' ' || (c) == '\t')

2294/* support hex-encoded time values? */
2295nstime_t*
2296tvb_get_string_time(tvbuff_t *tvb, const unsigned offset, const unsigned length,
    const unsigned encoding, nstime_t *ns, unsigned *endoff)
2298{
char *begin;
const char *ptr;
const char *end       = NULL((void*)0);
int	     num_chars = 0;
int	     utc_offset = 0;

validate_single_byte_ascii_encoding(encoding);

DISSECTOR_ASSERT(ns)((void) ((ns) ? (void)0 : (proto_report_dissector_bug("%s:%u: failed assertion \"%s\""
, "epan/tvbuff.c", 2307, "ns"))));

begin = (char*) tvb_get_raw_string(NULL((void*)0), tvb, offset, length);
ptr = begin;

while (IS_WSP(*ptr)((*ptr) == ' ' || (*ptr) == '\t'))
ptr++;

if (*ptr) {
if ((encoding & ENC_ISO_8601_DATE_TIME0x00030000) == ENC_ISO_8601_DATE_TIME0x00030000) {
	if (!(end = iso8601_to_nstime(ns, ptr, ISO8601_DATETIME))) {


		goto fail;
	}
} else if ((encoding & ENC_ISO_8601_DATE_TIME_BASIC0x00100000) == ENC_ISO_8601_DATE_TIME_BASIC0x00100000) {
	if (!(end = iso8601_to_nstime(ns, ptr, ISO8601_DATETIME_BASIC))) {


		goto fail;
	}
} else {
	struct tm    tm;

	memset(&tm, 0, sizeof(tm));
	tm.tm_isdst = -1;
	ns->secs    = 0;
	ns->nsecs   = 0;

	/* note: sscanf is known to be inconsistent across platforms with respect
	   to whether a %n is counted as a return value or not, so we have to use
	   '>=' a lot */
	if (encoding & ENC_ISO_8601_DATE0x00010000) {
		/* 2014-04-07 */
		if (sscanf(ptr, "%d-%d-%d%n",
		    &tm.tm_year,
		    &tm.tm_mon,
		    &tm.tm_mday,
		    &num_chars) >= 3)
		{
			end = ptr + num_chars;
			tm.tm_mon--;
			if (tm.tm_year > 1900) tm.tm_year -= 1900;
		} else {
			goto fail;
		}
	}
	else if (encoding & ENC_ISO_8601_TIME0x00020000) {
		/* 2014-04-07 */
		if (sscanf(ptr, "%d:%d:%d%n",
		    &tm.tm_hour,
		    &tm.tm_min,
		    &tm.tm_sec,
		    &num_chars) >= 2)
		{
			/* what should we do about day/month/year? */
			/* setting it to "now" for now */
			time_t time_now = time(NULL((void*)0));
			struct tm *tm_now = gmtime(&time_now);
			if (tm_now != NULL((void*)0)) {
				tm.tm_year = tm_now->tm_year;
				tm.tm_mon  = tm_now->tm_mon;
				tm.tm_mday = tm_now->tm_mday;
			} else {
				/* The second before the Epoch */
				tm.tm_year = 69;
				tm.tm_mon = 12;
				tm.tm_mday = 31;
			}
			end = ptr + num_chars;
		} else {
			goto fail;
		}
	}
	else if (encoding & ENC_IMF_DATE_TIME0x00040000) {
		/*
		 * Match [dow,] day month year hh:mm[:ss] with
		 * two-digit years (RFC 822) or four-digit
		 * years (RFCs 1123, 2822, 5822). Skip
		 * the day of week since it is locale
		 * dependent and does not affect the resulting
		 * date anyway.
		 */
		if (g_ascii_isalpha(ptr[0])((g_ascii_table[(guchar) (ptr[0])] & G_ASCII_ALPHA) != 0) && g_ascii_isalpha(ptr[1])((g_ascii_table[(guchar) (ptr[1])] & G_ASCII_ALPHA) != 0) && g_ascii_isalpha(ptr[2])((g_ascii_table[(guchar) (ptr[2])] & G_ASCII_ALPHA) != 0) && ptr[3] == ',')
			ptr += 4;   /* Skip day of week. */

		/*
		 * Parse the day-of-month and month
		 * name.
		 */
		char month_name[4] = { 0 };

		if (sscanf(ptr, "%d %3s%n",
		    &tm.tm_mday,
		    month_name,
		    &num_chars) < 2)
		{
			/* Not matched. */
			goto fail;
		}
		if (!parse_month_name(month_name, &tm.tm_mon)) {
			goto fail;
		}
		ptr += num_chars;
		while (IS_WSP(*ptr)((*ptr) == ' ' || (*ptr) == '\t'))
			ptr++;

		/*
		 * Scan the year.  Treat 2-digit years
		 * differently from 4-digit years.
		 */
		uint32_t year;
		const char *yearendp;

		if (!ws_strtou32(ptr, &yearendp, &year)) {
			goto fail;
		}
		if (!IS_WSP(*yearendp)((*yearendp) == ' ' || (*yearendp) == '\t')) {
			/* Not followed by WSP. */
			goto fail;
		}
		if (yearendp - ptr < 2) {
			/* 1-digit year.  Error. */
			goto fail;
		}
		if (yearendp - ptr == 2) {
			/*
			 * 2-digit year.
			 *
			 * Match RFC 2822/RFC 5322 behavior;
			 * add 2000 to years from 0 to
			 * 49 and 1900 to uears from 50
			 * to 99.
			 */
			if (year <= 49) {
				year += 2000;
			} else {
				year += 1900;
			}
		} else if (yearendp - ptr == 3) {
			/*
			 * 3-digit year.
			 *
			 * Match RFC 2822/RFC 5322 behavior;
			 * add 1900 to the year.
			 */
			year += 1900;
		}
		tm.tm_year = year - 1900;
		ptr = yearendp;
		while (IS_WSP(*ptr)((*ptr) == ' ' || (*ptr) == '\t'))
			ptr++;

		/* Parse the time. */
		if (sscanf(ptr, "%d:%d%n:%d%n",
		    &tm.tm_hour,
		    &tm.tm_min,
		    &num_chars,
		    &tm.tm_sec,
		    &num_chars) < 2)
		{
			goto fail;
		}
		ptr += num_chars;
		while (IS_WSP(*ptr)((*ptr) == ' ' || (*ptr) == '\t'))
			ptr++;

		/*
		 * Parse the time zone.
		 * Check for obs-zone values first.
		 */
		if (g_ascii_strncasecmp(ptr, "UT", 2) == 0)
		{
			ptr += 2;
		}
		else if (g_ascii_strncasecmp(ptr, "GMT", 3) == 0)
		{
			ptr += 3;
		}
		else
		{
			char sign;
			int off_hr;
			int off_min;

			if (sscanf(ptr, "%c%2d%2d%n",
			    &sign,
			    &off_hr,
			    &off_min,
			    &num_chars) < 3)
			{
				goto fail;
			}

			/*
			 * If sign is '+', there's a positive
			 * UTC offset.
			 *
			 * If sign is '-', there's a negative
			 * UTC offset.
			 *
			 * Otherwise, that's an invalid UTC
			 * offset string.
			 */
			if (sign == '+')
				utc_offset += (off_hr * 3600) + (off_min * 60);
			else if (sign == '-')
				utc_offset -= (off_hr * 3600) + (off_min * 60);
			else {
				/* Sign must be + or - */
				goto fail;
			}
			ptr += num_chars;
		}
		end = ptr;
	}
	ns->secs = mktime_utc(&tm);
	if (ns->secs == (time_t)-1 && errno(*__errno_location ()) != 0) {
		goto fail;
	}
	ns->secs += utc_offset;
}
} else {
/* Empty string */
goto fail;
}

if (endoff)
   *endoff = (unsigned)(offset + (end - begin));
wmem_free(NULL((void*)0), begin);
return ns;

2539fail:
wmem_free(NULL((void*)0), begin);
return NULL((void*)0);
2542}

2544/* Fetch an IPv4 address, in network byte order.
* We do *not* convert them to host byte order; we leave them in
* network byte order. */
2547uint32_t
2548tvb_get_ipv4(tvbuff_t *tvb, const unsigned offset)
2549{
const uint8_t *ptr;
uint32_t      addr;

ptr = fast_ensure_contiguous(tvb, offset, sizeof(uint32_t));
memcpy(&addr, ptr, sizeof addr);
return addr;
2556}

2558/* Fetch an IPv6 address. */
2559void
2560tvb_get_ipv6(tvbuff_t *tvb, const unsigned offset, ws_in6_addr *addr)
2561{
const uint8_t *ptr;

ptr = ensure_contiguous_unsigned(tvb, offset, sizeof(*addr));
memcpy(addr, ptr, sizeof *addr);
2566}

2568/*
* These routines return the length of the address in bytes on success
* and -1 if the prefix length is too long.
*/
2572int
2573tvb_get_ipv4_addr_with_prefix_len(tvbuff_t *tvb, const unsigned offset, ws_in4_addr *addr,
  uint32_t prefix_len)
2575{
uint8_t addr_len;

if (prefix_len > 32)
return -1;

addr_len = (prefix_len + 7) / 8;
*addr = 0;
tvb_memcpy(tvb, addr, offset, addr_len);
if (prefix_len % 8)
((uint8_t*)addr)[addr_len - 1] &= ((0xff00 >> (prefix_len % 8)) & 0xff);
return addr_len;
2587}

2589/*
* These routines return the length of the address in bytes on success
* and -1 if the prefix length is too long.
*/
2593int
2594tvb_get_ipv6_addr_with_prefix_len(tvbuff_t *tvb, const unsigned offset, ws_in6_addr *addr,
  uint32_t prefix_len)
2596{
uint32_t addr_len;

if (prefix_len > 128)
return -1;

addr_len = (prefix_len + 7) / 8;
memset(addr->bytes, 0, 16);
tvb_memcpy(tvb, addr->bytes, offset, addr_len);
if (prefix_len % 8) {
addr->bytes[addr_len - 1] &=
    ((0xff00 >> (prefix_len % 8)) & 0xff);
}

return addr_len;
2611}

2613/* Fetch a GUID. */
2614void
2615tvb_get_ntohguid(tvbuff_t *tvb, const unsigned offset, e_guid_t *guid)
2616{
const uint8_t *ptr = ensure_contiguous_unsigned(tvb, offset, GUID_LEN16);

guid->data1 = pntohu32(ptr + 0);
guid->data2 = pntohu16(ptr + 4);
guid->data3 = pntohu16(ptr + 6);
memcpy(guid->data4, ptr + 8, sizeof guid->data4);
2623}

2625void
2626tvb_get_letohguid(tvbuff_t *tvb, const unsigned offset, e_guid_t *guid)
2627{
const uint8_t *ptr = ensure_contiguous_unsigned(tvb, offset, GUID_LEN16);

guid->data1 = pletohu32(ptr + 0);
guid->data2 = pletohu16(ptr + 4);
guid->data3 = pletohu16(ptr + 6);
memcpy(guid->data4, ptr + 8, sizeof guid->data4);
2634}

2636void
2637tvb_get_guid(tvbuff_t *tvb, const unsigned offset, e_guid_t *guid, const unsigned encoding)
2638{
if (encoding & ENC_LITTLE_ENDIAN0x80000000) {
tvb_get_letohguid(tvb, offset, guid);
} else {
tvb_get_ntohguid(tvb, offset, guid);
}
2644}

2646static const uint8_t bit_mask8[] = {
0x00,
0x01,
0x03,
0x07,
0x0f,
0x1f,
0x3f,
0x7f,
0xff
2656};


2659/* Get a variable amount of bits
*
* Return a byte array with bit limited data.
* When encoding is ENC_BIG_ENDIAN, the data is aligned to the left.
* When encoding is ENC_LITTLE_ENDIAN, the data is aligned to the right.
*/
2665uint8_t *
2666tvb_get_bits_array(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned bit_offset,
   size_t no_of_bits, size_t *data_length, const unsigned encoding)
2668{
tvbuff_t *sub_tvb;
if (encoding & ENC_LITTLE_ENDIAN0x80000000) {
1
Assuming the condition is false→
2
←
Taking false branch→
sub_tvb = tvb_new_octet_right_aligned(tvb, bit_offset, (int32_t) no_of_bits);
} else {
sub_tvb = tvb_new_octet_aligned(tvb, bit_offset, (int32_t) no_of_bits);
3
←
Calling 'tvb_new_octet_aligned'→
}
*data_length = tvb_reported_length(sub_tvb);
return (uint8_t*)tvb_memdup(scope, sub_tvb, 0, *data_length);
2677}

2679/* Get 1 - 8 bits */
2680uint8_t
2681tvb_get_bits8(tvbuff_t *tvb, unsigned bit_offset, const unsigned no_of_bits)
2682{
DISSECTOR_ASSERT_HINT(no_of_bits <= 8, "Too many bits requested for 8-bit return type")((void) ((no_of_bits <= 8) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\" (%s)", "epan/tvbuff.c", 2683
, "no_of_bits <= 8", "Too many bits requested for 8-bit return type"
))));
return (uint8_t)_tvb_get_bits64(tvb, bit_offset, no_of_bits);
2685}

2687/* Get 1 - 16 bits */
2688uint16_t
2689tvb_get_bits16(tvbuff_t *tvb, unsigned bit_offset, const unsigned no_of_bits, const unsigned encoding)
2690{
DISSECTOR_ASSERT_HINT(no_of_bits <= 16, "Too many bits requested for 16-bit return type")((void) ((no_of_bits <= 16) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\" (%s)", "epan/tvbuff.c", 2691
, "no_of_bits <= 16", "Too many bits requested for 16-bit return type"
))));
return (uint16_t)tvb_get_bits64(tvb, bit_offset, no_of_bits, encoding);
2693}

2695/* Get 1 - 32 bits */
2696uint32_t
2697tvb_get_bits32(tvbuff_t *tvb, unsigned bit_offset, const unsigned no_of_bits, const unsigned encoding)
2698{
DISSECTOR_ASSERT_HINT(no_of_bits <= 32, "Too many bits requested for 32-bit return type")((void) ((no_of_bits <= 32) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\" (%s)", "epan/tvbuff.c", 2699
, "no_of_bits <= 32", "Too many bits requested for 32-bit return type"
))));
return (uint32_t)tvb_get_bits64(tvb, bit_offset, no_of_bits, encoding);
2701}

2703/* Get 1 - 64 bits */
2704uint64_t
2705tvb_get_bits64(tvbuff_t *tvb, unsigned bit_offset, const unsigned no_of_bits, const unsigned encoding)
2706{
DISSECTOR_ASSERT_HINT(no_of_bits <= 64, "Too many bits requested for 64-bit return type")((void) ((no_of_bits <= 64) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\" (%s)", "epan/tvbuff.c", 2707
, "no_of_bits <= 64", "Too many bits requested for 64-bit return type"
))));

/* encoding determines bit numbering within octet array */
if (encoding & ENC_LITTLE_ENDIAN0x80000000) {
return _tvb_get_bits64_le(tvb, bit_offset, no_of_bits);
} else {
return _tvb_get_bits64(tvb, bit_offset, no_of_bits);
}
2715}

2717/*
* This function will dissect a sequence of bits that does not need to be byte aligned; the bits
* set will be shown in the tree as ..10 10.. and the integer value returned if return_value is set.
* Offset should be given in bits from the start of the tvb.
* Bits within octet are numbered from MSB (0) to LSB (7). Bit at bit_offset is return value most significant bit.
* The function tolerates requests for more than 64 bits, but will only return the least significant 64 bits.
*/
2724static uint64_t
2725_tvb_get_bits64(tvbuff_t *tvb, unsigned bit_offset, const unsigned total_no_of_bits)
2726{
uint64_t value;
unsigned	octet_offset = bit_offset >> 3;
uint8_t	required_bits_in_first_octet = 8 - (bit_offset % 8);

if(required_bits_in_first_octet > total_no_of_bits)
{
/* the required bits don't extend to the end of the first octet */
uint8_t right_shift = required_bits_in_first_octet - total_no_of_bits;
value = (tvb_get_uint8(tvb, octet_offset) >> right_shift) & bit_mask8[total_no_of_bits % 8];
}
else
{
uint8_t remaining_bit_length = total_no_of_bits;

/* get the bits up to the first octet boundary */
value = 0;
required_bits_in_first_octet %= 8;
if(required_bits_in_first_octet != 0)
{
	value = tvb_get_uint8(tvb, octet_offset) & bit_mask8[required_bits_in_first_octet];
	remaining_bit_length -= required_bits_in_first_octet;
	octet_offset ++;
}
/* take the biggest words, shorts or octets that we can */
while (remaining_bit_length > 7)
{
	switch (remaining_bit_length >> 4)
	{
	case 0:
		/* 8 - 15 bits. (note that 0 - 7 would have dropped out of the while() loop) */
		value <<= 8;
		value += tvb_get_uint8(tvb, octet_offset);
		remaining_bit_length -= 8;
		octet_offset ++;
		break;

	case 1:
		/* 16 - 31 bits */
		value <<= 16;
		value += tvb_get_ntohs(tvb, octet_offset);
		remaining_bit_length -= 16;
		octet_offset += 2;
		break;

	case 2:
	case 3:
		/* 32 - 63 bits */
		value <<= 32;
		value += tvb_get_ntohl(tvb, octet_offset);
		remaining_bit_length -= 32;
		octet_offset += 4;
		break;

	default:
		/* 64 bits (or more???) */
		value = tvb_get_ntoh64(tvb, octet_offset);
		remaining_bit_length -= 64;
		octet_offset += 8;
		break;
	}
}
/* get bits from any partial octet at the tail */
if(remaining_bit_length)
{
	value <<= remaining_bit_length;
	value += (tvb_get_uint8(tvb, octet_offset) >> (8 - remaining_bit_length));
}
}
return value;
2796}

2798/*
* Offset should be given in bits from the start of the tvb.
* Bits within octet are numbered from LSB (0) to MSB (7). Bit at bit_offset is return value least significant bit.
* The function tolerates requests for more than 64 bits, but will only return the least significant 64 bits.
*/
2803static uint64_t
2804_tvb_get_bits64_le(tvbuff_t *tvb, unsigned bit_offset, const unsigned total_no_of_bits)
2805{
uint64_t value = 0;
unsigned octet_offset = bit_offset / 8;
unsigned remaining_bits = total_no_of_bits;
unsigned shift = 0;

if (remaining_bits > 64)
{
remaining_bits = 64;
}

if (bit_offset % 8)
{
/* not aligned, extract bits from first octet */
shift = 8 - (bit_offset % 8);
value = tvb_get_uint8(tvb, octet_offset) >> (bit_offset % 8);
if (shift > remaining_bits)
{
	/* keep only the requested bits */
	value &= (UINT64_C(1)1UL << remaining_bits) - 1;
	remaining_bits = 0;
}
else
{
	remaining_bits -= shift;
}
octet_offset++;
}

while (remaining_bits > 0)
{
/* take the biggest words, shorts or octets that we can */
if (remaining_bits >= 32)
{
	value |= ((uint64_t)tvb_get_letohl(tvb, octet_offset) << shift);
	shift += 32;
	remaining_bits -= 32;
	octet_offset += 4;
}
else if (remaining_bits >= 16)
{
	value |= ((uint64_t)tvb_get_letohs(tvb, octet_offset) << shift);
	shift += 16;
	remaining_bits -= 16;
	octet_offset += 2;
}
else if (remaining_bits >= 8)
{
	value |= ((uint64_t)tvb_get_uint8(tvb, octet_offset) << shift);
	shift += 8;
	remaining_bits -= 8;
	octet_offset += 1;
}
else
{
	unsigned mask = (1 << remaining_bits) - 1;
	value |= (((uint64_t)tvb_get_uint8(tvb, octet_offset) & mask) << shift);
	shift += remaining_bits;
	remaining_bits = 0;
	octet_offset += 1;
}
}
return value;
2868}

2870static bool_Bool
2871tvb_find_uint8_generic(tvbuff_t *tvb, unsigned abs_offset, unsigned limit, uint8_t needle, unsigned *end_offset)
2872{
const uint8_t *ptr;
const uint8_t *result;

if (end_offset) {
*end_offset = abs_offset + limit;
}

ptr = ensure_contiguous_unsigned(tvb, abs_offset, limit); /* tvb_get_ptr() */
if (!ptr)
return false0;

result = (const uint8_t *) memchr(ptr, needle, limit);
if (!result)
return false0;

if (end_offset) {
*end_offset = (unsigned)((result - ptr) + abs_offset);
}
return true1;
2892}

2894static bool_Bool
2895_tvb_find_uint8_length(tvbuff_t *tvb, const unsigned offset, const unsigned limit, const uint8_t needle, unsigned *end_offset)
2896{
const uint8_t *result;

/* If we have real data, perform our search now. */
if (tvb->real_data) {
result = (const uint8_t *)memchr(tvb->real_data + offset, needle, limit);
if (result == NULL((void*)0)) {
	if (end_offset) {
		*end_offset = offset + limit;
	}
	return false0;
}
else {
	if (end_offset) {
		*end_offset = (unsigned)(result - tvb->real_data);
	}
	return true1;
}
}

if (tvb->ops->tvb_find_uint8)
return tvb->ops->tvb_find_uint8(tvb, offset, limit, needle, end_offset);

return tvb_find_uint8_generic(tvb, offset, limit, needle, end_offset);
2920}

2922bool_Bool
2923tvb_find_uint8_length(tvbuff_t *tvb, const unsigned offset, const unsigned maxlength, const uint8_t needle, unsigned *end_offset)
2924{
unsigned      limit = 0;
int           exception;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 2928, "tvb && tvb->initialized"
))));

exception = validate_offset_and_remaining(tvb, offset, &limit);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));

/* Only search to end of tvbuff, w/o throwing exception. */
if (limit > maxlength) {
/* Maximum length doesn't go past end of tvbuff; search
   to that value. */
limit = maxlength;
}

return _tvb_find_uint8_length(tvb, offset, limit, needle, end_offset);
2942}

2944bool_Bool
2945tvb_find_uint8_remaining(tvbuff_t *tvb, const unsigned offset, const uint8_t needle, unsigned *end_offset)
2946{
unsigned      limit = 0;
int           exception;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 2950, "tvb && tvb->initialized"
))));

exception = validate_offset_and_remaining(tvb, offset, &limit);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));

return _tvb_find_uint8_length(tvb, offset, limit, needle, end_offset);
2957}

2959static bool_Bool
2960_tvb_find_uint16_length(tvbuff_t *tvb, const unsigned offset, const unsigned limit, const uint16_t needle, unsigned *end_offset)
2961{
const uint8_t needle1 = ((needle & 0xFF00) >> 8);
const uint8_t needle2 = ((needle & 0x00FF) >> 0);
unsigned searched_bytes = 0;
unsigned pos = offset;

if (end_offset) {
*end_offset = offset + limit;
}

do {
if (!_tvb_find_uint8_length(tvb, pos, limit - searched_bytes, needle1, &pos)) {
	return false0;
}

/* Bytes searched so far (not counting the second byte) */
searched_bytes = pos - offset + 1;

/* Test vs. equality to account for the second byte */
if (searched_bytes >= limit) {
	return false0;
}

if (_tvb_find_uint8_length(tvb, pos + 1, 1, needle2, NULL((void*)0))) {
	if (end_offset) {
		*end_offset = pos;
	}
	return true1;
}

pos += 1;
searched_bytes += 1;
} while (searched_bytes < limit);

return false0;
2996}

2998bool_Bool
2999tvb_find_uint16_length(tvbuff_t *tvb, const unsigned offset, const unsigned maxlength, const uint16_t needle, unsigned *end_offset)
3000{
unsigned      limit = 0;
int           exception;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 3004, "tvb && tvb->initialized"
))));

exception = validate_offset_and_remaining(tvb, offset, &limit);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));

/* Only search to end of tvbuff, w/o throwing exception. */
if (limit > maxlength) {
/* Maximum length doesn't go past end of tvbuff; search
   to that value. */
limit = maxlength;
}

return _tvb_find_uint16_length(tvb, offset, limit, needle, end_offset);
3018}

3020bool_Bool
3021tvb_find_uint16_remaining(tvbuff_t *tvb, const unsigned offset, const uint16_t needle, unsigned *end_offset)
3022{
unsigned      limit = 0;
int           exception;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 3026, "tvb && tvb->initialized"
))));

exception = validate_offset_and_remaining(tvb, offset, &limit);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));

return _tvb_find_uint16_length(tvb, offset, limit, needle, end_offset);
3033}

3035static inline bool_Bool
3036tvb_ws_mempbrk_uint8_generic(tvbuff_t *tvb, unsigned abs_offset, unsigned limit, const ws_mempbrk_pattern* pattern, unsigned *found_offset, unsigned char *found_needle)
3037{
const uint8_t *ptr;
const uint8_t *result;

if (found_offset) {
*found_offset = abs_offset + limit;
}

ptr = ensure_contiguous_unsigned(tvb, abs_offset, limit); /* tvb_get_ptr */
if (!ptr)
return false0;

result = ws_mempbrk_exec(ptr, limit, pattern, found_needle);
if (!result)
return false0;

if (found_offset) {
*found_offset = (unsigned)((result - ptr) + abs_offset);
}
return true1;
3057}

3059static bool_Bool
3060_tvb_ws_mempbrk_uint8_length(tvbuff_t *tvb, const unsigned offset, const unsigned limit,
	const ws_mempbrk_pattern* pattern, unsigned *found_offset, unsigned char *found_needle)
3062{
const uint8_t *result;

/* If we have real data, perform our search now. */
if (tvb->real_data) {
result = ws_mempbrk_exec(tvb->real_data + offset, limit, pattern, found_needle);
if (result == NULL((void*)0)) {
	if (found_offset) {
		*found_offset = offset + limit;
	}
	return false0;
}
else {
	if (found_offset) {
		*found_offset = (unsigned)(result - tvb->real_data);
	}
	return true1;
}
}

if (tvb->ops->tvb_ws_mempbrk_pattern_uint8)
return tvb->ops->tvb_ws_mempbrk_pattern_uint8(tvb, offset, limit, pattern, found_offset, found_needle);

return tvb_ws_mempbrk_uint8_generic(tvb, offset, limit, pattern, found_offset, found_needle);
3086}

3088bool_Bool
3089tvb_ws_mempbrk_uint8_remaining(tvbuff_t *tvb, const unsigned offset,
	const ws_mempbrk_pattern* pattern, unsigned *found_offset, unsigned char *found_needle)
3091{
unsigned      limit = 0;
int           exception;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 3095, "tvb && tvb->initialized"
))));

exception = validate_offset_and_remaining(tvb, offset, &limit);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));

return _tvb_ws_mempbrk_uint8_length(tvb, offset, limit, pattern, found_offset, found_needle);
3102}

3104bool_Bool
3105tvb_ws_mempbrk_uint8_length(tvbuff_t *tvb, const unsigned offset, const unsigned maxlength,
	const ws_mempbrk_pattern* pattern, unsigned *found_offset, unsigned char *found_needle)
3107{
unsigned      limit = 0;
int           exception;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 3111, "tvb && tvb->initialized"
))));

exception = validate_offset_and_remaining(tvb, offset, &limit);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));

/* Only search to end of tvbuff, w/o throwing exception. */
if (limit > maxlength) {
/* Maximum length doesn't go past end of tvbuff; search
   to that value. */
limit = maxlength;
}

return _tvb_ws_mempbrk_uint8_length(tvb, offset, limit, pattern, found_offset, found_needle);
3125}

3127/* Find size of stringz (NUL-terminated string) by looking for terminating
* NUL.  The size of the string includes the terminating NUL.
*
* If the NUL isn't found, it throws the appropriate exception.
*/
3132unsigned
3133tvb_strsize(tvbuff_t *tvb, const unsigned offset)
3134{
unsigned nul_offset;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 3137, "tvb && tvb->initialized"
))));

validate_offset(tvb, offset);
if (!tvb_find_uint8_remaining(tvb, offset, 0, &nul_offset)) {
/*
 * OK, we hit the end of the tvbuff, so we should throw
 * an exception.
 */
if (tvb->length < tvb->contained_length) {
	THROW(BoundsError)except_throw(1, (1), ((void*)0));
} else if (tvb->flags & TVBUFF_FRAGMENT0x00000001) {
	THROW(FragmentBoundsError)except_throw(1, (4), ((void*)0));
} else if (tvb->length < tvb->reported_length) {
	THROW(ContainedBoundsError)except_throw(1, (2), ((void*)0));
} else {
	THROW(ReportedBoundsError)except_throw(1, (3), ((void*)0));
}
}
return (nul_offset - offset) + 1;
3156}

3158/* UTF-16/UCS-2 version of tvb_strsize */
3159/* Returns number of bytes including the (two-bytes) null terminator */
3160unsigned
3161tvb_unicode_strsize(tvbuff_t *tvb, const unsigned offset)
3162{
unsigned  cur_offset = offset;
gunichar2 uchar;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 3166, "tvb && tvb->initialized"
))));

/* Note: don't use tvb_find_uint16 because it must be aligned */
do {
/* Endianness doesn't matter when looking for null */
uchar = tvb_get_ntohs(tvb, cur_offset);
/* Make sure we don't overflow */
if (ckd_add(&cur_offset, cur_offset, 2)__builtin_add_overflow((cur_offset), (2), (&cur_offset))) {
	THROW(ReportedBoundsError)except_throw(1, (3), ((void*)0));
}
} while(uchar != 0);

return cur_offset - offset;
3179}

3181/* UTF-32/UCS-4 version of tvb_strsize */
3182/* Returns number of bytes including the (four-bytes) null terminator */
3183static unsigned
3184tvb_ucs_4_strsize(tvbuff_t *tvb, const unsigned offset)
3185{

unsigned       end_offset;
gunichar       uchar;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 3190, "tvb && tvb->initialized"
))));
end_offset = offset;
do {
/* Endianness doesn't matter when looking for null */
uchar = tvb_get_ntohl(tvb, end_offset);
/* Make sure we don't overflow */
if (ckd_add(&end_offset, end_offset, 4)__builtin_add_overflow((end_offset), (4), (&end_offset))) {
	THROW(ReportedBoundsError)except_throw(1, (3), ((void*)0));
}
} while(uchar != 0);
return end_offset - offset;
3201}

3203unsigned
3204tvb_strsize_enc(tvbuff_t *tvb, const unsigned offset, const unsigned encoding)
3205{
switch (encoding & ENC_CHARENCODING_MASK0x0000FFFE) {
case ENC_UTF_160x00000004:
case ENC_UCS_20x00000006:
return tvb_unicode_strsize(tvb, offset);

case ENC_UCS_40x00000008:
return tvb_ucs_4_strsize(tvb, offset);

      case ENC_3GPP_TS_23_038_7BITS_PACKED0x0000002C:
      case ENC_3GPP_TS_23_038_7BITS_UNPACKED0x0000004C:
      case ENC_ETSI_TS_102_221_ANNEX_A0x0000004E:
              REPORT_DISSECTOR_BUG("TS 23.038 7bits has no null character and doesn't support null-terminated strings")proto_report_dissector_bug("TS 23.038 7bits has no null character and doesn't support null-terminated strings"
);
              break;

case ENC_ASCII_7BITS0x00000034:
REPORT_DISSECTOR_BUG("Null-terminated strings not implemented for ENC_ASCII_7BITS yet")proto_report_dissector_bug("Null-terminated strings not implemented for ENC_ASCII_7BITS yet"
);
break;

case ENC_APN_STR0x00000054:
/* At least as defined in 3GPP TS 23.003 Clause 9.1, null-termination
 * does make sense as internal nulls are not allowed. */
REPORT_DISSECTOR_BUG("Null-terminated strings are not implemented for ENC_APN_STR")proto_report_dissector_bug("Null-terminated strings are not implemented for ENC_APN_STR"
);
break;

case ENC_BCD_DIGITS_0_90x00000044:
case ENC_KEYPAD_ABC_TBCD0x00000046:
case ENC_KEYPAD_BC_TBCD0x00000048:
case ENC_DECT_STANDARD_4BITS_TBCD0x00000058:
REPORT_DISSECTOR_BUG("Null-terminated strings are not supported for BCD encodings.")proto_report_dissector_bug("Null-terminated strings are not supported for BCD encodings."
);
break;

case ENC_ASCII0x00000000:
case ENC_UTF_80x00000002:
case ENC_ISO_8859_10x0000000A:
case ENC_ISO_8859_20x0000000C:
case ENC_ISO_8859_30x0000000E:
case ENC_ISO_8859_40x00000010:
case ENC_ISO_8859_50x00000012:
case ENC_ISO_8859_60x00000014:
case ENC_ISO_8859_70x00000016:
case ENC_ISO_8859_80x00000018:
case ENC_ISO_8859_90x0000001A:
case ENC_ISO_8859_100x0000001C:
case ENC_ISO_8859_110x0000001E:
case ENC_ISO_8859_130x00000022:
case ENC_ISO_8859_140x00000024:
case ENC_ISO_8859_150x00000026:
case ENC_ISO_8859_160x00000028:
case ENC_WINDOWS_12500x0000002A:
case ENC_WINDOWS_12510x0000003C:
case ENC_WINDOWS_12520x0000003A:
case ENC_MAC_ROMAN0x00000030:
case ENC_CP4370x00000032:
case ENC_CP8550x0000003E:
case ENC_CP8660x00000040:
case ENC_ISO_646_BASIC0x00000042:
case ENC_EBCDIC0x0000002E:
case ENC_EBCDIC_CP0370x00000038:
case ENC_EBCDIC_CP5000x00000060:
case ENC_T610x00000036:
case ENC_GB180300x00000050:
case ENC_EUC_KR0x00000052:
case ENC_DECT_STANDARD_8BITS0x00000056:
default:
return tvb_strsize(tvb, offset);
}
3272}

3274/* Find length of string by looking for end of string ('\0'), up to
* 'maxlength' characters'; if 'maxlength' is -1, searches to end
* of tvbuff.
* Returns -1 if 'maxlength' reached before finding EOS. */
3278int
3279tvb_strnlen(tvbuff_t *tvb, const unsigned offset, const unsigned maxlength)
3280{
unsigned result_offset;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 3283, "tvb && tvb->initialized"
))));

/* TODO - this needs a variant that returns a bool
* and sets a unsigned offset to the value if true. */
if (!tvb_find_uint8_length(tvb, offset, maxlength, 0, &result_offset)) {
return -1;
}
else {
return (int)(result_offset - offset);
}
3293}

3295/*
* Implement strneql etc
*/

3299/*
* Call strncmp after checking if enough chars left, returning 0 if
* it returns 0 (meaning "equal") and -1 otherwise, otherwise return -1.
*/
3303int
3304tvb_strneql(tvbuff_t *tvb, const unsigned offset, const char *str, const size_t size)
3305{
const uint8_t *ptr;

ptr = ensure_contiguous_unsigned_no_exception(tvb, offset, (unsigned)size, NULL((void*)0));

if (ptr) {
int cmp = strncmp((const char *)ptr, str, size);

/*
 * Return 0 if equal, -1 otherwise.
 */
return (cmp == 0 ? 0 : -1);
} else {
/*
 * Not enough characters in the tvbuff to match the
 * string.
 */
return -1;
}
3324}

3326/*
* Call g_ascii_strncasecmp after checking if enough chars left, returning
* 0 if it returns 0 (meaning "equal") and -1 otherwise, otherwise return -1.
*/
3330int
3331tvb_strncaseeql(tvbuff_t *tvb, const unsigned offset, const char *str, const size_t size)
3332{
const uint8_t *ptr;

ptr = ensure_contiguous_unsigned_no_exception(tvb, offset, (unsigned)size, NULL((void*)0));

if (ptr) {
int cmp = g_ascii_strncasecmp((const char *)ptr, str, size);

/*
 * Return 0 if equal, -1 otherwise.
 */
return (cmp == 0 ? 0 : -1);
} else {
/*
 * Not enough characters in the tvbuff to match the
 * string.
 */
return -1;
}
3351}

3353/*
* Check that the tvbuff contains at least size bytes, starting at
* offset, and that those bytes are equal to str. Return 0 for success
* and -1 for error. This function does not throw an exception.
*/
3358int
3359tvb_memeql(tvbuff_t *tvb, const unsigned offset, const uint8_t *str, size_t size)
3360{
const uint8_t *ptr;

ptr = ensure_contiguous_unsigned_no_exception(tvb, offset, (unsigned)size, NULL((void*)0));

if (ptr) {
int cmp = memcmp(ptr, str, size);

/*
 * Return 0 if equal, -1 otherwise.
 */
return (cmp == 0 ? 0 : -1);
} else {
/*
 * Not enough characters in the tvbuff to match the
 * string.
 */
return -1;
}
3379}

3381/**
* Format the data in the tvb from offset for size.
*/
3384char *
3385tvb_format_text(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, const unsigned size)
3386{
const uint8_t *ptr;

ptr = ensure_contiguous_unsigned(tvb, offset, size);
return format_text(scope, (const char*)ptr, size);
3391}

3393/*
* Format the data in the tvb from offset for length ...
*/
3396char *
3397tvb_format_text_wsp(wmem_allocator_t* allocator, tvbuff_t *tvb, const unsigned offset, const unsigned size)
3398{
const uint8_t *ptr;

ptr = ensure_contiguous_unsigned(tvb, offset, size);
return format_text_wsp(allocator, (const char*)ptr, size);
3403}

3405/**
* Like "tvb_format_text()", but for null-padded strings; don't show
* the null padding characters as "\000".
*/
3409char *
3410tvb_format_stringzpad(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, const unsigned size)
3411{
const uint8_t *ptr, *p;
unsigned      stringlen;

ptr = ensure_contiguous_unsigned(tvb, offset, size);
for (p = ptr, stringlen = 0; stringlen < size && *p != '\0'; p++, stringlen++)
;
return format_text(scope, (const char*)ptr, stringlen);
3419}

3421/*
* Like "tvb_format_text_wsp()", but for null-padded strings; don't show
* the null padding characters as "\000".
*/
3425char *
3426tvb_format_stringzpad_wsp(wmem_allocator_t* allocator, tvbuff_t *tvb, const unsigned offset, const unsigned size)
3427{
const uint8_t *ptr, *p;
unsigned      stringlen;

ptr = ensure_contiguous_unsigned(tvb, offset, size);
for (p = ptr, stringlen = 0; stringlen < size && *p != '\0'; p++, stringlen++)
;
return format_text_wsp(allocator, (const char*)ptr, stringlen);
3435}

3437/*
* All string functions below take a scope as an argument.
*
*
* If scope is NULL, memory is allocated with g_malloc() and user must
* explicitly free it with g_free().
* If scope is not NULL, memory is allocated with the corresponding pool
* lifetime.
*
* All functions throw an exception if the tvbuff ends before the string
* does.
*/

3450/*
* Given a wmem scope, a tvbuff, an offset, and a length, treat the string
* of bytes referred to by the tvbuff, offset, and length as an ASCII string,
* with all bytes with the high-order bit set being invalid, and return a
* pointer to a UTF-8 string, allocated using the wmem scope.
*
* Octets with the highest bit set will be converted to the Unicode
* REPLACEMENT CHARACTER.
*/
3459static uint8_t *
3460tvb_get_ascii_string(wmem_allocator_t *scope, tvbuff_t *tvb, unsigned offset, unsigned length)
3461{
const uint8_t *ptr;

ptr = ensure_contiguous_unsigned(tvb, offset, length);
return get_ascii_string(scope, ptr, length);
3466}

3468/*
* Given a wmem scope, a tvbuff, an offset, a length, and a translation table,
* treat the string of bytes referred to by the tvbuff, offset, and length
* as a string encoded using one octet per character, with octets with the
* high-order bit clear being mapped by the translation table to 2-byte
* Unicode Basic Multilingual Plane characters (including REPLACEMENT
* CHARACTER) and octets with the high-order bit set being mapped to
* REPLACEMENT CHARACTER, and return a pointer to a UTF-8 string,
* allocated using the wmem scope.
*
* Octets with the highest bit set will be converted to the Unicode
* REPLACEMENT CHARACTER.
*/
3481static uint8_t *
3482tvb_get_iso_646_string(wmem_allocator_t *scope, tvbuff_t *tvb, unsigned offset, unsigned length, const gunichar2 table[0x80])
3483{
const uint8_t *ptr;

ptr = ensure_contiguous_unsigned(tvb, offset, length);
return get_iso_646_string(scope, ptr, length, table);
3488}

3490/*
* Given a wmem scope, a tvbuff, an offset, and a length, treat the string
* of bytes referred to by the tvbuff, the offset. and the length as a UTF-8
* string, and return a pointer to a UTF-8 string, allocated using the wmem
* scope, with all ill-formed sequences replaced with the Unicode REPLACEMENT
* CHARACTER according to the recommended "best practices" given in the Unicode
* Standard and specified by W3C/WHATWG.
*
* Note that in conformance with the Unicode Standard, this treats three
* byte sequences corresponding to UTF-16 surrogate halves (paired or unpaired)
* and two byte overlong encodings of 7-bit ASCII characters as invalid and
* substitutes REPLACEMENT CHARACTER for them. Explicit support for nonstandard
* derivative encoding formats (e.g. CESU-8, Java Modified UTF-8, WTF-8) could
* be added later.
*/
3505static uint8_t *
3506tvb_get_utf_8_string(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, const unsigned length)
3507{
const uint8_t *ptr;

ptr = ensure_contiguous_unsigned(tvb, offset, length);
return get_utf_8_string(scope, ptr, length);
3512}

3514/*
* Given a wmem scope, a tvbuff, an offset, and a length, treat the string
* of bytes referred to by the tvbuff, the offset, and the length as a
* raw string, and return a pointer to that string, allocated using the
* wmem scope. This means a null is appended at the end, but no replacement
* checking is done otherwise, unlike tvb_get_utf_8_string().
*/
3521static inline uint8_t *
3522tvb_get_raw_string(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, const unsigned length)
3523{
uint8_t *strbuf;

tvb_ensure_bytes_exist(tvb, offset, length);
strbuf = (uint8_t *)wmem_alloc(scope, length + 1);
tvb_memcpy(tvb, strbuf, offset, length);
strbuf[length] = '\0';
return strbuf;
3531}

3533/*
* Given a wmem scope, a tvbuff, an offset, and a length, treat the string
* of bytes referred to by the tvbuff, the offset, and the length as an
* ISO 8859/1 string, and return a pointer to a UTF-8 string, allocated
* using the wmem scope.
*/
3539static uint8_t *
3540tvb_get_string_8859_1(wmem_allocator_t *scope, tvbuff_t *tvb, unsigned offset, unsigned length)
3541{
const uint8_t *ptr;

ptr = ensure_contiguous_unsigned(tvb, offset, length);
return get_8859_1_string(scope, ptr, length);
3546}

3548/*
* Given a wmem scope, a tvbuff, an offset, a length, and a translation
* table, treat the string of bytes referred to by the tvbuff, the offset,
* and the length as a string encoded using one octet per character, with
* octets with the high-order bit clear being ASCII and octets with the
* high-order bit set being mapped by the translation table to 2-byte
* Unicode Basic Multilingual Plane characters (including REPLACEMENT
* CHARACTER), and return a pointer to a UTF-8 string, allocated with the
* wmem scope.
*/
3558static uint8_t *
3559tvb_get_string_unichar2(wmem_allocator_t *scope, tvbuff_t *tvb, unsigned offset, unsigned length, const gunichar2 table[0x80])
3560{
const uint8_t *ptr;

ptr = ensure_contiguous_unsigned(tvb, offset, length);
return get_unichar2_string(scope, ptr, length, table);
3565}

3567/*
* Given a wmem scope, a tvbuff, an offset, a length, and an encoding
* giving the byte order, treat the string of bytes referred to by the
* tvbuff, the offset, and the length as a UCS-2 encoded string in
* the byte order in question, containing characters from the Basic
* Multilingual Plane (plane 0) of Unicode, and return a pointer to a
* UTF-8 string, allocated with the wmem scope.
*
* Encoding parameter should be ENC_BIG_ENDIAN or ENC_LITTLE_ENDIAN,
* optionally with ENC_BOM.
*
* Specify length in bytes.
*
* XXX - should map lead and trail surrogate values to REPLACEMENT
* CHARACTERs (0xFFFD)?
* XXX - if there are an odd number of bytes, should put a
* REPLACEMENT CHARACTER at the end.
*/
3585static uint8_t *
3586tvb_get_ucs_2_string(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, unsigned length, const unsigned encoding)
3587{
const uint8_t *ptr;

ptr = ensure_contiguous_unsigned(tvb, offset, length);
return get_ucs_2_string(scope, ptr, length, encoding);
3592}

3594/*
* Given a wmem scope, a tvbuff, an offset, a length, and an encoding
* giving the byte order, treat the string of bytes referred to by the
* tvbuff, the offset, and the length as a UTF-16 encoded string in
* the byte order in question, and return a pointer to a UTF-8 string,
* allocated with the wmem scope.
*
* Encoding parameter should be ENC_BIG_ENDIAN or ENC_LITTLE_ENDIAN,
* optionally with ENC_BOM.
*
* Specify length in bytes.
*
* XXX - should map surrogate errors to REPLACEMENT CHARACTERs (0xFFFD).
* XXX - should map code points > 10FFFF to REPLACEMENT CHARACTERs.
* XXX - if there are an odd number of bytes, should put a
* REPLACEMENT CHARACTER at the end.
*/
3611static uint8_t *
3612tvb_get_utf_16_string(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, unsigned length, const unsigned encoding)
3613{
const uint8_t *ptr;

ptr = ensure_contiguous_unsigned(tvb, offset, length);
return get_utf_16_string(scope, ptr, length, encoding);
3618}

3620/*
* Given a wmem scope, a tvbuff, an offset, a length, and an encoding
* giving the byte order, treat the string of bytes referred to by the
* tvbuff, the offset, and the length as a UCS-4 encoded string in
* the byte order in question, and return a pointer to a UTF-8 string,
* allocated with the wmem scope.
*
* Encoding parameter should be ENC_BIG_ENDIAN or ENC_LITTLE_ENDIAN,
* optionally with ENC_BOM.
*
* Specify length in bytes
*
* XXX - should map lead and trail surrogate values to a "substitute"
* UTF-8 character?
* XXX - should map code points > 10FFFF to REPLACEMENT CHARACTERs.
* XXX - if the number of bytes isn't a multiple of 4, should put a
* REPLACEMENT CHARACTER at the end.
*/
3638static char *
3639tvb_get_ucs_4_string(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, unsigned length, const unsigned encoding)
3640{
const uint8_t *ptr;

ptr = ensure_contiguous_unsigned(tvb, offset, length);
return (char*)get_ucs_4_string(scope, ptr, length, encoding);
3645}

3647char *
3648tvb_get_ts_23_038_7bits_string_packed(wmem_allocator_t *scope, tvbuff_t *tvb,
const unsigned bit_offset, unsigned no_of_chars)
3650{
unsigned       in_offset = bit_offset >> 3; /* Current pointer to the input buffer */
/* Calculate the number of bytes this will occupy without overflow.
* The end result never overflow (although some compilers don't know
* that and will warn about shortening absent an explicit cast), but
* we must store the intermediate result in a wider type. */
unsigned length = (unsigned)((((uint64_t)no_of_chars + 1) * 7 + (bit_offset & 0x07)) >> 3);
3657#if 0
/* Alternatively, on 32-bit architectures (or if we were doing the
* same operation on 64-bit integers), we could divide by 8 first,
* splitting no_of_chars into its quotient and remainder: */
unsigned       length = (no_of_chars >> 3) * 7;
/* Then calculate the number of bytes occupied by the remainder and bit
* offset, rounded up. */
length += ((no_of_chars & 0x7 + 1) * 7 + (bit_offset & 0x7)) >> 3;
3665#endif
const uint8_t *ptr;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 3668, "tvb && tvb->initialized"
))));

ptr = ensure_contiguous_unsigned(tvb, in_offset, length);
return (char*)get_ts_23_038_7bits_string_packed(scope, ptr, bit_offset, no_of_chars);
3672}

3674char *
3675tvb_get_ts_23_038_7bits_string_unpacked(wmem_allocator_t *scope, tvbuff_t *tvb,
const unsigned offset, unsigned length)
3677{
const uint8_t *ptr;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 3680, "tvb && tvb->initialized"
))));

ptr = ensure_contiguous_unsigned(tvb, offset, length);
return (char*)get_ts_23_038_7bits_string_unpacked(scope, ptr, length);
3684}

3686char *
3687tvb_get_etsi_ts_102_221_annex_a_string(wmem_allocator_t *scope, tvbuff_t *tvb,
const unsigned offset, unsigned length)
3689{
const uint8_t *ptr;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 3692, "tvb && tvb->initialized"
))));

ptr = ensure_contiguous_unsigned(tvb, offset, length);
return (char*)get_etsi_ts_102_221_annex_a_string(scope, ptr, length);
3696}

3698char *
3699tvb_get_ascii_7bits_string(wmem_allocator_t *scope, tvbuff_t *tvb,
const unsigned bit_offset, unsigned no_of_chars)
3701{
unsigned       in_offset = bit_offset >> 3; /* Current pointer to the input buffer */
/* Calculate the number of bytes this will occupy without overflow.
* The end result never overflow (although some compilers don't know
* that and will warn about shortening absent an explicit cast), but
* we must store the intermediate result in a wider type. */
unsigned length = (unsigned)((((uint64_t)no_of_chars + 1) * 7 + (bit_offset & 0x07)) >> 3);
3708#if 0
/* Alternatively, on 32-bit architectures (or if we were doing the
* same operation on 64-bit integers), we could divide by 8 first,
* splitting no_of_chars into its quotient and remainder: */
unsigned       length = (no_of_chars >> 3) * 7;
/* Then calculate the number of bytes occupied by the remainder and bit
* offset, rounded up. */
length += ((no_of_chars & 0x7 + 1) * 7 + (bit_offset & 0x7)) >> 3;
3716#endif
const uint8_t *ptr;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 3719, "tvb && tvb->initialized"
))));

ptr = ensure_contiguous_unsigned(tvb, in_offset, length);
return (char*)get_ascii_7bits_string(scope, ptr, bit_offset, no_of_chars);
3723}

3725/*
* Given a wmem scope, a tvbuff, an offset, a length, and a translation
* table, treat the string of bytes referred to by the tvbuff, the offset,
* and the length as a string encoded using one octet per character, with
* octets being mapped by the translation table to 2-byte Unicode Basic
* Multilingual Plane characters (including REPLACEMENT CHARACTER), and
* return a pointer to a UTF-8 string, allocated with the wmem scope.
*/
3733static uint8_t *
3734tvb_get_nonascii_unichar2_string(wmem_allocator_t *scope, tvbuff_t *tvb, unsigned offset, unsigned length, const gunichar2 table[256])
3735{
const uint8_t *ptr;

ptr = ensure_contiguous_unsigned(tvb, offset, length);
return get_nonascii_unichar2_string(scope, ptr, length, table);
3740}

3742/*
* Given a wmem scope, a tvbuff, an offset, and a length, treat the bytes
* referred to by the tvbuff, offset, and length as a GB18030 encoded string,
* and return a pointer to a UTF-8 string, allocated with the wmem scope,
* converted having substituted REPLACEMENT CHARACTER according to the
* Unicode Standard 5.22 U+FFFD Substitution for Conversion.
* ( https://www.unicode.org/versions/Unicode13.0.0/ch05.pdf )
*
* As expected, this will also decode GBK and GB2312 strings.
*/
3752static uint8_t *
3753tvb_get_gb18030_string(wmem_allocator_t *scope, tvbuff_t *tvb, unsigned offset, unsigned length)
3754{
const uint8_t *ptr;

ptr = ensure_contiguous_unsigned(tvb, offset, length);
return get_gb18030_string(scope, ptr, length);
3759}

3761/*
* Given a wmem scope, a tvbuff, an offset, and a length, treat the bytes
* referred to by the tvbuff, offset, and length as a EUC-KR encoded string,
* and return a pointer to a UTF-8 string, allocated with the wmem scope,
* converted having substituted REPLACEMENT CHARACTER according to the
* Unicode Standard 5.22 U+FFFD Substitution for Conversion.
* ( https://www.unicode.org/versions/Unicode13.0.0/ch05.pdf )
*/
3769static uint8_t *
3770tvb_get_euc_kr_string(wmem_allocator_t *scope, tvbuff_t *tvb, unsigned offset, unsigned length)
3771{
const uint8_t *ptr;

ptr = ensure_contiguous_unsigned(tvb, offset, length);
return get_euc_kr_string(scope, ptr, length);
3776}

3778static uint8_t *
3779tvb_get_t61_string(wmem_allocator_t *scope, tvbuff_t *tvb, unsigned offset, unsigned length)
3780{
const uint8_t *ptr;

ptr = ensure_contiguous_unsigned(tvb, offset, length);
return get_t61_string(scope, ptr, length);
3785}

3787/*
* Encoding tables for BCD strings.
*/
3790static const dgt_set_t Dgt0_9_bcd = {
{
/*  0   1   2   3   4   5   6   7   8   9   a   b   c   d   e  f */
   '0','1','2','3','4','5','6','7','8','9','?','?','?','?','?','?'
}
3795};

3797static const dgt_set_t Dgt_keypad_abc_tbcd = {
{
/*  0   1   2   3   4   5   6   7   8   9   a   b   c   d   e  f */
   '0','1','2','3','4','5','6','7','8','9','*','#','a','b','c','?'
}
3802};

3804static const dgt_set_t Dgt_ansi_tbcd = {
{
/*  0   1   2   3   4   5   6   7   8   9   a   b   c   d   e  f */
   '0','1','2','3','4','5','6','7','8','9','?','B','C','*','#','?'
}
3809};

3811static const dgt_set_t Dgt_dect_standard_4bits_tbcd = {
{
/*  0   1   2   3   4   5   6   7   8   9   a   b   c   d   e  f */
   '0','1','2','3','4','5','6','7','8','9','?',' ','?','?','?','?'
}
3816};

3818static uint8_t *
3819tvb_get_apn_string(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset,
	     unsigned length)
3821{
wmem_strbuf_t *str;

/*
* This is a domain name.
*
* 3GPP TS 23.003, section 19.4.2 "Fully Qualified Domain Names
* (FQDNs)", subsection 19.4.2.1 "General", says:
*
*    The encoding of any identifier used as part of a Fully
*    Qualified Domain Name (FQDN) shall follow the Name Syntax
*    defined in IETF RFC 2181 [18], IETF RFC 1035 [19] and
*    IETF RFC 1123 [20].  An FQDN consists of one or more
*    labels. Each label is coded as a one octet length field
*    followed by that number of octets coded as 8 bit ASCII
*    characters.
*
* so this does not appear to use full-blown DNS compression -
* the upper 2 bits of the length don't indicate that it's a
* pointer or an extended label (RFC 2673).
*/
str = wmem_strbuf_new_sized(scope, length + 1);
if (length > 0) {
const uint8_t *ptr;

ptr = ensure_contiguous_unsigned(tvb, offset, length);

for (;;) {
	unsigned label_len;

	/*
	 * Process this label.
	 */
	label_len = *ptr;
	ptr++;
	length--;

	while (label_len != 0) {
		uint8_t ch;

		if (length == 0)
			goto end;

		ch = *ptr;
		if (ch < 0x80)
			wmem_strbuf_append_c(str, ch);
		else
			wmem_strbuf_append_unichar_repl(str)wmem_strbuf_append_unichar(str, 0x00FFFD);
		ptr++;
		label_len--;
		length--;
	}

	if (length == 0)
		goto end;

	wmem_strbuf_append_c(str, '.');
}
}

3881end:
return (uint8_t *) wmem_strbuf_finalize(str);
3883}

3885static uint8_t *
3886tvb_get_dect_standard_8bits_string(wmem_allocator_t *scope, tvbuff_t *tvb, unsigned offset, unsigned length)
3887{
const uint8_t *ptr;

ptr = ensure_contiguous_unsigned(tvb, offset, length);
return get_dect_standard_8bits_string(scope, ptr, length);
3892}

3894/*
* Given a tvbuff, an offset, a length, and an encoding, allocate a
* buffer big enough to hold a non-null-terminated string of that length
* at that offset, plus a trailing '\0', copy into the buffer the
* string as converted from the appropriate encoding to UTF-8, and
* return a pointer to the string.
*/
3901uint8_t *
3902tvb_get_string_enc(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset,
	     const unsigned length, const unsigned encoding)
3904{
uint8_t *strptr;
bool_Bool odd, skip_first;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 3908, "tvb && tvb->initialized"
))));

switch (encoding & ENC_CHARENCODING_MASK0x0000FFFE) {

case ENC_ASCII0x00000000:
default:
/*
 * For now, we treat bogus values as meaning
 * "ASCII" rather than reporting an error,
 * for the benefit of old dissectors written
 * when the last argument to proto_tree_add_item()
 * was a bool for the byte order, not an
 * encoding value, and passed non-zero values
 * other than true to mean "little-endian".
 */
strptr = tvb_get_ascii_string(scope, tvb, offset, length);
break;

case ENC_UTF_80x00000002:
strptr = tvb_get_utf_8_string(scope, tvb, offset, length);
break;

case ENC_UTF_160x00000004:
strptr = tvb_get_utf_16_string(scope, tvb, offset, length,
    encoding & (ENC_LITTLE_ENDIAN0x80000000|ENC_BOM0x20000000));
break;

case ENC_UCS_20x00000006:
strptr = tvb_get_ucs_2_string(scope, tvb, offset, length,
    encoding & (ENC_LITTLE_ENDIAN0x80000000|ENC_BOM0x20000000));
break;

case ENC_UCS_40x00000008:
strptr = (uint8_t*)tvb_get_ucs_4_string(scope, tvb, offset, length,
    encoding & (ENC_LITTLE_ENDIAN0x80000000|ENC_BOM0x20000000));
break;

case ENC_ISO_8859_10x0000000A:
/*
 * ISO 8859-1 printable code point values are equal
 * to the equivalent Unicode code point value, so
 * no translation table is needed.
 */
strptr = tvb_get_string_8859_1(scope, tvb, offset, length);
break;

case ENC_ISO_8859_20x0000000C:
strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_2);
break;

case ENC_ISO_8859_30x0000000E:
strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_3);
break;

case ENC_ISO_8859_40x00000010:
strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_4);
break;

case ENC_ISO_8859_50x00000012:
strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_5);
break;

case ENC_ISO_8859_60x00000014:
strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_6);
break;

case ENC_ISO_8859_70x00000016:
strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_7);
break;

case ENC_ISO_8859_80x00000018:
strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_8);
break;

case ENC_ISO_8859_90x0000001A:
strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_9);
break;

case ENC_ISO_8859_100x0000001C:
strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_10);
break;

case ENC_ISO_8859_110x0000001E:
strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_11);
break;

case ENC_ISO_8859_130x00000022:
strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_13);
break;

case ENC_ISO_8859_140x00000024:
strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_14);
break;

case ENC_ISO_8859_150x00000026:
strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_15);
break;

case ENC_ISO_8859_160x00000028:
strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_16);
break;

case ENC_WINDOWS_12500x0000002A:
strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_cp1250);
break;

case ENC_WINDOWS_12510x0000003C:
strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_cp1251);
break;

case ENC_WINDOWS_12520x0000003A:
strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_cp1252);
break;

case ENC_MAC_ROMAN0x00000030:
strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_mac_roman);
break;

case ENC_CP4370x00000032:
strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_cp437);
break;

case ENC_CP8550x0000003E:
strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_cp855);
break;

case ENC_CP8660x00000040:
strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_cp866);
break;

case ENC_ISO_646_BASIC0x00000042:
strptr = tvb_get_iso_646_string(scope, tvb, offset, length, charset_table_iso_646_basic);
break;

case ENC_3GPP_TS_23_038_7BITS_PACKED0x0000002C:
{
	unsigned bit_offset  = offset << 3;
	unsigned no_of_chars = (length << 3) / 7;
	strptr = (uint8_t*)tvb_get_ts_23_038_7bits_string_packed(scope, tvb, bit_offset, no_of_chars);
}
break;

case ENC_ASCII_7BITS0x00000034:
{
	unsigned bit_offset  = offset << 3;
	unsigned no_of_chars = (length << 3) / 7;
	strptr = (uint8_t*)tvb_get_ascii_7bits_string(scope, tvb, bit_offset, no_of_chars);
}
break;

case ENC_EBCDIC0x0000002E:
/*
 * "Common" EBCDIC, covering all characters with the
 * same code point in all Roman-alphabet EBCDIC code
 * pages.
 */
strptr = tvb_get_nonascii_unichar2_string(scope, tvb, offset, length, charset_table_ebcdic);
break;

case ENC_EBCDIC_CP0370x00000038:
/*
 * EBCDIC code page 037.
 */
strptr = tvb_get_nonascii_unichar2_string(scope, tvb, offset, length, charset_table_ebcdic_cp037);
break;

case ENC_EBCDIC_CP5000x00000060:
/*
 * EBCDIC code page 500.
 */
strptr = tvb_get_nonascii_unichar2_string(scope, tvb, offset, length, charset_table_ebcdic_cp500);
break;

case ENC_T610x00000036:
strptr = tvb_get_t61_string(scope, tvb, offset, length);
break;

case ENC_BCD_DIGITS_0_90x00000044:
/*
 * Packed BCD, with digits 0-9.
 */
odd = (encoding & ENC_BCD_ODD_NUM_DIG0x00010000) >> 16;
skip_first = (encoding & ENC_BCD_SKIP_FIRST0x00020000) >> 17;
strptr = (uint8_t*)tvb_get_bcd_string(scope, tvb, offset, length, &Dgt0_9_bcd, skip_first, odd, !(encoding & ENC_LITTLE_ENDIAN0x80000000));
break;

case ENC_KEYPAD_ABC_TBCD0x00000046:
/*
 * Keypad-with-a/b/c "telephony BCD" - packed BCD, with
 * digits 0-9 and symbols *, #, a, b, and c.
 */
odd = (encoding & ENC_BCD_ODD_NUM_DIG0x00010000) >> 16;
skip_first = (encoding & ENC_BCD_SKIP_FIRST0x00020000) >> 17;
strptr = (uint8_t*)tvb_get_bcd_string(scope, tvb, offset, length, &Dgt_keypad_abc_tbcd, skip_first, odd, !(encoding & ENC_LITTLE_ENDIAN0x80000000));
break;

case ENC_KEYPAD_BC_TBCD0x00000048:
/*
 * Keypad-with-B/C "telephony BCD" - packed BCD, with
 * digits 0-9 and symbols B, C, *, and #.
 */
odd = (encoding & ENC_BCD_ODD_NUM_DIG0x00010000) >> 16;
skip_first = (encoding & ENC_BCD_SKIP_FIRST0x00020000) >> 17;
strptr = (uint8_t*)tvb_get_bcd_string(scope, tvb, offset, length, &Dgt_ansi_tbcd, skip_first, odd, !(encoding & ENC_LITTLE_ENDIAN0x80000000));
break;

case ENC_3GPP_TS_23_038_7BITS_UNPACKED0x0000004C:
strptr = (uint8_t*)tvb_get_ts_23_038_7bits_string_unpacked(scope, tvb, offset, length);
break;

case ENC_ETSI_TS_102_221_ANNEX_A0x0000004E:
strptr = (uint8_t*)tvb_get_etsi_ts_102_221_annex_a_string(scope, tvb, offset, length);
break;

case ENC_GB180300x00000050:
strptr = tvb_get_gb18030_string(scope, tvb, offset, length);
break;

case ENC_EUC_KR0x00000052:
strptr = tvb_get_euc_kr_string(scope, tvb, offset, length);
break;

case ENC_APN_STR0x00000054:
strptr = tvb_get_apn_string(scope, tvb, offset, length);
break;

case ENC_DECT_STANDARD_8BITS0x00000056:
strptr = tvb_get_dect_standard_8bits_string(scope, tvb, offset, length);
break;

case ENC_DECT_STANDARD_4BITS_TBCD0x00000058:
/*
 * DECT standard 4bits "telephony BCD" - packed BCD, with
 * digits 0-9 and symbol SPACE for 0xb.
 */
odd = (encoding & ENC_BCD_ODD_NUM_DIG0x00010000) >> 16;
skip_first = (encoding & ENC_BCD_SKIP_FIRST0x00020000) >> 17;
strptr = (uint8_t*)tvb_get_bcd_string(scope, tvb, offset, length, &Dgt_dect_standard_4bits_tbcd, skip_first, odd, false0);
break;
}
return strptr;
4149}

4151/*
* This is like tvb_get_string_enc(), except that it handles null-padded
* strings.
*
* Currently, string values are stored as UTF-8 null-terminated strings,
* so nothing needs to be done differently for null-padded strings; we
* could save a little memory by not storing the null padding.
*
* If we ever store string values differently, in a fashion that doesn't
* involve null termination, that might change.
*/
4162uint8_t *
4163tvb_get_stringzpad(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset,
   const unsigned length, const unsigned encoding)
4165{
return tvb_get_string_enc(scope, tvb, offset, length, encoding);
4167}

4169/*
* These routines are like the above routines, except that they handle
* null-terminated strings.  They find the length of that string (and
* throw an exception if the tvbuff ends before we find the null), and
* also return through a pointer the length of the string, in bytes,
* including the terminating null (the terminating null being 2 bytes
* for UCS-2 and UTF-16, 4 bytes for UCS-4, and 1 byte for other
* encodings).
*/
4178static uint8_t *
4179tvb_get_ascii_stringz(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, unsigned *lengthp)
4180{
unsigned       size;
const uint8_t *ptr;

size = tvb_strsize(tvb, offset);
ptr  = ensure_contiguous_unsigned(tvb, offset, size);
if (lengthp)
*lengthp = size;
return get_ascii_string(scope, ptr, size);
4189}

4191static uint8_t *
4192tvb_get_iso_646_stringz(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, unsigned *lengthp, const gunichar2 table[0x80])
4193{
unsigned       size;
const uint8_t *ptr;

size = tvb_strsize(tvb, offset);
ptr  = ensure_contiguous_unsigned(tvb, offset, size);
if (lengthp)
*lengthp = size;
return get_iso_646_string(scope, ptr, size, table);
4202}

4204static uint8_t *
4205tvb_get_utf_8_stringz(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, unsigned *lengthp)
4206{
unsigned   size;
const uint8_t *ptr;

size   = tvb_strsize(tvb, offset);
ptr = ensure_contiguous_unsigned(tvb, offset, size);
if (lengthp)
*lengthp = size;
return get_utf_8_string(scope, ptr, size);
4215}

4217static uint8_t *
4218tvb_get_stringz_8859_1(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, unsigned *lengthp)
4219{
unsigned size;
const uint8_t *ptr;

size = tvb_strsize(tvb, offset);
ptr = ensure_contiguous_unsigned(tvb, offset, size);
if (lengthp)
*lengthp = size;
return get_8859_1_string(scope, ptr, size);
4228}

4230static uint8_t *
4231tvb_get_stringz_unichar2(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, unsigned *lengthp, const gunichar2 table[0x80])
4232{
unsigned size;
const uint8_t *ptr;

size = tvb_strsize(tvb, offset);
ptr = ensure_contiguous_unsigned(tvb, offset, size);
if (lengthp)
*lengthp = size;
return get_unichar2_string(scope, ptr, size, table);
4241}

4243/*
* Given a tvbuff and an offset, with the offset assumed to refer to
* a null-terminated string, find the length of that string (and throw
* an exception if the tvbuff ends before we find the null), ensure that
* the TVB is flat, and return a pointer to the string (in the TVB).
* Also return the length of the string (including the terminating null)
* through a pointer.
*
* As long as we aren't using composite TVBs, this saves the cycles used
* (often unnecessarily) in allocating a buffer and copying the string into
* it. OTOH, the string returned isn't valid UTF-8, so it shouldn't be
* added to the tree, the columns, etc., just used with various other
* functions that operate on strings that don't have a tvb_ equivalent.
* That's hard to enforce, which is why this is deprecated.
*/
4258static char *
4259tvb_get_ucs_2_stringz(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, unsigned *lengthp, const unsigned encoding)
4260{
unsigned       size;    /* Number of bytes in string */
const uint8_t *ptr;

size = tvb_unicode_strsize(tvb, offset);
ptr = ensure_contiguous_unsigned(tvb, offset, size);
if (lengthp)
*lengthp = size;
return (char*)get_ucs_2_string(scope, ptr, size, encoding);
4269}

4271static char *
4272tvb_get_utf_16_stringz(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, unsigned *lengthp, const unsigned encoding)
4273{
unsigned       size;
const uint8_t *ptr;

size = tvb_unicode_strsize(tvb, offset);
ptr = ensure_contiguous_unsigned(tvb, offset, size);
if (lengthp)
*lengthp = size;
return (char*)get_utf_16_string(scope, ptr, size, encoding);
4282}

4284static char *
4285tvb_get_ucs_4_stringz(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, unsigned *lengthp, const unsigned encoding)
4286{
unsigned       size;
const uint8_t *ptr;

size = tvb_ucs_4_strsize(tvb, offset);

ptr = ensure_contiguous_unsigned(tvb, offset, size);
if (lengthp)
*lengthp = size;
return (char*)get_ucs_4_string(scope, ptr, size, encoding);
4296}

4298static uint8_t *
4299tvb_get_nonascii_unichar2_stringz(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, unsigned *lengthp, const gunichar2 table[256])
4300{
unsigned       size;
const uint8_t *ptr;

size = tvb_strsize(tvb, offset);
ptr  = ensure_contiguous_unsigned(tvb, offset, size);
if (lengthp)
*lengthp = size;
return get_nonascii_unichar2_string(scope, ptr, size, table);
4309}

4311static uint8_t *
4312tvb_get_t61_stringz(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, unsigned *lengthp)
4313{
unsigned       size;
const uint8_t *ptr;

size = tvb_strsize(tvb, offset);
ptr  = ensure_contiguous_unsigned(tvb, offset, size);
if (lengthp)
*lengthp = size;
return get_t61_string(scope, ptr, size);
4322}

4324static uint8_t *
4325tvb_get_gb18030_stringz(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, unsigned *lengthp)
4326{
unsigned       size;
const uint8_t *ptr;

size = tvb_strsize(tvb, offset);
ptr  = ensure_contiguous_unsigned(tvb, offset, size);
if (lengthp)
*lengthp = size;
return get_gb18030_string(scope, ptr, size);
4335}

4337static uint8_t *
4338tvb_get_euc_kr_stringz(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, unsigned *lengthp)
4339{
unsigned       size;
const uint8_t *ptr;

size = tvb_strsize(tvb, offset);
ptr  = ensure_contiguous_unsigned(tvb, offset, size);
if (lengthp)
*lengthp = size;
return get_euc_kr_string(scope, ptr, size);
4348}

4350static uint8_t *
4351tvb_get_dect_standard_8bits_stringz(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, unsigned *lengthp)
4352{
unsigned       size;
const uint8_t *ptr;

size = tvb_strsize(tvb, offset);
ptr  = ensure_contiguous_unsigned(tvb, offset, size);
if (lengthp)
*lengthp = size;
return get_dect_standard_8bits_string(scope, ptr, size);
4361}

4363uint8_t *
4364tvb_get_stringz_enc(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, unsigned *lengthp, const unsigned encoding)
4365{
uint8_t *strptr;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 4368, "tvb && tvb->initialized"
))));

switch (encoding & ENC_CHARENCODING_MASK0x0000FFFE) {

case ENC_ASCII0x00000000:
default:
/*
 * For now, we treat bogus values as meaning
 * "ASCII" rather than reporting an error,
 * for the benefit of old dissectors written
 * when the last argument to proto_tree_add_item()
 * was a bool for the byte order, not an
 * encoding value, and passed non-zero values
 * other than true to mean "little-endian".
 */
strptr = tvb_get_ascii_stringz(scope, tvb, offset, lengthp);
break;

case ENC_UTF_80x00000002:
strptr = tvb_get_utf_8_stringz(scope, tvb, offset, lengthp);
break;

case ENC_UTF_160x00000004:
strptr = (uint8_t*)tvb_get_utf_16_stringz(scope, tvb, offset, lengthp,
    encoding & (ENC_LITTLE_ENDIAN0x80000000|ENC_BOM0x20000000));
break;

case ENC_UCS_20x00000006:
strptr = (uint8_t*)tvb_get_ucs_2_stringz(scope, tvb, offset, lengthp,
    encoding & (ENC_LITTLE_ENDIAN0x80000000|ENC_BOM0x20000000));
break;

case ENC_UCS_40x00000008:
strptr = (uint8_t*)tvb_get_ucs_4_stringz(scope, tvb, offset, lengthp,
    encoding & (ENC_LITTLE_ENDIAN0x80000000|ENC_BOM0x20000000));
break;

case ENC_ISO_8859_10x0000000A:
/*
 * ISO 8859-1 printable code point values are equal
 * to the equivalent Unicode code point value, so
 * no translation table is needed.
 */
strptr = tvb_get_stringz_8859_1(scope, tvb, offset, lengthp);
break;

case ENC_ISO_8859_20x0000000C:
strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_2);
break;

case ENC_ISO_8859_30x0000000E:
strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_3);
break;

case ENC_ISO_8859_40x00000010:
strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_4);
break;

case ENC_ISO_8859_50x00000012:
strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_5);
break;

case ENC_ISO_8859_60x00000014:
strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_6);
break;

case ENC_ISO_8859_70x00000016:
strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_7);
break;

case ENC_ISO_8859_80x00000018:
strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_8);
break;

case ENC_ISO_8859_90x0000001A:
strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_9);
break;

case ENC_ISO_8859_100x0000001C:
strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_10);
break;

case ENC_ISO_8859_110x0000001E:
strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_11);
break;

case ENC_ISO_8859_130x00000022:
strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_13);
break;

case ENC_ISO_8859_140x00000024:
strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_14);
break;

case ENC_ISO_8859_150x00000026:
strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_15);
break;

case ENC_ISO_8859_160x00000028:
strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_16);
break;

case ENC_WINDOWS_12500x0000002A:
strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_cp1250);
break;

case ENC_WINDOWS_12510x0000003C:
strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_cp1251);
break;

case ENC_WINDOWS_12520x0000003A:
strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_cp1252);
break;

case ENC_MAC_ROMAN0x00000030:
strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_mac_roman);
break;

case ENC_CP4370x00000032:
strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_cp437);
break;

case ENC_CP8550x0000003E:
strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_cp855);
break;

case ENC_CP8660x00000040:
strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_cp866);
break;

case ENC_ISO_646_BASIC0x00000042:
strptr = tvb_get_iso_646_stringz(scope, tvb, offset, lengthp, charset_table_iso_646_basic);
break;

case ENC_BCD_DIGITS_0_90x00000044:
case ENC_KEYPAD_ABC_TBCD0x00000046:
case ENC_KEYPAD_BC_TBCD0x00000048:
case ENC_DECT_STANDARD_4BITS_TBCD0x00000058:
REPORT_DISSECTOR_BUG("Null-terminated strings are not supported for BCD encodings.")proto_report_dissector_bug("Null-terminated strings are not supported for BCD encodings."
);
break;

case ENC_3GPP_TS_23_038_7BITS_PACKED0x0000002C:
case ENC_3GPP_TS_23_038_7BITS_UNPACKED0x0000004C:
case ENC_ETSI_TS_102_221_ANNEX_A0x0000004E:
REPORT_DISSECTOR_BUG("TS 23.038 7bits has no null character and doesn't support null-terminated strings")proto_report_dissector_bug("TS 23.038 7bits has no null character and doesn't support null-terminated strings"
);
break;

case ENC_ASCII_7BITS0x00000034:
REPORT_DISSECTOR_BUG("tvb_get_stringz_enc function with ENC_ASCII_7BITS not implemented yet")proto_report_dissector_bug("tvb_get_stringz_enc function with ENC_ASCII_7BITS not implemented yet"
);
break;

case ENC_EBCDIC0x0000002E:
/*
 * "Common" EBCDIC, covering all characters with the
 * same code point in all Roman-alphabet EBCDIC code
 * pages.
 */
strptr = tvb_get_nonascii_unichar2_stringz(scope, tvb, offset, lengthp, charset_table_ebcdic);
break;

case ENC_EBCDIC_CP0370x00000038:
/*
 * EBCDIC code page 037.
 */
strptr = tvb_get_nonascii_unichar2_stringz(scope, tvb, offset, lengthp, charset_table_ebcdic_cp037);
break;

case ENC_EBCDIC_CP5000x00000060:
/*
 * EBCDIC code page 500.
 */
strptr = tvb_get_nonascii_unichar2_stringz(scope, tvb, offset, lengthp, charset_table_ebcdic_cp500);
break;

case ENC_T610x00000036:
strptr = tvb_get_t61_stringz(scope, tvb, offset, lengthp);
break;

case ENC_GB180300x00000050:
strptr = tvb_get_gb18030_stringz(scope, tvb, offset, lengthp);
break;

case ENC_EUC_KR0x00000052:
strptr = tvb_get_euc_kr_stringz(scope, tvb, offset, lengthp);
break;

case ENC_APN_STR0x00000054:
/* At least as defined in 3GPP TS 23.003 Clause 9.1, null-termination
 * does make sense as internal nulls are not allowed. */
REPORT_DISSECTOR_BUG("Null-terminated strings not implemented for ENC_APN_STR")proto_report_dissector_bug("Null-terminated strings not implemented for ENC_APN_STR"
);
break;

case ENC_DECT_STANDARD_8BITS0x00000056:
strptr = tvb_get_dect_standard_8bits_stringz(scope, tvb, offset, lengthp);
break;
}

return strptr;
4566}

4568/* Looks for a stringz (NUL-terminated string) in tvbuff and copies
* no more than bufsize number of bytes, including terminating NUL, to buffer.
* Returns length of string (not including terminating NUL).
* In this way, it acts like snprintf().
*
* bufsize MUST be greater than 0.
*
* This function does not otherwise throw an exception for running out of room
* in the buffer or running out of remaining bytes in the tvbuffer. It will
* copy as many bytes to the buffer as possible (the lesser of bufsize - 1
* and the number of remaining captured bytes) and then NUL terminate the
* string.
*
* *bytes_copied will contain the number of bytes actually copied,
* including the terminating-NUL if present in the frame, but not
* if it was supplied by the function instead of copied from packet data.
* [Not currently used, but could be used to determine how much to advance
* the offset.]
*/
4587static unsigned
4588_tvb_get_raw_bytes_as_stringz(tvbuff_t *tvb, const unsigned offset, const unsigned bufsize, uint8_t* buffer, unsigned *bytes_copied)
4589{
int	 exception;
int      stringlen;
unsigned limit;
unsigned len = 0;

/* Only read to end of tvbuff, w/o throwing exception. */
exception = validate_offset_and_remaining(tvb, offset, &len);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));

/* There must at least be room for the terminating NUL. */
DISSECTOR_ASSERT(bufsize != 0)((void) ((bufsize != 0) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 4601, "bufsize != 0"
))));

/* If there's no room for anything else, just return the NUL. */
if (bufsize == 1) {
buffer[0] = 0;
if (len && tvb_get_uint8(tvb, offset) == 0) {
	*bytes_copied = 1;
} else {
	*bytes_copied = 0;
}
return 0;
}

/* validate_offset_and_remaining() won't throw an exception if we're
* looking at the byte immediately after the end of the tvbuff. */
if (len == 0) {
THROW(ReportedBoundsError)except_throw(1, (3), ((void*)0));
}

if (len < bufsize) {
limit = len;
}
else {
limit = bufsize - 1;
}

stringlen = tvb_strnlen(tvb, offset, limit);
/* If NUL wasn't found, copy the data up to the limit and terminate */
if (stringlen == -1) {
tvb_memcpy(tvb, buffer, offset, limit);
buffer[limit] = 0;
*bytes_copied = limit;
return limit;
}

/* Copy the string to buffer */
tvb_memcpy(tvb, buffer, offset, stringlen + 1);
*bytes_copied = stringlen + 1;
return (unsigned)stringlen;
4640}

4642unsigned
4643tvb_get_raw_bytes_as_stringz(tvbuff_t *tvb, const unsigned offset, const unsigned bufsize, uint8_t* buffer)
4644{
unsigned bytes_copied;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 4647, "tvb && tvb->initialized"
))));

return _tvb_get_raw_bytes_as_stringz(tvb, offset, bufsize, buffer, &bytes_copied);
4650}

4652/*
* Given a tvbuff, an offset into the tvbuff, a buffer, and a buffer size,
* extract as many raw bytes from the tvbuff, starting at the offset,
* as 1) are available in the tvbuff and 2) will fit in the buffer, leaving
* room for a terminating NUL.
*/
4658unsigned
4659tvb_get_raw_bytes_as_string(tvbuff_t *tvb, const unsigned offset, char *buffer, size_t bufsize)
4660{
unsigned len = 0;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 4663, "tvb && tvb->initialized"
))));

/* There must be room for the string and the terminating NUL. */
DISSECTOR_ASSERT(bufsize > 0)((void) ((bufsize > 0) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 4666, "bufsize > 0"
))));

/* bufsize is size_t, but tvbuffers only have up to unsigned bytes */
DISSECTOR_ASSERT(bufsize - 1 < UINT_MAX)((void) ((bufsize - 1 < (2147483647 *2U +1U)) ? (void)0 : (
proto_report_dissector_bug("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c"
, 4669, "bufsize - 1 < (2147483647 *2U +1U)"))));

len = _tvb_captured_length_remaining(tvb, offset);
if (len == 0) {
buffer[0] = '\0';
return 0;
}
if (len > (bufsize - 1))
len = (unsigned)(bufsize - 1);

/* Copy the string to buffer */
tvb_memcpy(tvb, buffer, offset, len);
buffer[len] = '\0';
return len;
4683}

4685bool_Bool
4686tvb_ascii_isprint(tvbuff_t *tvb, const unsigned offset, const unsigned length)
4687{
DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 4688, "tvb && tvb->initialized"
))));

/* XXX - Perhaps this function should return false instead of throwing
* an exception. */
const uint8_t* buf = ensure_contiguous_unsigned(tvb, offset, length);

for (unsigned i = 0; i < length; i++, buf++)
if (!g_ascii_isprint(*buf)((g_ascii_table[(guchar) (*buf)] & G_ASCII_PRINT) != 0))
	return false0;

return true1;
4699}

4701bool_Bool
4702tvb_ascii_isprint_remaining(tvbuff_t *tvb, const unsigned offset)
4703{
int exception;
unsigned length;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 4707, "tvb && tvb->initialized"
))));

exception = validate_offset_and_remaining(tvb, offset, &length);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));

const uint8_t* buf = ensure_contiguous_unsigned(tvb, offset, length);

for (unsigned i = 0; i < length; i++, buf++)
if (!g_ascii_isprint(*buf)((g_ascii_table[(guchar) (*buf)] & G_ASCII_PRINT) != 0))
	return false0;

return true1;
4720}

4722bool_Bool
4723tvb_utf_8_isprint(tvbuff_t *tvb, const unsigned offset, const unsigned length)
4724{
DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 4725, "tvb && tvb->initialized"
))));

/* XXX - Perhaps this function should return false instead of throwing
* an exception. */
const uint8_t* buf = ensure_contiguous_unsigned(tvb, offset, length);

return isprint_utf8_string((const char*)buf, length);
4732}

4734bool_Bool
4735tvb_utf_8_isprint_remaining(tvbuff_t *tvb, const unsigned offset)
4736{
int exception;
unsigned length;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 4740, "tvb && tvb->initialized"
))));

exception = validate_offset_and_remaining(tvb, offset, &length);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));

const uint8_t* buf = ensure_contiguous_unsigned(tvb, offset, length);

return isprint_utf8_string((const char*)buf, length);
4749}

4751bool_Bool
4752tvb_ascii_isdigit(tvbuff_t *tvb, const unsigned offset, const unsigned length)
4753{
DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 4754, "tvb && tvb->initialized"
))));

/* XXX - Perhaps this function should return false instead of throwing
* an exception. */
const uint8_t* buf = ensure_contiguous_unsigned(tvb, offset, length);

for (unsigned i = 0; i < length; i++, buf++)
if (!g_ascii_isdigit(*buf)((g_ascii_table[(guchar) (*buf)] & G_ASCII_DIGIT) != 0))
	return false0;

return true1;
4765}

4767static ws_mempbrk_pattern pbrk_crlf;

4769static bool_Bool
4770_tvb_find_line_end_length(tvbuff_t *tvb, const unsigned offset, const unsigned limit, unsigned *linelen, unsigned *next_offset)
4771{
static bool_Bool compiled = false0;
unsigned eob_offset;
unsigned eol_offset;
unsigned char found_needle = 0;

if (!compiled) {
ws_mempbrk_compile(&pbrk_crlf, "\r\n");
compiled = true1;
}

eob_offset = offset + limit;

/*
* Look either for a CR or an LF.
*/
if (!_tvb_ws_mempbrk_uint8_length(tvb, offset, limit, &pbrk_crlf, &eol_offset, &found_needle)) {
/*
 * No CR or LF - line is presumably continued in next packet.
 */
/*
 * Pretend the line runs to the end of the tvbuff.
 */
if (linelen)
	*linelen = eob_offset - offset;
if (next_offset)
	*next_offset = eob_offset;
/*
 * Tell our caller we saw no EOL, so they can try to
 * desegment and get the entire line into one tvbuff.
 */
return false0;
} else {
/*
 * Find the number of bytes between the starting offset
 * and the CR or LF.
 */
if (linelen)
	*linelen = eol_offset - offset;

/*
 * Is it a CR?
 */
if (found_needle == '\r') {
	/*
	 * Yes - is it followed by an LF?
	 */
	if (eol_offset + 1 >= eob_offset) {
		/*
		 * Dunno - the next byte isn't in this
		 * tvbuff.
		 */
		if (next_offset)
			*next_offset = eob_offset;
		/*
		 * We'll return false, although that
		 * runs the risk that if the line
		 * really *is* terminated with a CR,
		 * we won't properly dissect this
		 * tvbuff.
		 *
		 * It's probably more likely that
		 * the line ends with CR-LF than
		 * that it ends with CR by itself.
		 *
		 * XXX - Return a third value?
		 */
		return false0;
	} else {
		/*
		 * Well, we can at least look at the next
		 * byte.
		 */
		if (tvb_get_uint8(tvb, eol_offset + 1) == '\n') {
			/*
			 * It's an LF; skip over the CR.
			 */
			eol_offset++;
		}
	}
}

/*
 * Return the offset of the character after the last
 * character in the line, skipping over the last character
 * in the line terminator.
 */
if (next_offset)
	*next_offset = eol_offset + 1;
}
return true1;
4862}

4864bool_Bool
4865tvb_find_line_end_remaining(tvbuff_t *tvb, const unsigned offset, unsigned *linelen, unsigned *next_offset)
4866{
unsigned limit;
int exception;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 4870, "tvb && tvb->initialized"
))));

exception = validate_offset_and_remaining(tvb, offset, &limit);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));

return _tvb_find_line_end_length(tvb, offset, limit, linelen, next_offset);
4877}

4879bool_Bool
4880tvb_find_line_end_length(tvbuff_t *tvb, const unsigned offset, const unsigned maxlength, unsigned *linelen, unsigned *next_offset)
4881{
unsigned limit;
int exception;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 4885, "tvb && tvb->initialized"
))));

exception = validate_offset_and_remaining(tvb, offset, &limit);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));

/* Only search to end of tvbuff, w/o throwing exception. */
if (limit > maxlength) {
/* Maximum length doesn't go past end of tvbuff; search
   to that value. */
limit = maxlength;
}

return _tvb_find_line_end_length(tvb, offset, limit, linelen, next_offset);
4899}

4901static ws_mempbrk_pattern pbrk_crlf_dquote;

4903static bool_Bool
4904_tvb_find_line_end_unquoted_length(tvbuff_t *tvb, const unsigned offset, unsigned limit, unsigned *linelen, unsigned *next_offset)
4905{
unsigned cur_offset, char_offset;
bool_Bool     is_quoted;
unsigned char   c = 0;
unsigned eob_offset;
static bool_Bool compiled = false0;
unsigned len;
bool_Bool	 found;

if (!compiled) {
ws_mempbrk_compile(&pbrk_crlf_dquote, "\r\n\"");
compiled = true1;
}

eob_offset = offset + limit;

cur_offset = offset;
is_quoted  = false0;
for (;;) {
len = limit - (cur_offset - offset);
/*
 * Is this part of the string quoted?
 */
if (is_quoted) {
	/*
	 * Yes - look only for the terminating quote.
	 */
	found = _tvb_find_uint8_length(tvb, cur_offset, len, '"', &char_offset);
} else {
	/*
	 * Look either for a CR, an LF, or a '"'.
	 */
	found = _tvb_ws_mempbrk_uint8_length(tvb, cur_offset, len, &pbrk_crlf_dquote, &char_offset, &c);
}
if (!found) {
	/*
	 * Not found - line is presumably continued in
	 * next packet.
	 * We pretend the line runs to the end of the tvbuff.
	 */
	if (linelen)
		*linelen = eob_offset - offset;
	if (next_offset)
		*next_offset = eob_offset;
	break;
}

if (is_quoted) {
	/*
	 * We're processing a quoted string.
	 * We only looked for ", so we know it's a ";
	 * as we're processing a quoted string, it's a
	 * closing quote.
	 */
	is_quoted = false0;
} else {
	/*
	 * OK, what is it?
	 */
	if (c == '"') {
		/*
		 * Un-quoted "; it begins a quoted
		 * string.
		 */
		is_quoted = true1;
	} else {
		/*
		 * It's a CR or LF; we've found a line
		 * terminator.
		 *
		 * Find the number of bytes between the
		 * starting offset and the CR or LF.
		 */
		if (linelen)
			*linelen = char_offset - offset;

		/*
		 * Is it a CR?
		 */
		if (c == '\r') {
			/*
			 * Yes; is it followed by an LF?
			 */
			if (char_offset + 1 < eob_offset &&
				tvb_get_uint8(tvb, char_offset + 1)
				  == '\n') {
				/*
				 * Yes; skip over the CR.
				 */
				char_offset++;
			}
		}

		/*
		 * Return the offset of the character after
		 * the last character in the line, skipping
		 * over the last character in the line
		 * terminator, and quit.
		 */
		if (next_offset)
			*next_offset = char_offset + 1;
		break;
	}
}

/*
 * Step past the character we found.
 */
cur_offset = char_offset + 1;
if (cur_offset >= eob_offset) {
	/*
	 * The character we found was the last character
	 * in the tvbuff - line is presumably continued in
	 * next packet.
	 * We pretend the line runs to the end of the tvbuff.
	 */
	if (linelen)
		*linelen = eob_offset - offset;
	if (next_offset)
		*next_offset = eob_offset;
	break;
}
}
return found;
5029}

5031/*
* Given a tvbuff, an offset into the tvbuff, and a length that starts
* at that offset (which may be -1 for "all the way to the end of the
* tvbuff"), find the end of the (putative) line that starts at the
* specified offset in the tvbuff, going no further than the specified
* length.
*
* However, treat quoted strings inside the buffer specially - don't
* treat newlines in quoted strings as line terminators.
*
* Return the length of the line (not counting the line terminator at
* the end), or the amount of data remaining in the buffer if we don't
* find a line terminator.
*
* If "next_offset" is not NULL, set "*next_offset" to the offset of the
* character past the line terminator, or past the end of the buffer if
* we don't find a line terminator.
*/
5049int
5050tvb_find_line_end_unquoted(tvbuff_t *tvb, const unsigned offset, int len, int *next_offset)
5051{
unsigned linelen;
unsigned abs_next_offset;
unsigned limit;
int exception;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 5057, "tvb && tvb->initialized"
))));

exception = validate_offset_and_remaining(tvb, offset, &limit);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));

/* Only search to end of tvbuff, w/o throwing exception. */
if (len >= 0 && limit > (unsigned) len) {
/* Maximum length doesn't go past end of tvbuff; search
   to that value. */
limit = (unsigned) len;
}

_tvb_find_line_end_unquoted_length(tvb, offset, limit, &linelen, &abs_next_offset);
if (next_offset) {
*next_offset = (int)abs_next_offset;
}
return (int)linelen;
5075}

5077bool_Bool
5078tvb_find_line_end_unquoted_remaining(tvbuff_t *tvb, const unsigned offset, unsigned *linelen, unsigned *next_offset)
5079{
unsigned limit;
int exception;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 5083, "tvb && tvb->initialized"
))));

exception = validate_offset_and_remaining(tvb, offset, &limit);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));

return _tvb_find_line_end_unquoted_length(tvb, offset, limit, linelen, next_offset);
5090}

5092bool_Bool
5093tvb_find_line_end_unquoted_length(tvbuff_t *tvb, const unsigned offset, const unsigned maxlength, unsigned *linelen, unsigned *next_offset)
5094{
unsigned limit;
int exception;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 5098, "tvb && tvb->initialized"
))));

exception = validate_offset_and_remaining(tvb, offset, &limit);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));

/* Only search to end of tvbuff, w/o throwing exception. */
if (limit > maxlength) {
/* Maximum length doesn't go past end of tvbuff; search
   to that value. */
limit = maxlength;
}

return _tvb_find_line_end_unquoted_length(tvb, offset, limit, linelen, next_offset);
5112}

5114/*
* Copied from the mgcp dissector. (This function should be moved to /epan )
* tvb_skip_wsp - Returns the position in tvb of the first non-whitespace
*				  character following offset or offset + maxlength -1 whichever
*				  is smaller.
*
* Parameters:
* tvb - The tvbuff in which we are skipping whitespace.
* offset - The offset in tvb from which we begin trying to skip whitespace.
* maxlength - The maximum distance from offset that we may try to skip
* whitespace.
*
* Returns: The position in tvb of the first non-whitespace
*			character following offset or offset + maxlength -1 whichever
*			is smaller.
*/
5130unsigned
5131tvb_skip_wsp(tvbuff_t *tvb, const unsigned offset, const unsigned maxlength)
5132{
unsigned counter;
unsigned end, tvb_len;
uint8_t  tempchar;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 5137, "tvb && tvb->initialized"
))));

/* Get the length remaining */
/*tvb_len = tvb_captured_length(tvb);*/
tvb_len = tvb->length;

if (ckd_add(&end, offset, maxlength)__builtin_add_overflow((offset), (maxlength), (&end)) || end > tvb_len) {
end = tvb_len;
}

/* Skip past spaces, tabs, CRs and LFs until run out or meet something else */
/* XXX - The MEGACO dissector uses g_ascii_isspace(), which might be
* slightly faster but also tests for vertical tab and form feed. */
for (counter = offset;
 counter < end &&
  ((tempchar = tvb_get_uint8(tvb,counter)) == ' ' ||
  tempchar == '\t' || tempchar == '\r' || tempchar == '\n');
 counter++);

return counter;
5157}

5159unsigned
5160tvb_skip_wsp_return(tvbuff_t *tvb, const unsigned offset)
5161{
unsigned counter;
uint8_t  tempchar;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 5165, "tvb && tvb->initialized"
))));

/* XXX - DISSECTOR_ASSERT(offset > 0) and then subtract 1 from offset?
* The way this is used the caller almost always wants to subtract one
* from the offset of a non WSP separator, and they might forget to do
* so and then this function return the offset past the separator. */

/* XXX - The MEGACO dissector uses g_ascii_isspace(), which might be
* slightly faster but also tests for vertical tab and form feed. */
for (counter = offset; counter > 0 &&
((tempchar = tvb_get_uint8(tvb,counter)) == ' ' ||
tempchar == '\t' || tempchar == '\n' || tempchar == '\r'); counter--);
counter++;

return counter;
5180}

5182unsigned
5183tvb_skip_uint8(tvbuff_t *tvb, unsigned offset, const unsigned maxlength, const uint8_t ch)
5184{
unsigned end, tvb_len;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 5187, "tvb && tvb->initialized"
))));

/* Get the length remaining */
/*tvb_len = tvb_captured_length(tvb);*/
tvb_len = tvb->length;

if (ckd_add(&end, offset, maxlength)__builtin_add_overflow((offset), (maxlength), (&end)) || end > tvb_len) {
end = tvb_len;
}

while (offset < end) {
uint8_t tempch = tvb_get_uint8(tvb, offset);

if (tempch != ch)
	break;
offset++;
}

return offset;
5206}

5208static ws_mempbrk_pattern pbrk_whitespace;

5210static bool_Bool
5211_tvb_get_token_len_length(tvbuff_t *tvb, const unsigned offset, unsigned limit, unsigned *tokenlen, unsigned *next_offset)
5212{
unsigned eot_offset;
unsigned char found_needle = 0;
static bool_Bool compiled = false0;

if (!compiled) {
ws_mempbrk_compile(&pbrk_whitespace, " \r\n");
compiled = true1;
}

/*
* Look either for a space, CR, or LF.
*/
if (!_tvb_ws_mempbrk_uint8_length(tvb, offset, limit, &pbrk_whitespace, &eot_offset, &found_needle)) {
/*
* No space, CR or LF - token is presumably continued in next packet.
*/
/*
* Pretend the token runs to the end of the tvbuff.
*/
if (tokenlen)
	*tokenlen = eot_offset - offset;
if (next_offset)
	*next_offset = eot_offset;
/*
* Tell our caller we saw no whitespace, so they can
* try to desegment and get the entire line
* into one tvbuff.
*/
return false0;
}

/*
* Find the number of bytes between the starting offset
* and the space, CR or LF.
*/
if (tokenlen)
*tokenlen = eot_offset - offset;

/*
* Return the offset of the character after the token delimiter,
* skipping over the last character in the separator.
*
* XXX - get_token_len() from strutil.h returns the start offset of
* the next token by skipping trailing spaces (but not spaces that
* follow a CR or LF, only consecutive spaces). Should we align
* the two functions? Most dissectors want to skip extra spaces,
* and while the dissector _can_ follow up with tvb_skip_wsp, this
* probably causes dissectors to use tvb_get_ptr + get_token_len,
* which we want to discourage. OTOH, IMAP, which uses this, says
* "in all cases, SP refers to exactly one space. It is NOT permitted
* to substitute TAB, insert additional spaces, or otherwise treat
* SP as being equivalent to linear whitespace (LWSP)."
* https://www.rfc-editor.org/rfc/rfc9051.html#name-formal-syntax
*
* XXX - skip over CR-LF as a unit like tvb_find_line_end()?
* get_token_len() doesn't, probably because most dissectors have
* already found the line end before, but it probably makes sense
* to do and unlike above it's unlikely it would break any protocol
* (and might even fix some.)
*/
if (next_offset)
*next_offset = eot_offset + 1;

return true1;
5277}

5279int tvb_get_token_len(tvbuff_t *tvb, const unsigned offset, int len, int *next_offset, const bool_Bool desegment)
5280{
unsigned tokenlen;
unsigned abs_next_offset;
unsigned limit;
int exception;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 5286, "tvb && tvb->initialized"
))));

exception = validate_offset_and_remaining(tvb, offset, &limit);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));

/* Only search to end of tvbuff, w/o throwing exception. */
if (len >= 0 && limit > (unsigned) len) {
/* Maximum length doesn't go past end of tvbuff; search
   to that value. */
limit = (unsigned) len;
}

if (!_tvb_get_token_len_length(tvb, offset, limit, &tokenlen, &abs_next_offset) && desegment) {
return -1;
}
if (next_offset) {
*next_offset = (int)abs_next_offset;
}
return (int)tokenlen;
5306}

5308bool_Bool
5309tvb_get_token_len_remaining(tvbuff_t *tvb, const unsigned offset, unsigned *tokenlen, unsigned *next_offset)
5310{
unsigned limit;
int exception;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 5314, "tvb && tvb->initialized"
))));

exception = validate_offset_and_remaining(tvb, offset, &limit);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));

return _tvb_get_token_len_length(tvb, offset, limit, tokenlen, next_offset);
5321}

5323bool_Bool
5324tvb_get_token_len_length(tvbuff_t *tvb, const unsigned offset, const unsigned maxlength, unsigned *tokenlen, unsigned *next_offset)
5325{
unsigned limit;
int exception;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 5329, "tvb && tvb->initialized"
))));

exception = validate_offset_and_remaining(tvb, offset, &limit);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));

/* Only search to end of tvbuff, w/o throwing exception. */
if (limit > maxlength) {
/* Maximum length doesn't go past end of tvbuff; search
   to that value. */
limit = maxlength;
}

return _tvb_get_token_len_length(tvb, offset, limit, tokenlen, next_offset);
5343}

5345/*
* Format a bunch of data from a tvbuff as bytes, returning a pointer
* to the string with the formatted data, with "punct" as a byte
* separator.
*/
5350char *
5351tvb_bytes_to_str_punct(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, const unsigned len, const char punct)
5352{
return bytes_to_str_punct(scope, ensure_contiguous_unsigned(tvb, offset, len), len, punct)bytes_to_str_punct_maxlen(scope, ensure_contiguous_unsigned(tvb
, offset, len), len, punct, 24);
5354}

5356/*
* Given a wmem scope, a tvbuff, an offset, a length, an input digit
* set, and a boolean indicator, fetch BCD-encoded digits from a
* tvbuff starting from either the low or high half byte of the
* first byte depending on the boolean indicator (true means "start
* with the high half byte, ignoring the low half byte", and false
* means "start with the low half byte and proceed to the high half
* byte), formating the digits into characters according to the
* input digit set, and return a pointer to a UTF-8 string, allocated
* using the wmem scope.  A nibble of 0xf is considered a 'filler'
* and will end the conversion. Similarly if odd is set the last
* high nibble will be omitted. (Note that if both skip_first and
* odd are true, then both the first and last semi-octet are skipped,
* i.e. an even number of nibbles are considered.)
*/
5371char *
5372tvb_get_bcd_string(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, unsigned len, const dgt_set_t *dgt, bool_Bool skip_first, bool_Bool odd, bool_Bool bigendian)
5373{
const uint8_t *ptr;
int           i = 0;
char         *digit_str;
uint8_t       octet, nibble;

DISSECTOR_ASSERT(tvb && tvb->initialized)((void) ((tvb && tvb->initialized) ? (void)0 : (proto_report_dissector_bug
("%s:%u: failed assertion \"%s\"", "epan/tvbuff.c", 5379, "tvb && tvb->initialized"
))));

ptr = ensure_contiguous_unsigned(tvb, offset, len);

/*
* XXX - map illegal digits (digits that map to 0) to REPLACEMENT
* CHARACTER, and have all the tables in epan/tvbuff.c use 0 rather
* than '?'?
*/
digit_str = (char *)wmem_alloc(scope, len*2 + 1);

while (len > 0) {
octet = *ptr;
if (!skip_first) {
	if (bigendian) {
		nibble = (octet >> 4) & 0x0f;
	} else {
		nibble = octet & 0x0f;
	}
	if (nibble == 0x0f) {
		/*
		 * Stop digit.
		 */
		break;
	}
	digit_str[i] = dgt->out[nibble];
	i++;
}
skip_first = false0;

/*
 * unpack second value in byte
 */
if (bigendian) {
	nibble = octet & 0x0f;
} else {
	nibble = octet >> 4;
}

if (nibble == 0x0f) {
	/*
	 * This is the stop digit or a filler digit.  Ignore
	 * it.
	 */
	break;
}
if ((len == 1) && (odd == true1 )){
	/* Last octet, skip last high nibble in case of odd number of digits */
	break;
}
digit_str[i] = dgt->out[nibble];
i++;

ptr++;
len--;
}
digit_str[i] = '\0';
return digit_str;
5437}

5439/* XXXX Fix me - needs odd indicator added (or just use of tvb_get_bcd_string / proto_tree_add_item) */
5440const char *
5441tvb_bcd_dig_to_str(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, const unsigned len, const dgt_set_t *dgt, bool_Bool skip_first)
5442{
if (!dgt)
dgt = &Dgt0_9_bcd;

return tvb_get_bcd_string(scope, tvb, offset, len, dgt, skip_first, false0, false0);
5447}

5449const char *
5450tvb_bcd_dig_to_str_be(wmem_allocator_t *scope, tvbuff_t *tvb, const unsigned offset, const unsigned len, const dgt_set_t *dgt, bool_Bool skip_first)
5451{
if (!dgt)
dgt = &Dgt0_9_bcd;

return tvb_get_bcd_string(scope, tvb, offset, len, dgt, skip_first, false0, true1);
5456}

5458/*
* Format a bunch of data from a tvbuff as bytes, returning a pointer
* to the string with the formatted data.
*/
5462char *
5463tvb_bytes_to_str(wmem_allocator_t *allocator, tvbuff_t *tvb, const unsigned offset, const unsigned len)
5464{
return bytes_to_str(allocator, ensure_contiguous_unsigned(tvb, offset, len), len)bytes_to_str_maxlen(allocator, ensure_contiguous_unsigned(tvb
, offset, len), len, 36);
5466}

5468/* Find a needle tvbuff within a haystack tvbuff. */
5469int
5470tvb_find_tvb(tvbuff_t *haystack_tvb, tvbuff_t *needle_tvb, const int haystack_offset)
5471{
unsigned	      haystack_abs_offset = 0, haystack_abs_length = 0;
const uint8_t *haystack_data;
const uint8_t *needle_data;
const unsigned   needle_len = needle_tvb->length;
const uint8_t *location;

DISSECTOR_ASSERT(haystack_tvb && haystack_tvb->initialized)((void) ((haystack_tvb && haystack_tvb->initialized
) ? (void)0 : (proto_report_dissector_bug("%s:%u: failed assertion \"%s\""
, "epan/tvbuff.c", 5478, "haystack_tvb && haystack_tvb->initialized"
))));

if (haystack_tvb->length < 1 || needle_tvb->length < 1) {
return -1;
}

/* Get pointers to the tvbuffs' data. */
haystack_data = ensure_contiguous(haystack_tvb, 0, -1);
needle_data   = ensure_contiguous(needle_tvb, 0, -1);

check_offset_length(haystack_tvb, haystack_offset, -1,
	&haystack_abs_offset, &haystack_abs_length);

location = ws_memmem(haystack_data + haystack_abs_offset, haystack_abs_length,
	needle_data, needle_len);

if (location) {
return (int) (location - haystack_data);
}

return -1;
5499}

5501/* Find a needle tvbuff within a haystack tvbuff. */
5502bool_Bool
5503tvb_find_tvb_remaining(tvbuff_t *haystack_tvb, tvbuff_t *needle_tvb, const unsigned haystack_offset, unsigned *found_offset)
5504{
const uint8_t *haystack_data;
const uint8_t *needle_data;
const unsigned   needle_len = needle_tvb->length;
const uint8_t *location;
int exception;
unsigned haystack_rem_length;

DISSECTOR_ASSERT(haystack_tvb && haystack_tvb->initialized)((void) ((haystack_tvb && haystack_tvb->initialized
) ? (void)0 : (proto_report_dissector_bug("%s:%u: failed assertion \"%s\""
, "epan/tvbuff.c", 5512, "haystack_tvb && haystack_tvb->initialized"
))));
DISSECTOR_ASSERT(needle_tvb && needle_tvb->initialized)((void) ((needle_tvb && needle_tvb->initialized) ?
 (void)0 : (proto_report_dissector_bug("%s:%u: failed assertion \"%s\""
, "epan/tvbuff.c", 5513, "needle_tvb && needle_tvb->initialized"
))));

if (haystack_tvb->length < 1 || needle_tvb->length < 1) {
return false0;
}

exception = validate_offset_and_remaining(haystack_tvb, haystack_offset, &haystack_rem_length);
if (exception)
THROW(exception)except_throw(1, (exception), ((void*)0));

/* Get pointers to the tvbuffs' data. */
haystack_data = ensure_contiguous_unsigned(haystack_tvb, haystack_offset, haystack_rem_length);
needle_data   = ensure_contiguous_unsigned(needle_tvb, 0, needle_len);

location = ws_memmem(haystack_data, haystack_rem_length,
	needle_data, needle_len);

if (location) {
if (found_offset)
	*found_offset = (unsigned) (location - haystack_data) + haystack_offset;
return true1;
}

return false0;
5537}

5539unsigned
5540tvb_raw_offset(tvbuff_t *tvb)
5541{
if (!(tvb->flags & TVBUFF_RAW_OFFSET0x00000002)) {
tvb->raw_offset = tvb_offset_from_real_beginning(tvb);
tvb->flags |= TVBUFF_RAW_OFFSET0x00000002;
}
return tvb->raw_offset;
5547}

5549void
5550tvb_set_fragment(tvbuff_t *tvb)
5551{
tvb->flags |= TVBUFF_FRAGMENT0x00000001;
5553}

5555struct tvbuff *
5556tvb_get_ds_tvb(tvbuff_t *tvb)
5557{
return(tvb->ds_tvb);
5559}

5561unsigned
5562tvb_get_varint(tvbuff_t *tvb, unsigned offset, unsigned maxlen, uint64_t *value, const unsigned encoding)
5563{
*value = 0;

switch (encoding & ENC_VARINT_MASK(0x00000002|0x00000004|0x00000008|0x00000010)) {
case ENC_VARINT_PROTOBUF0x00000002:
{
unsigned i;
uint64_t b; /* current byte */

for (i = 0; ((i < FT_VARINT_MAX_LEN10) && (i < maxlen)); ++i) {
	b = tvb_get_uint8(tvb, offset++);
	*value |= ((b & 0x7F) << (i * 7)); /* add lower 7 bits to val */

	if (b < 0x80) {
		/* end successfully because of last byte's msb(most significant bit) is zero */
		return i + 1;
	}
}
break;
}

case ENC_VARINT_ZIGZAG0x00000008:
{
unsigned i;
uint64_t b; /* current byte */

for (i = 0; ((i < FT_VARINT_MAX_LEN10) && (i < maxlen)); ++i) {
	b = tvb_get_uint8(tvb, offset++);
	*value |= ((b & 0x7F) << (i * 7)); /* add lower 7 bits to val */

	if (b < 0x80) {
		/* end successfully because of last byte's msb(most significant bit) is zero */
		*value = (*value >> 1) ^ ((*value & 1) ? -1 : 0);
		return i + 1;
	}
}
break;
}

case ENC_VARINT_SDNV0x00000010:
{
/* Decodes similar to protobuf but in MSByte order */
unsigned i;
uint64_t b; /* current byte */

for (i = 0; ((i < FT_VARINT_MAX_LEN10) && (i < maxlen)); ++i) {
	b = tvb_get_uint8(tvb, offset++);
	if ((i == 9) && (*value >= UINT64_C(1)1UL<<(64-7))) {
		// guaranteed overflow, not valid SDNV
		return 0;
	}
	*value <<= 7;
	*value |= (b & 0x7F); /* add lower 7 bits to val */

	if (b < 0x80) {
		/* end successfully because of last byte's msb(most significant bit) is zero */
		return i + 1;
	}
}
break;
}

case ENC_VARINT_QUIC0x00000004:
{
/* calculate variable length */
*value = tvb_get_uint8(tvb, offset);
switch((*value) >> 6) {
case 0: /* 0b00 => 1 byte length (6 bits Usable) */
	(*value) &= 0x3F;
	return 1;
case 1: /* 0b01 => 2 bytes length (14 bits Usable) */
	*value = tvb_get_ntohs(tvb, offset) & 0x3FFF;
	return 2;
case 2: /* 0b10 => 4 bytes length (30 bits Usable) */
	*value = tvb_get_ntohl(tvb, offset) & 0x3FFFFFFF;
	return 4;
case 3: /* 0b11 => 8 bytes length (62 bits Usable) */
	*value = tvb_get_ntoh64(tvb, offset) & UINT64_C(0x3FFFFFFFFFFFFFFF)0x3FFFFFFFFFFFFFFFUL;
	return 8;
default: /* No Possible */
	ws_assert_not_reached()ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/tvbuff.c", 5643,
 __func__, "assertion \"not reached\" failed");
	break;
}
break;
}

default:
DISSECTOR_ASSERT_NOT_REACHED()(proto_report_dissector_bug("%s:%u: failed assertion \"DISSECTOR_ASSERT_NOT_REACHED\""
, "epan/tvbuff.c", 5650));
}

// We have scanned 10 bytes, but no bytes' msb is zero. We should probably
// return a nonzero value instead since we might be incrementing an offset
// inside a loop.
return 0;
5657}

5659/*
* Editor modelines  -  https://www.wireshark.org/tools/modelines.html
*
* Local variables:
* c-basic-offset: 8
* tab-width: 8
* indent-tabs-mode: t
* End:
*
* vi: set shiftwidth=8 tabstop=8 noexpandtab:
* :indentSize=8:tabSize=8:noTabs=false:
*/