/* tvbuff.c * * Testy, Virtual(-izable) Buffer of guint8*'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 * * 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 * Copyright 1998 Gerald Combs * * SPDX-License-Identifier: GPL-2.0-or-later */ #include "config.h" #include #include #include #include #include "wsutil/pint.h" #include "wsutil/sign_ext.h" #include "wsutil/strtoi.h" #include "wsutil/unicode-utils.h" #include "wsutil/nstime.h" #include "wsutil/time_util.h" #include #include "tvbuff.h" #include "tvbuff-int.h" #include "strutil.h" #include "to_str.h" #include "charsets.h" #include "proto.h" /* XXX - only used for DISSECTOR_ASSERT, probably a new header file? */ #include "exceptions.h" #include static guint64 _tvb_get_bits64(tvbuff_t *tvb, guint bit_offset, const gint total_no_of_bits); static guint64 _tvb_get_bits64_le(tvbuff_t *tvb, guint bit_offset, const gint total_no_of_bits); static inline gint _tvb_captured_length_remaining(const tvbuff_t *tvb, const gint offset); static inline const guint8* ensure_contiguous(tvbuff_t *tvb, const gint offset, const gint length); static inline guint8 * tvb_get_raw_string(wmem_allocator_t *scope, tvbuff_t *tvb, const gint offset, const gint length); tvbuff_t * tvb_new(const struct tvb_ops *ops) { tvbuff_t *tvb; gsize size = ops->tvb_size; ws_assert(size >= sizeof(*tvb)); tvb = (tvbuff_t *) g_slice_alloc(size); tvb->next = NULL; tvb->ops = ops; tvb->initialized = FALSE; tvb->flags = 0; tvb->length = 0; tvb->reported_length = 0; tvb->contained_length = 0; tvb->real_data = NULL; tvb->raw_offset = -1; tvb->ds_tvb = NULL; return tvb; } static void tvb_free_internal(tvbuff_t *tvb) { gsize size; DISSECTOR_ASSERT(tvb); if (tvb->ops->tvb_free) tvb->ops->tvb_free(tvb); size = tvb->ops->tvb_size; g_slice_free1(size, tvb); } /* 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 beeen * calls to tvb_free_chain() although the calls were OK as long as no * subsets, etc had been created on the tvb. */ void tvb_free(tvbuff_t *tvb) { tvb_free_chain(tvb); } void tvb_free_chain(tvbuff_t *tvb) { tvbuff_t *next_tvb; DISSECTOR_ASSERT(tvb); while (tvb) { next_tvb = tvb->next; tvb_free_internal(tvb); tvb = next_tvb; } } tvbuff_t * tvb_new_chain(tvbuff_t *parent, tvbuff_t *backing) { tvbuff_t *tvb = tvb_new_proxy(backing); tvb_add_to_chain(parent, tvb); return tvb; } void tvb_add_to_chain(tvbuff_t *parent, tvbuff_t *child) { tvbuff_t *tmp; DISSECTOR_ASSERT(parent); DISSECTOR_ASSERT(child); while (child) { tmp = child; child = child->next; tmp->next = parent->next; parent->next = tmp; } } /* * Check whether that offset goes more than one byte past the * end of the buffer. * * If not, return 0; otherwise, return exception */ static inline int validate_offset(const tvbuff_t *tvb, const guint abs_offset) { if (G_LIKELY(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 BoundsError; } /* * There's some actual packet boundary, not just the * artificial boundary imposed by packet slicing, that * we're past. */ if (tvb->flags & TVBUFF_FRAGMENT) { /* * 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 FragmentBoundsError; } /* 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 ContainedBoundsError; } /* * OK, it looks as if we ran past the claimed length * of data. */ return ReportedBoundsError; } static inline int compute_offset(const tvbuff_t *tvb, const gint offset, guint *offset_ptr) { if (offset >= 0) { /* Positive offset - relative to the beginning of the packet. */ if (G_LIKELY((guint) offset <= tvb->length)) { *offset_ptr = offset; } else if ((guint) offset <= tvb->contained_length) { return BoundsError; } else if (tvb->flags & TVBUFF_FRAGMENT) { return FragmentBoundsError; } else if ((guint) offset <= tvb->reported_length) { return ContainedBoundsError; } else { return ReportedBoundsError; } } else { /* Negative offset - relative to the end of the packet. */ if (G_LIKELY((guint) -offset <= tvb->length)) { *offset_ptr = tvb->length + offset; } else if ((guint) -offset <= tvb->contained_length) { return BoundsError; } else if (tvb->flags & TVBUFF_FRAGMENT) { return FragmentBoundsError; } else if ((guint) -offset <= tvb->reported_length) { return ContainedBoundsError; } else { return ReportedBoundsError; } } return 0; } static inline int compute_offset_and_remaining(const tvbuff_t *tvb, const gint offset, guint *offset_ptr, guint *rem_len) { int exception; exception = compute_offset(tvb, offset, offset_ptr); if (!exception) *rem_len = tvb->length - *offset_ptr; return exception; } /* 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. */ static inline int check_offset_length_no_exception(const tvbuff_t *tvb, const gint offset, gint const length_val, guint *offset_ptr, guint *length_ptr) { guint end_offset; int exception; DISSECTOR_ASSERT(offset_ptr); DISSECTOR_ASSERT(length_ptr); /* Compute the offset */ exception = compute_offset(tvb, offset, offset_ptr); if (exception) return exception; if (length_val < -1) { /* XXX - ReportedBoundsError? */ return BoundsError; } /* 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 BoundsError; return validate_offset(tvb, end_offset); } /* Checks (+/-) offset and length and throws an exception if * either is out of bounds. Sets integer ptrs to the new offset * and length. */ static inline void check_offset_length(const tvbuff_t *tvb, const gint offset, gint const length_val, guint *offset_ptr, guint *length_ptr) { int exception; exception = check_offset_length_no_exception(tvb, offset, length_val, offset_ptr, length_ptr); if (exception) THROW(exception); } void tvb_check_offset_length(const tvbuff_t *tvb, const gint offset, gint const length_val, guint *offset_ptr, guint *length_ptr) { check_offset_length(tvb, offset, length_val, offset_ptr, length_ptr); } static const unsigned char left_aligned_bitmask[] = { 0xff, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe }; tvbuff_t * tvb_new_octet_aligned(tvbuff_t *tvb, guint32 bit_offset, gint32 no_of_bits) { tvbuff_t *sub_tvb = NULL; guint32 byte_offset; gint32 datalen, i; guint8 left, right, remaining_bits, *buf; const guint8 *data; DISSECTOR_ASSERT(tvb && tvb->initialized); byte_offset = bit_offset >> 3; left = bit_offset % 8; /* for left-shifting */ right = 8 - left; /* for right-shifting */ if (no_of_bits == -1) { datalen = _tvb_captured_length_remaining(tvb, byte_offset); remaining_bits = 0; } else { datalen = no_of_bits >> 3; remaining_bits = no_of_bits % 8; if (remaining_bits) { datalen++; } } /* already aligned -> shortcut */ if ((left == 0) && (remaining_bits == 0)) { return tvb_new_subset_length_caplen(tvb, byte_offset, datalen, datalen); } DISSECTOR_ASSERT(datalen>0); /* 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 non extra byte is available, the last shifted byte requires * special treatment */ if (_tvb_captured_length_remaining(tvb, byte_offset) > datalen) { data = ensure_contiguous(tvb, byte_offset, datalen + 1); /* tvb_get_ptr */ /* Do this allocation AFTER tvb_get_ptr() (which could throw an exception) */ buf = (guint8 *)g_malloc(datalen); /* shift tvb data bit_offset bits to the left */ for (i = 0; i < datalen; i++) buf[i] = (data[i] << left) | (data[i+1] >> right); } else { data = ensure_contiguous(tvb, byte_offset, datalen); /* tvb_get_ptr() */ /* Do this allocation AFTER tvb_get_ptr() (which could throw an exception) */ buf = (guint8 *)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); tvb_set_free_cb(sub_tvb, g_free); return sub_tvb; } tvbuff_t * tvb_new_octet_right_aligned(tvbuff_t *tvb, guint32 bit_offset, gint32 no_of_bits) { tvbuff_t *sub_tvb = NULL; guint32 byte_offset; gint src_len, dst_len, i; guint8 left, right, remaining_bits, *buf; const guint8 *data; DISSECTOR_ASSERT(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; if (no_of_bits == -1) { dst_len = _tvb_captured_length_remaining(tvb, byte_offset); remaining_bits = 0; } else { 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)) { return tvb_new_subset_length_caplen(tvb, byte_offset, dst_len, dst_len); } DISSECTOR_ASSERT(dst_len>0); 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(tvb, byte_offset, src_len); /* tvb_get_ptr */ /* Do this allocation AFTER tvb_get_ptr() (which could throw an exception) */ buf = (guint8 *)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; } static tvbuff_t * tvb_generic_clone_offset_len(tvbuff_t *tvb, guint offset, guint len) { tvbuff_t *cloned_tvb; guint8 *data; DISSECTOR_ASSERT(tvb_bytes_exist(tvb, offset, len)); data = (guint8 *) 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; } tvbuff_t * tvb_clone_offset_len(tvbuff_t *tvb, guint offset, guint len) { 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); } tvbuff_t * tvb_clone(tvbuff_t *tvb) { return tvb_clone_offset_len(tvb, 0, tvb->length); } guint tvb_captured_length(const tvbuff_t *tvb) { DISSECTOR_ASSERT(tvb && tvb->initialized); return tvb->length; } /* For tvbuff internal use */ static inline gint _tvb_captured_length_remaining(const tvbuff_t *tvb, const gint offset) { guint abs_offset = 0, rem_length; int exception; exception = compute_offset_and_remaining(tvb, offset, &abs_offset, &rem_length); if (exception) return 0; return rem_length; } gint tvb_captured_length_remaining(const tvbuff_t *tvb, const gint offset) { guint abs_offset = 0, rem_length; int exception; DISSECTOR_ASSERT(tvb && tvb->initialized); exception = compute_offset_and_remaining(tvb, offset, &abs_offset, &rem_length); if (exception) return 0; return rem_length; } guint tvb_ensure_captured_length_remaining(const tvbuff_t *tvb, const gint offset) { guint abs_offset = 0, rem_length = 0; int exception; DISSECTOR_ASSERT(tvb && tvb->initialized); exception = compute_offset_and_remaining(tvb, offset, &abs_offset, &rem_length); if (exception) THROW(exception); 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 (abs_offset < tvb->contained_length) { THROW(BoundsError); } else if (tvb->flags & TVBUFF_FRAGMENT) { THROW(FragmentBoundsError); } else if (abs_offset < tvb->reported_length) { THROW(ContainedBoundsError); } else { THROW(ReportedBoundsError); } } return rem_length; } /* Validates that 'length' bytes are available starting from * offset (pos/neg). Does not throw an exception. */ gboolean tvb_bytes_exist(const tvbuff_t *tvb, const gint offset, const gint length) { guint abs_offset = 0, abs_length; int exception; DISSECTOR_ASSERT(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 FALSE; exception = check_offset_length_no_exception(tvb, offset, length, &abs_offset, &abs_length); if (exception) return FALSE; return TRUE; } /* 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. */ void tvb_ensure_bytes_exist64(const tvbuff_t *tvb, const gint offset, const guint64 length) { /* * Make sure the value fits in a signed integer; if not, assume * that means that it's too big. */ if (length > G_MAXINT) { THROW(ReportedBoundsError); } /* OK, now cast it and try it with tvb_ensure_bytes_exist(). */ tvb_ensure_bytes_exist(tvb, offset, (gint)length); } /* Validates that 'length' bytes are available starting from * offset (pos/neg). Throws an exception if they aren't. */ void tvb_ensure_bytes_exist(const tvbuff_t *tvb, const gint offset, const gint length) { guint real_offset, end_offset; DISSECTOR_ASSERT(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); } /* XXX: Below this point could be replaced with a call to * check_offset_length with no functional change, however this is a * *very* hot path and check_offset_length is not well-optimized for * this case, so we eat some code duplication for a lot of speedup. */ if (offset >= 0) { /* Positive offset - relative to the beginning of the packet. */ if (G_LIKELY((guint) offset <= tvb->length)) { real_offset = offset; } else if ((guint) offset <= tvb->contained_length) { THROW(BoundsError); } else if (tvb->flags & TVBUFF_FRAGMENT) { THROW(FragmentBoundsError); } else if ((guint) offset <= tvb->reported_length) { THROW(ContainedBoundsError); } else { THROW(ReportedBoundsError); } } else { /* Negative offset - relative to the end of the packet. */ if (G_LIKELY((guint) -offset <= tvb->length)) { real_offset = tvb->length + offset; } else if ((guint) -offset <= tvb->contained_length) { THROW(BoundsError); } else if (tvb->flags & TVBUFF_FRAGMENT) { THROW(FragmentBoundsError); } else if ((guint) -offset <= tvb->reported_length) { THROW(ContainedBoundsError); } else { THROW(ReportedBoundsError); } } /* * Compute the offset of the first byte past the length. */ end_offset = real_offset + length; /* * Check for an overflow */ if (end_offset < real_offset) THROW(BoundsError); if (G_LIKELY(end_offset <= tvb->length)) return; else if (end_offset <= tvb->contained_length) THROW(BoundsError); else if (tvb->flags & TVBUFF_FRAGMENT) THROW(FragmentBoundsError); else if (end_offset <= tvb->reported_length) THROW(ContainedBoundsError); else THROW(ReportedBoundsError); } gboolean tvb_offset_exists(const tvbuff_t *tvb, const gint offset) { guint abs_offset = 0; int exception; DISSECTOR_ASSERT(tvb && tvb->initialized); exception = compute_offset(tvb, offset, &abs_offset); if (exception) return FALSE; /* compute_offset only throws an exception on >, not >= because of the * comment above check_offset_length_no_exception, but here we want the * opposite behaviour so we check ourselves... */ if (abs_offset < tvb->length) { return TRUE; } else { return FALSE; } } guint tvb_reported_length(const tvbuff_t *tvb) { DISSECTOR_ASSERT(tvb && tvb->initialized); return tvb->reported_length; } gint tvb_reported_length_remaining(const tvbuff_t *tvb, const gint offset) { guint abs_offset = 0; int exception; DISSECTOR_ASSERT(tvb && tvb->initialized); exception = compute_offset(tvb, offset, &abs_offset); if (exception) return 0; if (tvb->reported_length >= abs_offset) return tvb->reported_length - abs_offset; else return 0; } guint tvb_ensure_reported_length_remaining(const tvbuff_t *tvb, const gint offset) { guint abs_offset = 0; int exception; DISSECTOR_ASSERT(tvb && tvb->initialized); exception = compute_offset(tvb, offset, &abs_offset); if (exception) THROW(exception); if (tvb->reported_length >= abs_offset) return tvb->reported_length - abs_offset; else THROW(ReportedBoundsError); } /* 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. */ void tvb_set_reported_length(tvbuff_t *tvb, const guint reported_length) { DISSECTOR_ASSERT(tvb && tvb->initialized); if (reported_length > tvb->reported_length) THROW(ReportedBoundsError); 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; } /* 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. */ void tvb_fix_reported_length(tvbuff_t *tvb) { DISSECTOR_ASSERT(tvb && tvb->initialized); DISSECTOR_ASSERT(tvb->reported_length < tvb->length); tvb->reported_length = tvb->length; if (tvb->contained_length < tvb->length) tvb->contained_length = tvb->length; } guint tvb_offset_from_real_beginning_counter(const tvbuff_t *tvb, const guint counter) { if (tvb->ops->tvb_offset) return tvb->ops->tvb_offset(tvb, counter); DISSECTOR_ASSERT_NOT_REACHED(); return 0; } guint tvb_offset_from_real_beginning(const tvbuff_t *tvb) { return tvb_offset_from_real_beginning_counter(tvb, 0); } static inline const guint8* ensure_contiguous_no_exception(tvbuff_t *tvb, const gint offset, const gint length, int *pexception) { guint 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; } /* * 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; } /* * 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(); return NULL; } static inline const guint8* ensure_contiguous(tvbuff_t *tvb, const gint offset, const gint length) { int exception = 0; const guint8 *p; p = ensure_contiguous_no_exception(tvb, offset, length, &exception); if (p == NULL && length != 0) { DISSECTOR_ASSERT(exception > 0); THROW(exception); } return p; } static inline const guint8* fast_ensure_contiguous(tvbuff_t *tvb, const gint offset, const guint length) { guint end_offset; guint u_offset; DISSECTOR_ASSERT(tvb && tvb->initialized); /* We don't check for overflow in this fast path so we only handle simple types */ DISSECTOR_ASSERT(length <= 8); if (offset < 0 || !tvb->real_data) { return ensure_contiguous(tvb, offset, length); } u_offset = offset; end_offset = u_offset + length; if (G_LIKELY(end_offset <= tvb->length)) { return tvb->real_data + u_offset; } else if (end_offset <= tvb->contained_length) { THROW(BoundsError); } else if (tvb->flags & TVBUFF_FRAGMENT) { THROW(FragmentBoundsError); } else if (end_offset <= tvb->reported_length) { THROW(ContainedBoundsError); } else { THROW(ReportedBoundsError); } /* not reached */ return NULL; } /************** ACCESSORS **************/ void * tvb_memcpy(tvbuff_t *tvb, void *target, const gint offset, size_t length) { guint abs_offset = 0, abs_length = 0; DISSECTOR_ASSERT(tvb && tvb->initialized); /* * XXX - we should eliminate the "length = -1 means 'to the end * of the tvbuff'" convention, and use other means to achieve * that; this would let us eliminate a bunch of checks for * negative lengths in cases where the protocol has a 32-bit * length field. * * Allowing -1 but throwing an assertion on other negative * lengths is a bit more work with the length being a size_t; * instead, we check for a length <= 2^31-1. */ DISSECTOR_ASSERT(length <= 0x7FFFFFFF); check_offset_length(tvb, offset, (gint) length, &abs_offset, &abs_length); if (target && tvb->real_data) { return memcpy(target, tvb->real_data + abs_offset, abs_length); } if (target && tvb->ops->tvb_memcpy) return tvb->ops->tvb_memcpy(tvb, target, abs_offset, abs_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(); } return NULL; } /* * XXX - this doesn't treat a length of -1 as an error. * If it did, this could replace some code that calls * "tvb_ensure_bytes_exist()" and then allocates a buffer and copies * data to it. * * "composite_get_ptr()" depends on -1 not being * an error; does anything else depend on this routine treating -1 as * meaning "to the end of the buffer"? * * 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. */ void * tvb_memdup(wmem_allocator_t *scope, tvbuff_t *tvb, const gint offset, size_t length) { guint abs_offset = 0, abs_length = 0; void *duped; DISSECTOR_ASSERT(tvb && tvb->initialized); check_offset_length(tvb, offset, (gint) length, &abs_offset, &abs_length); if (abs_length == 0) return NULL; duped = wmem_alloc(scope, abs_length); return tvb_memcpy(tvb, duped, abs_offset, abs_length); } const guint8* tvb_get_ptr(tvbuff_t *tvb, const gint offset, const gint length) { return ensure_contiguous(tvb, offset, length); } /* ---------------- */ guint8 tvb_get_guint8(tvbuff_t *tvb, const gint offset) { const guint8 *ptr; ptr = fast_ensure_contiguous(tvb, offset, 1); return *ptr; } gint8 tvb_get_gint8(tvbuff_t *tvb, const gint offset) { const guint8 *ptr; ptr = fast_ensure_contiguous(tvb, offset, 1); return *ptr; } guint16 tvb_get_ntohs(tvbuff_t *tvb, const gint offset) { const guint8 *ptr; ptr = fast_ensure_contiguous(tvb, offset, 2); return pntoh16(ptr); } gint16 tvb_get_ntohis(tvbuff_t *tvb, const gint offset) { const guint8 *ptr; ptr = fast_ensure_contiguous(tvb, offset, 2); return pntoh16(ptr); } guint32 tvb_get_ntoh24(tvbuff_t *tvb, const gint offset) { const guint8 *ptr; ptr = fast_ensure_contiguous(tvb, offset, 3); return pntoh24(ptr); } gint32 tvb_get_ntohi24(tvbuff_t *tvb, const gint offset) { guint32 ret; ret = ws_sign_ext32(tvb_get_ntoh24(tvb, offset), 24); return (gint32)ret; } guint32 tvb_get_ntohl(tvbuff_t *tvb, const gint offset) { const guint8 *ptr; ptr = fast_ensure_contiguous(tvb, offset, 4); return pntoh32(ptr); } gint32 tvb_get_ntohil(tvbuff_t *tvb, const gint offset) { const guint8 *ptr; ptr = fast_ensure_contiguous(tvb, offset, 4); return pntoh32(ptr); } guint64 tvb_get_ntoh40(tvbuff_t *tvb, const gint offset) { const guint8 *ptr; ptr = fast_ensure_contiguous(tvb, offset, 5); return pntoh40(ptr); } gint64 tvb_get_ntohi40(tvbuff_t *tvb, const gint offset) { guint64 ret; ret = ws_sign_ext64(tvb_get_ntoh40(tvb, offset), 40); return (gint64)ret; } guint64 tvb_get_ntoh48(tvbuff_t *tvb, const gint offset) { const guint8 *ptr; ptr = fast_ensure_contiguous(tvb, offset, 6); return pntoh48(ptr); } gint64 tvb_get_ntohi48(tvbuff_t *tvb, const gint offset) { guint64 ret; ret = ws_sign_ext64(tvb_get_ntoh48(tvb, offset), 48); return (gint64)ret; } guint64 tvb_get_ntoh56(tvbuff_t *tvb, const gint offset) { const guint8 *ptr; ptr = fast_ensure_contiguous(tvb, offset, 7); return pntoh56(ptr); } gint64 tvb_get_ntohi56(tvbuff_t *tvb, const gint offset) { guint64 ret; ret = ws_sign_ext64(tvb_get_ntoh56(tvb, offset), 56); return (gint64)ret; } guint64 tvb_get_ntoh64(tvbuff_t *tvb, const gint offset) { const guint8 *ptr; ptr = fast_ensure_contiguous(tvb, offset, 8); return pntoh64(ptr); } gint64 tvb_get_ntohi64(tvbuff_t *tvb, const gint offset) { const guint8 *ptr; ptr = fast_ensure_contiguous(tvb, offset, 8); return pntoh64(ptr); } guint16 tvb_get_guint16(tvbuff_t *tvb, const gint offset, const guint encoding) { if (encoding & ENC_LITTLE_ENDIAN) { return tvb_get_letohs(tvb, offset); } else { return tvb_get_ntohs(tvb, offset); } } gint16 tvb_get_gint16(tvbuff_t *tvb, const gint offset, const guint encoding) { if (encoding & ENC_LITTLE_ENDIAN) { return tvb_get_letohis(tvb, offset); } else { return tvb_get_ntohis(tvb, offset); } } guint32 tvb_get_guint24(tvbuff_t *tvb, const gint offset, const guint encoding) { if (encoding & ENC_LITTLE_ENDIAN) { return tvb_get_letoh24(tvb, offset); } else { return tvb_get_ntoh24(tvb, offset); } } gint32 tvb_get_gint24(tvbuff_t *tvb, const gint offset, const guint encoding) { if (encoding & ENC_LITTLE_ENDIAN) { return tvb_get_letohi24(tvb, offset); } else { return tvb_get_ntohi24(tvb, offset); } } guint32 tvb_get_guint32(tvbuff_t *tvb, const gint offset, const guint encoding) { if (encoding & ENC_LITTLE_ENDIAN) { return tvb_get_letohl(tvb, offset); } else { return tvb_get_ntohl(tvb, offset); } } gint32 tvb_get_gint32(tvbuff_t *tvb, const gint offset, const guint encoding) { if (encoding & ENC_LITTLE_ENDIAN) { return tvb_get_letohil(tvb, offset); } else { return tvb_get_ntohil(tvb, offset); } } guint64 tvb_get_guint40(tvbuff_t *tvb, const gint offset, const guint encoding) { if (encoding & ENC_LITTLE_ENDIAN) { return tvb_get_letoh40(tvb, offset); } else { return tvb_get_ntoh40(tvb, offset); } } gint64 tvb_get_gint40(tvbuff_t *tvb, const gint offset, const guint encoding) { if (encoding & ENC_LITTLE_ENDIAN) { return tvb_get_letohi40(tvb, offset); } else { return tvb_get_ntohi40(tvb, offset); } } guint64 tvb_get_guint48(tvbuff_t *tvb, const gint offset, const guint encoding) { if (encoding & ENC_LITTLE_ENDIAN) { return tvb_get_letoh48(tvb, offset); } else { return tvb_get_ntoh48(tvb, offset); } } gint64 tvb_get_gint48(tvbuff_t *tvb, const gint offset, const guint encoding) { if (encoding & ENC_LITTLE_ENDIAN) { return tvb_get_letohi48(tvb, offset); } else { return tvb_get_ntohi48(tvb, offset); } } guint64 tvb_get_guint56(tvbuff_t *tvb, const gint offset, const guint encoding) { if (encoding & ENC_LITTLE_ENDIAN) { return tvb_get_letoh56(tvb, offset); } else { return tvb_get_ntoh56(tvb, offset); } } gint64 tvb_get_gint56(tvbuff_t *tvb, const gint offset, const guint encoding) { if (encoding & ENC_LITTLE_ENDIAN) { return tvb_get_letohi56(tvb, offset); } else { return tvb_get_ntohi56(tvb, offset); } } guint64 tvb_get_guint64(tvbuff_t *tvb, const gint offset, const guint encoding) { if (encoding & ENC_LITTLE_ENDIAN) { return tvb_get_letoh64(tvb, offset); } else { return tvb_get_ntoh64(tvb, offset); } } gint64 tvb_get_gint64(tvbuff_t *tvb, const gint offset, const guint encoding) { if (encoding & ENC_LITTLE_ENDIAN) { return tvb_get_letohi64(tvb, offset); } else { return tvb_get_ntohi64(tvb, offset); } } gfloat tvb_get_ieee_float(tvbuff_t *tvb, const gint offset, const guint encoding) { if (encoding & ENC_LITTLE_ENDIAN) { return tvb_get_letohieee_float(tvb, offset); } else { return tvb_get_ntohieee_float(tvb, offset); } } gdouble tvb_get_ieee_double(tvbuff_t *tvb, const gint offset, const guint encoding) { if (encoding & ENC_LITTLE_ENDIAN) { return tvb_get_letohieee_double(tvb, offset); } else { return tvb_get_ntohieee_double(tvb, offset); } } /* * 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. */ #if defined(vax) #include /* * Single-precision. */ #define IEEE_SP_NUMBER_WIDTH 32 /* bits in number */ #define IEEE_SP_EXP_WIDTH 8 /* bits in exponent */ #define IEEE_SP_MANTISSA_WIDTH 23 /* IEEE_SP_NUMBER_WIDTH - 1 - IEEE_SP_EXP_WIDTH */ #define IEEE_SP_SIGN_MASK 0x80000000 #define IEEE_SP_EXPONENT_MASK 0x7F800000 #define IEEE_SP_MANTISSA_MASK 0x007FFFFF #define IEEE_SP_INFINITY IEEE_SP_EXPONENT_MASK #define IEEE_SP_IMPLIED_BIT (1 << IEEE_SP_MANTISSA_WIDTH) #define IEEE_SP_INFINITE ((1 << IEEE_SP_EXP_WIDTH) - 1) #define IEEE_SP_BIAS ((1 << (IEEE_SP_EXP_WIDTH - 1)) - 1) static int ieee_float_is_zero(const guint32 w) { return ((w & ~IEEE_SP_SIGN_MASK) == 0); } static gfloat get_ieee_float(const guint32 w) { 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; } #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); } #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); } /* * Double-precision. * We assume that if you don't have IEEE floating-point, you have a * compiler that understands 64-bit integral quantities. */ #define IEEE_DP_NUMBER_WIDTH 64 /* bits in number */ #define IEEE_DP_EXP_WIDTH 11 /* bits in exponent */ #define IEEE_DP_MANTISSA_WIDTH 52 /* IEEE_DP_NUMBER_WIDTH - 1 - IEEE_DP_EXP_WIDTH */ #define IEEE_DP_SIGN_MASK G_GINT64_CONSTANT(0x8000000000000000) #define IEEE_DP_EXPONENT_MASK G_GINT64_CONSTANT(0x7FF0000000000000) #define IEEE_DP_MANTISSA_MASK G_GINT64_CONSTANT(0x000FFFFFFFFFFFFF) #define IEEE_DP_INFINITY IEEE_DP_EXPONENT_MASK #define IEEE_DP_IMPLIED_BIT (G_GINT64_CONSTANT(1) << IEEE_DP_MANTISSA_WIDTH) #define IEEE_DP_INFINITE ((1 << IEEE_DP_EXP_WIDTH) - 1) #define IEEE_DP_BIAS ((1 << (IEEE_DP_EXP_WIDTH - 1)) - 1) static int ieee_double_is_zero(const guint64 w) { return ((w & ~IEEE_SP_SIGN_MASK) == 0); } static gdouble get_ieee_double(const guint64 w) { gint64 sign; gint64 exponent; gint64 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; } #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); } #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); } #endif /* * 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? */ gfloat tvb_get_ntohieee_float(tvbuff_t *tvb, const int offset) { #if defined(vax) return get_ieee_float(tvb_get_ntohl(tvb, offset)); #else union { gfloat f; guint32 w; } ieee_fp_union; ieee_fp_union.w = tvb_get_ntohl(tvb, offset); return ieee_fp_union.f; #endif } /* * Fetches an IEEE double-precision floating-point number, in * big-endian form, and returns a "double". */ gdouble tvb_get_ntohieee_double(tvbuff_t *tvb, const int offset) { #if defined(vax) union { guint32 w[2]; guint64 dw; } ieee_fp_union; #else union { gdouble d; guint32 w[2]; } ieee_fp_union; #endif #if G_BYTE_ORDER == G_BIG_ENDIAN ieee_fp_union.w[0] = tvb_get_ntohl(tvb, offset); ieee_fp_union.w[1] = tvb_get_ntohl(tvb, offset+4); #else ieee_fp_union.w[0] = tvb_get_ntohl(tvb, offset+4); ieee_fp_union.w[1] = tvb_get_ntohl(tvb, offset); #endif #if defined(vax) return get_ieee_double(ieee_fp_union.dw); #else return ieee_fp_union.d; #endif } guint16 tvb_get_letohs(tvbuff_t *tvb, const gint offset) { const guint8 *ptr; ptr = fast_ensure_contiguous(tvb, offset, 2); return pletoh16(ptr); } gint16 tvb_get_letohis(tvbuff_t *tvb, const gint offset) { const guint8 *ptr; ptr = fast_ensure_contiguous(tvb, offset, 2); return pletoh16(ptr); } guint32 tvb_get_letoh24(tvbuff_t *tvb, const gint offset) { const guint8 *ptr; ptr = fast_ensure_contiguous(tvb, offset, 3); return pletoh24(ptr); } gint32 tvb_get_letohi24(tvbuff_t *tvb, const gint offset) { guint32 ret; ret = ws_sign_ext32(tvb_get_letoh24(tvb, offset), 24); return (gint32)ret; } guint32 tvb_get_letohl(tvbuff_t *tvb, const gint offset) { const guint8 *ptr; ptr = fast_ensure_contiguous(tvb, offset, 4); return pletoh32(ptr); } gint32 tvb_get_letohil(tvbuff_t *tvb, const gint offset) { const guint8 *ptr; ptr = fast_ensure_contiguous(tvb, offset, 4); return pletoh32(ptr); } guint64 tvb_get_letoh40(tvbuff_t *tvb, const gint offset) { const guint8 *ptr; ptr = fast_ensure_contiguous(tvb, offset, 5); return pletoh40(ptr); } gint64 tvb_get_letohi40(tvbuff_t *tvb, const gint offset) { guint64 ret; ret = ws_sign_ext64(tvb_get_letoh40(tvb, offset), 40); return (gint64)ret; } guint64 tvb_get_letoh48(tvbuff_t *tvb, const gint offset) { const guint8 *ptr; ptr = fast_ensure_contiguous(tvb, offset, 6); return pletoh48(ptr); } gint64 tvb_get_letohi48(tvbuff_t *tvb, const gint offset) { guint64 ret; ret = ws_sign_ext64(tvb_get_letoh48(tvb, offset), 48); return (gint64)ret; } guint64 tvb_get_letoh56(tvbuff_t *tvb, const gint offset) { const guint8 *ptr; ptr = fast_ensure_contiguous(tvb, offset, 7); return pletoh56(ptr); } gint64 tvb_get_letohi56(tvbuff_t *tvb, const gint offset) { guint64 ret; ret = ws_sign_ext64(tvb_get_letoh56(tvb, offset), 56); return (gint64)ret; } guint64 tvb_get_letoh64(tvbuff_t *tvb, const gint offset) { const guint8 *ptr; ptr = fast_ensure_contiguous(tvb, offset, 8); return pletoh64(ptr); } gint64 tvb_get_letohi64(tvbuff_t *tvb, const gint offset) { const guint8 *ptr; ptr = fast_ensure_contiguous(tvb, offset, 8); return pletoh64(ptr); } /* * 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? */ gfloat tvb_get_letohieee_float(tvbuff_t *tvb, const int offset) { #if defined(vax) return get_ieee_float(tvb_get_letohl(tvb, offset)); #else union { gfloat f; guint32 w; } ieee_fp_union; ieee_fp_union.w = tvb_get_letohl(tvb, offset); return ieee_fp_union.f; #endif } /* * Fetches an IEEE double-precision floating-point number, in * little-endian form, and returns a "double". */ gdouble tvb_get_letohieee_double(tvbuff_t *tvb, const int offset) { #if defined(vax) union { guint32 w[2]; guint64 dw; } ieee_fp_union; #else union { gdouble d; guint32 w[2]; } ieee_fp_union; #endif #if G_BYTE_ORDER == G_BIG_ENDIAN ieee_fp_union.w[0] = tvb_get_letohl(tvb, offset+4); ieee_fp_union.w[1] = tvb_get_letohl(tvb, offset); #else ieee_fp_union.w[0] = tvb_get_letohl(tvb, offset); ieee_fp_union.w[1] = tvb_get_letohl(tvb, offset+4); #endif #if defined(vax) return get_ieee_double(ieee_fp_union.dw); #else return ieee_fp_union.d; #endif } /* 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. * */ static inline void validate_single_byte_ascii_encoding(const guint encoding) { const guint enc = encoding & ~ENC_CHARENCODING_MASK; switch (enc) { case ENC_UTF_16: case ENC_UCS_2: case ENC_UCS_4: case ENC_3GPP_TS_23_038_7BITS_PACKED: case ENC_ASCII_7BITS: case ENC_EBCDIC: case ENC_EBCDIC_CP037: case ENC_EBCDIC_CP500: case ENC_BCD_DIGITS_0_9: case ENC_KEYPAD_ABC_TBCD: case ENC_KEYPAD_BC_TBCD: case ENC_ETSI_TS_102_221_ANNEX_A: case ENC_APN_STR: case ENC_DECT_STANDARD_4BITS_TBCD: 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"); } GByteArray* tvb_get_string_bytes(tvbuff_t *tvb, const gint offset, const gint length, const guint encoding, GByteArray *bytes, gint *endoff) { gchar *ptr; const gchar *begin; const gchar *end = NULL; GByteArray *retval = NULL; validate_single_byte_ascii_encoding(encoding); ptr = (gchar*) tvb_get_raw_string(NULL, 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, FALSE)) { if (bytes->len > 0) { if (endoff) *endoff = offset + (gint)(end - ptr); retval = bytes; } } } wmem_free(NULL, ptr); return retval; } static gboolean parse_month_name(const char *name, int *tm_mon) { 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 TRUE; } } return FALSE; } /* * Is the character a WSP character, as per RFC 5234? (space or tab). */ #define IS_WSP(c) ((c) == ' ' || (c) == '\t') /* support hex-encoded time values? */ nstime_t* tvb_get_string_time(tvbuff_t *tvb, const gint offset, const gint length, const guint encoding, nstime_t *ns, gint *endoff) { gchar *begin; const gchar *ptr; const gchar *end = NULL; int num_chars = 0; int utc_offset = 0; validate_single_byte_ascii_encoding(encoding); DISSECTOR_ASSERT(ns); begin = (gchar*) tvb_get_raw_string(NULL, tvb, offset, length); ptr = begin; while (IS_WSP(*ptr)) ptr++; if (*ptr) { if ((encoding & ENC_ISO_8601_DATE_TIME) == ENC_ISO_8601_DATE_TIME) { if (!(end = iso8601_to_nstime(ns, ptr, ISO8601_DATETIME))) { goto fail; } } else if ((encoding & ENC_ISO_8601_DATE_TIME_BASIC) == ENC_ISO_8601_DATE_TIME_BASIC) { 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_DATE) { /* 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_TIME) { /* 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); struct tm *tm_now = gmtime(&time_now); if (tm_now != NULL) { 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_TIME) { /* * 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_isalpha(ptr[1]) && g_ascii_isalpha(ptr[2]) && 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++; /* * Scan the year. Treat 2-digit years * differently from 4-digit years. */ guint32 year; const gchar *yearendp; if (!ws_strtou32(ptr, &yearendp, &year)) { goto fail; } if (!IS_WSP(*yearendp)) { /* 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++; /* 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++; /* * 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 != 0) { goto fail; } ns->secs += utc_offset; } } else { /* Empty string */ goto fail; } if (endoff) *endoff = (gint)(offset + (end - begin)); wmem_free(NULL, begin); return ns; fail: wmem_free(NULL, begin); return NULL; } /* Fetch an IPv4 address, in network byte order. * We do *not* convert them to host byte order; we leave them in * network byte order. */ guint32 tvb_get_ipv4(tvbuff_t *tvb, const gint offset) { const guint8 *ptr; guint32 addr; ptr = fast_ensure_contiguous(tvb, offset, sizeof(guint32)); memcpy(&addr, ptr, sizeof addr); return addr; } /* Fetch an IPv6 address. */ void tvb_get_ipv6(tvbuff_t *tvb, const gint offset, ws_in6_addr *addr) { const guint8 *ptr; ptr = ensure_contiguous(tvb, offset, sizeof(*addr)); memcpy(addr, ptr, sizeof *addr); } /* Fetch a GUID. */ void tvb_get_ntohguid(tvbuff_t *tvb, const gint offset, e_guid_t *guid) { const guint8 *ptr = ensure_contiguous(tvb, offset, GUID_LEN); guid->data1 = pntoh32(ptr + 0); guid->data2 = pntoh16(ptr + 4); guid->data3 = pntoh16(ptr + 6); memcpy(guid->data4, ptr + 8, sizeof guid->data4); } void tvb_get_letohguid(tvbuff_t *tvb, const gint offset, e_guid_t *guid) { const guint8 *ptr = ensure_contiguous(tvb, offset, GUID_LEN); guid->data1 = pletoh32(ptr + 0); guid->data2 = pletoh16(ptr + 4); guid->data3 = pletoh16(ptr + 6); memcpy(guid->data4, ptr + 8, sizeof guid->data4); } /* * NOTE: to support code written when proto_tree_add_item() took a * gboolean as its last argument, with FALSE meaning "big-endian" * and TRUE meaning "little-endian", we treat any non-zero value of * "encoding" as meaning "little-endian". */ void tvb_get_guid(tvbuff_t *tvb, const gint offset, e_guid_t *guid, const guint encoding) { if (encoding) { tvb_get_letohguid(tvb, offset, guid); } else { tvb_get_ntohguid(tvb, offset, guid); } } static const guint8 bit_mask8[] = { 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff }; /* Get a variable ammount 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. */ guint8 * tvb_get_bits_array(wmem_allocator_t *scope, tvbuff_t *tvb, const gint bit_offset, size_t no_of_bits, size_t *data_length, const guint encoding) { tvbuff_t *sub_tvb; if (encoding & ENC_LITTLE_ENDIAN) { sub_tvb = tvb_new_octet_right_aligned(tvb, bit_offset, (gint32) no_of_bits); } else { sub_tvb = tvb_new_octet_aligned(tvb, bit_offset, (gint32) no_of_bits); } *data_length = tvb_reported_length(sub_tvb); return (guint8*)tvb_memdup(scope, sub_tvb, 0, *data_length); } /* Get 1 - 8 bits */ guint8 tvb_get_bits8(tvbuff_t *tvb, guint bit_offset, const gint no_of_bits) { return (guint8)_tvb_get_bits64(tvb, bit_offset, no_of_bits); } /* Get 1 - 16 bits */ guint16 tvb_get_bits16(tvbuff_t *tvb, guint bit_offset, const gint no_of_bits, const guint encoding) { return (guint16)tvb_get_bits64(tvb, bit_offset, no_of_bits, encoding); } /* Get 1 - 32 bits */ guint32 tvb_get_bits32(tvbuff_t *tvb, guint bit_offset, const gint no_of_bits, const guint encoding) { return (guint32)tvb_get_bits64(tvb, bit_offset, no_of_bits, encoding); } /* Get 1 - 64 bits */ guint64 tvb_get_bits64(tvbuff_t *tvb, guint bit_offset, const gint no_of_bits, const guint encoding) { /* encoding determines bit numbering within octet array */ if (encoding & ENC_LITTLE_ENDIAN) { return _tvb_get_bits64_le(tvb, bit_offset, no_of_bits); } else { return _tvb_get_bits64(tvb, bit_offset, no_of_bits); } } /* * 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. */ static guint64 _tvb_get_bits64(tvbuff_t *tvb, guint bit_offset, const gint total_no_of_bits) { guint64 value; guint octet_offset = bit_offset >> 3; guint8 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 */ guint8 right_shift = required_bits_in_first_octet - total_no_of_bits; value = (tvb_get_guint8(tvb, octet_offset) >> right_shift) & bit_mask8[total_no_of_bits % 8]; } else { guint8 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_guint8(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_guint8(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_guint8(tvb, octet_offset) >> (8 - remaining_bit_length)); } } return value; } /* * 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. */ static guint64 _tvb_get_bits64_le(tvbuff_t *tvb, guint bit_offset, const gint total_no_of_bits) { guint64 value = 0; guint octet_offset = bit_offset / 8; gint remaining_bits = total_no_of_bits; gint 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_guint8(tvb, octet_offset) >> (bit_offset % 8); if (shift > total_no_of_bits) { /* keep only the requested bits */ value &= (G_GUINT64_CONSTANT(1) << total_no_of_bits) - 1; remaining_bits = 0; } else { remaining_bits = total_no_of_bits - shift; } octet_offset++; } while (remaining_bits > 0) { /* take the biggest words, shorts or octets that we can */ if (remaining_bits >= 32) { value |= ((guint64)tvb_get_letohl(tvb, octet_offset) << shift); shift += 32; remaining_bits -= 32; octet_offset += 4; } else if (remaining_bits >= 16) { value |= ((guint64)tvb_get_letohs(tvb, octet_offset) << shift); shift += 16; remaining_bits -= 16; octet_offset += 2; } else if (remaining_bits >= 8) { value |= ((guint64)tvb_get_guint8(tvb, octet_offset) << shift); shift += 8; remaining_bits -= 8; octet_offset += 1; } else { guint mask = (1 << remaining_bits) - 1; value |= (((guint64)tvb_get_guint8(tvb, octet_offset) & mask) << shift); shift += remaining_bits; remaining_bits = 0; octet_offset += 1; } } return value; } /* Get 1 - 32 bits (should be deprecated as same as tvb_get_bits32??) */ guint32 tvb_get_bits(tvbuff_t *tvb, const guint bit_offset, const gint no_of_bits, const guint encoding) { return (guint32)tvb_get_bits64(tvb, bit_offset, no_of_bits, encoding); } static gint tvb_find_guint8_generic(tvbuff_t *tvb, guint abs_offset, guint limit, guint8 needle) { const guint8 *ptr; const guint8 *result; ptr = ensure_contiguous(tvb, abs_offset, limit); /* tvb_get_ptr() */ if (!ptr) return -1; result = (const guint8 *) memchr(ptr, needle, limit); if (!result) return -1; return (gint) ((result - ptr) + abs_offset); } /* Find first occurrence of needle in tvbuff, starting at offset. Searches * at most maxlength number of bytes; if maxlength is -1, searches to * end of tvbuff. * Returns the offset of the found needle, or -1 if not found. * Will not throw an exception, even if maxlength exceeds boundary of tvbuff; * in that case, -1 will be returned if the boundary is reached before * finding needle. */ gint tvb_find_guint8(tvbuff_t *tvb, const gint offset, const gint maxlength, const guint8 needle) { const guint8 *result; guint abs_offset = 0; guint limit = 0; int exception; DISSECTOR_ASSERT(tvb && tvb->initialized); exception = compute_offset_and_remaining(tvb, offset, &abs_offset, &limit); if (exception) THROW(exception); /* Only search to end of tvbuff, w/o throwing exception. */ if (maxlength >= 0 && limit > (guint) maxlength) { /* Maximum length doesn't go past end of tvbuff; search to that value. */ limit = (guint) maxlength; } /* If we have real data, perform our search now. */ if (tvb->real_data) { result = (const guint8 *)memchr(tvb->real_data + abs_offset, needle, limit); if (result == NULL) { return -1; } else { return (gint) (result - tvb->real_data); } } if (tvb->ops->tvb_find_guint8) return tvb->ops->tvb_find_guint8(tvb, abs_offset, limit, needle); return tvb_find_guint8_generic(tvb, offset, limit, needle); } /* Same as tvb_find_guint8() with 16bit needle. */ gint tvb_find_guint16(tvbuff_t *tvb, const gint offset, const gint maxlength, const guint16 needle) { guint abs_offset = 0; guint limit = 0; int exception; exception = compute_offset_and_remaining(tvb, offset, &abs_offset, &limit); if (exception) THROW(exception); /* Only search to end of tvbuff, w/o throwing exception. */ if (maxlength >= 0 && limit > (guint) maxlength) { /* Maximum length doesn't go past end of tvbuff; search to that value. */ limit = (guint) maxlength; } const guint8 needle1 = ((needle & 0xFF00) >> 8); const guint8 needle2 = ((needle & 0x00FF) >> 0); guint searched_bytes = 0; guint pos = abs_offset; do { gint offset1 = tvb_find_guint8(tvb, pos, limit - searched_bytes, needle1); gint offset2 = -1; if (offset1 == -1) { return -1; } searched_bytes = (guint)offset1 - abs_offset + 1; if (searched_bytes >= limit) { return -1; } offset2 = tvb_find_guint8(tvb, offset1 + 1, 1, needle2); searched_bytes += 1; if (offset2 != -1) { if (searched_bytes > limit) { return -1; } return offset1; } pos = offset1 + 1; } while (searched_bytes < limit); return -1; } static inline gint tvb_ws_mempbrk_guint8_generic(tvbuff_t *tvb, guint abs_offset, guint limit, const ws_mempbrk_pattern* pattern, guchar *found_needle) { const guint8 *ptr; const guint8 *result; ptr = ensure_contiguous(tvb, abs_offset, limit); /* tvb_get_ptr */ if (!ptr) return -1; result = ws_mempbrk_exec(ptr, limit, pattern, found_needle); if (!result) return -1; return (gint) ((result - ptr) + abs_offset); } /* Find first occurrence of any of the pattern chars in tvbuff, starting at offset. * Searches at most maxlength number of bytes; if maxlength is -1, searches * to end of tvbuff. * Returns the offset of the found needle, or -1 if not found. * Will not throw an exception, even if maxlength exceeds boundary of tvbuff; * in that case, -1 will be returned if the boundary is reached before * finding needle. */ gint tvb_ws_mempbrk_pattern_guint8(tvbuff_t *tvb, const gint offset, const gint maxlength, const ws_mempbrk_pattern* pattern, guchar *found_needle) { const guint8 *result; guint abs_offset = 0; guint limit = 0; int exception; DISSECTOR_ASSERT(tvb && tvb->initialized); exception = compute_offset_and_remaining(tvb, offset, &abs_offset, &limit); if (exception) THROW(exception); /* Only search to end of tvbuff, w/o throwing exception. */ if (limit > (guint) maxlength) { /* Maximum length doesn't go past end of tvbuff; search to that value. */ limit = maxlength; } /* If we have real data, perform our search now. */ if (tvb->real_data) { result = ws_mempbrk_exec(tvb->real_data + abs_offset, limit, pattern, found_needle); if (result == NULL) { return -1; } else { return (gint) (result - tvb->real_data); } } if (tvb->ops->tvb_ws_mempbrk_pattern_guint8) return tvb->ops->tvb_ws_mempbrk_pattern_guint8(tvb, abs_offset, limit, pattern, found_needle); return tvb_ws_mempbrk_guint8_generic(tvb, abs_offset, limit, pattern, found_needle); } /* 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. */ guint tvb_strsize(tvbuff_t *tvb, const gint offset) { guint abs_offset = 0, junk_length; gint nul_offset; DISSECTOR_ASSERT(tvb && tvb->initialized); check_offset_length(tvb, offset, 0, &abs_offset, &junk_length); nul_offset = tvb_find_guint8(tvb, abs_offset, -1, 0); if (nul_offset == -1) { /* * OK, we hit the end of the tvbuff, so we should throw * an exception. */ if (tvb->length < tvb->contained_length) { THROW(BoundsError); } else if (tvb->flags & TVBUFF_FRAGMENT) { THROW(FragmentBoundsError); } else if (tvb->length < tvb->reported_length) { THROW(ContainedBoundsError); } else { THROW(ReportedBoundsError); } } return (nul_offset - abs_offset) + 1; } /* UTF-16/UCS-2 version of tvb_strsize */ /* Returns number of bytes including the (two-bytes) null terminator */ guint tvb_unicode_strsize(tvbuff_t *tvb, const gint offset) { guint i = 0; gunichar2 uchar; DISSECTOR_ASSERT(tvb && tvb->initialized); do { /* Endianness doesn't matter when looking for null */ uchar = tvb_get_ntohs(tvb, offset + i); i += 2; } while(uchar != 0); return i; } /* 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. */ gint tvb_strnlen(tvbuff_t *tvb, const gint offset, const guint maxlength) { gint result_offset; guint abs_offset = 0, junk_length; DISSECTOR_ASSERT(tvb && tvb->initialized); check_offset_length(tvb, offset, 0, &abs_offset, &junk_length); result_offset = tvb_find_guint8(tvb, abs_offset, maxlength, 0); if (result_offset == -1) { return -1; } else { return result_offset - abs_offset; } } /* * Implement strneql etc */ /* * Call strncmp after checking if enough chars left, returning 0 if * it returns 0 (meaning "equal") and -1 otherwise, otherwise return -1. */ gint tvb_strneql(tvbuff_t *tvb, const gint offset, const gchar *str, const size_t size) { const guint8 *ptr; ptr = ensure_contiguous_no_exception(tvb, offset, (gint)size, NULL); 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; } } /* * Call g_ascii_strncasecmp after checking if enough chars left, returning * 0 if it returns 0 (meaning "equal") and -1 otherwise, otherwise return -1. */ gint tvb_strncaseeql(tvbuff_t *tvb, const gint offset, const gchar *str, const size_t size) { const guint8 *ptr; ptr = ensure_contiguous_no_exception(tvb, offset, (gint)size, NULL); 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; } } /* * 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. */ gint tvb_memeql(tvbuff_t *tvb, const gint offset, const guint8 *str, size_t size) { const guint8 *ptr; ptr = ensure_contiguous_no_exception(tvb, offset, (gint) size, NULL); 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; } } /** * Format the data in the tvb from offset for size. Returned string is * wmem packet_scoped so call must be in that scope. */ gchar * tvb_format_text(wmem_allocator_t *scope, tvbuff_t *tvb, const gint offset, const gint size) { const guint8 *ptr; gint len; len = (size > 0) ? size : 0; ptr = ensure_contiguous(tvb, offset, size); return format_text(scope, ptr, len); } /* * Format the data in the tvb from offset for length ... */ gchar * tvb_format_text_wsp(wmem_allocator_t* allocator, tvbuff_t *tvb, const gint offset, const gint size) { const guint8 *ptr; gint len; len = (size > 0) ? size : 0; ptr = ensure_contiguous(tvb, offset, size); return format_text_wsp(allocator, ptr, len); } /** * Like "tvb_format_text()", but for null-padded strings; don't show * the null padding characters as "\000". Returned string is wmem packet_scoped * so call must be in that scope. */ gchar * tvb_format_stringzpad(wmem_allocator_t *scope, tvbuff_t *tvb, const gint offset, const gint size) { const guint8 *ptr, *p; gint len; gint stringlen; len = (size > 0) ? size : 0; ptr = ensure_contiguous(tvb, offset, size); for (p = ptr, stringlen = 0; stringlen < len && *p != '\0'; p++, stringlen++) ; return format_text(scope, ptr, stringlen); } /* * Like "tvb_format_text_wsp()", but for null-padded strings; don't show * the null padding characters as "\000". */ gchar * tvb_format_stringzpad_wsp(wmem_allocator_t* allocator, tvbuff_t *tvb, const gint offset, const gint size) { const guint8 *ptr, *p; gint len; gint stringlen; len = (size > 0) ? size : 0; ptr = ensure_contiguous(tvb, offset, size); for (p = ptr, stringlen = 0; stringlen < len && *p != '\0'; p++, stringlen++) ; return format_text_wsp(allocator, ptr, stringlen); } /* * 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. */ /* * 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. */ static guint8 * tvb_get_ascii_string(wmem_allocator_t *scope, tvbuff_t *tvb, gint offset, gint length) { const guint8 *ptr; ptr = ensure_contiguous(tvb, offset, length); return get_ascii_string(scope, ptr, length); } /* * 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. */ static guint8 * tvb_get_iso_646_string(wmem_allocator_t *scope, tvbuff_t *tvb, gint offset, gint length, const gunichar2 table[0x80]) { const guint8 *ptr; ptr = ensure_contiguous(tvb, offset, length); return get_iso_646_string(scope, ptr, length, table); } /* * 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. */ static guint8 * tvb_get_utf_8_string(wmem_allocator_t *scope, tvbuff_t *tvb, const gint offset, const gint length) { const guint8 *ptr; ptr = ensure_contiguous(tvb, offset, length); return get_utf_8_string(scope, ptr, length); } /* * 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(). * * Also, this one allows a length of -1 to mean get all, but does not * allow a negative offset. */ static inline guint8 * tvb_get_raw_string(wmem_allocator_t *scope, tvbuff_t *tvb, const gint offset, const gint length) { guint8 *strbuf; gint abs_length = length; DISSECTOR_ASSERT(offset >= 0); DISSECTOR_ASSERT(abs_length >= -1); if (abs_length < 0) abs_length = tvb->length - offset; tvb_ensure_bytes_exist(tvb, offset, abs_length); strbuf = (guint8 *)wmem_alloc(scope, abs_length + 1); tvb_memcpy(tvb, strbuf, offset, abs_length); strbuf[abs_length] = '\0'; return strbuf; } /* * 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. */ static guint8 * tvb_get_string_8859_1(wmem_allocator_t *scope, tvbuff_t *tvb, gint offset, gint length) { const guint8 *ptr; ptr = ensure_contiguous(tvb, offset, length); return get_8859_1_string(scope, ptr, length); } /* * 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. */ static guint8 * tvb_get_string_unichar2(wmem_allocator_t *scope, tvbuff_t *tvb, gint offset, gint length, const gunichar2 table[0x80]) { const guint8 *ptr; ptr = ensure_contiguous(tvb, offset, length); return get_unichar2_string(scope, ptr, length, table); } /* * 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. * * 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. */ static guint8 * tvb_get_ucs_2_string(wmem_allocator_t *scope, tvbuff_t *tvb, const gint offset, gint length, const guint encoding) { const guint8 *ptr; ptr = ensure_contiguous(tvb, offset, length); return get_ucs_2_string(scope, ptr, length, encoding); } /* * 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. * * 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. */ static guint8 * tvb_get_utf_16_string(wmem_allocator_t *scope, tvbuff_t *tvb, const gint offset, gint length, const guint encoding) { const guint8 *ptr; ptr = ensure_contiguous(tvb, offset, length); return get_utf_16_string(scope, ptr, length, encoding); } /* * 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 * * 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. */ static gchar * tvb_get_ucs_4_string(wmem_allocator_t *scope, tvbuff_t *tvb, const gint offset, gint length, const guint encoding) { const guint8 *ptr; ptr = ensure_contiguous(tvb, offset, length); return get_ucs_4_string(scope, ptr, length, encoding); } gchar * tvb_get_ts_23_038_7bits_string_packed(wmem_allocator_t *scope, tvbuff_t *tvb, const gint bit_offset, gint no_of_chars) { gint in_offset = bit_offset >> 3; /* Current pointer to the input buffer */ gint length = ((no_of_chars + 1) * 7 + (bit_offset & 0x07)) >> 3; const guint8 *ptr; DISSECTOR_ASSERT(tvb && tvb->initialized); ptr = ensure_contiguous(tvb, in_offset, length); return get_ts_23_038_7bits_string_packed(scope, ptr, bit_offset, no_of_chars); } gchar * tvb_get_ts_23_038_7bits_string_unpacked(wmem_allocator_t *scope, tvbuff_t *tvb, const gint offset, gint length) { const guint8 *ptr; DISSECTOR_ASSERT(tvb && tvb->initialized); ptr = ensure_contiguous(tvb, offset, length); return get_ts_23_038_7bits_string_unpacked(scope, ptr, length); } gchar * tvb_get_etsi_ts_102_221_annex_a_string(wmem_allocator_t *scope, tvbuff_t *tvb, const gint offset, gint length) { const guint8 *ptr; DISSECTOR_ASSERT(tvb && tvb->initialized); ptr = ensure_contiguous(tvb, offset, length); return get_etsi_ts_102_221_annex_a_string(scope, ptr, length); } gchar * tvb_get_ascii_7bits_string(wmem_allocator_t *scope, tvbuff_t *tvb, const gint bit_offset, gint no_of_chars) { gint in_offset = bit_offset >> 3; /* Current pointer to the input buffer */ gint length = ((no_of_chars + 1) * 7 + (bit_offset & 0x07)) >> 3; const guint8 *ptr; DISSECTOR_ASSERT(tvb && tvb->initialized); ptr = ensure_contiguous(tvb, in_offset, length); return get_ascii_7bits_string(scope, ptr, bit_offset, no_of_chars); } /* * 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. */ static guint8 * tvb_get_nonascii_unichar2_string(wmem_allocator_t *scope, tvbuff_t *tvb, gint offset, gint length, const gunichar2 table[256]) { const guint8 *ptr; ptr = ensure_contiguous(tvb, offset, length); return get_nonascii_unichar2_string(scope, ptr, length, table); } /* * 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. */ static guint8 * tvb_get_gb18030_string(wmem_allocator_t *scope, tvbuff_t *tvb, gint offset, gint length) { const guint8 *ptr; ptr = ensure_contiguous(tvb, offset, length); return get_gb18030_string(scope, ptr, length); } /* * 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 ) */ static guint8 * tvb_get_euc_kr_string(wmem_allocator_t *scope, tvbuff_t *tvb, gint offset, gint length) { const guint8 *ptr; ptr = ensure_contiguous(tvb, offset, length); return get_euc_kr_string(scope, ptr, length); } static guint8 * tvb_get_t61_string(wmem_allocator_t *scope, tvbuff_t *tvb, gint offset, gint length) { const guint8 *ptr; ptr = ensure_contiguous(tvb, offset, length); return get_t61_string(scope, ptr, length); } /* * Encoding tables for BCD strings. */ static 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','?','?','?','?','?','?' } }; static 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','?' } }; static 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','*','#','?' } }; static 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','?',' ','?','?','?','?' } }; static guint8 * tvb_get_apn_string(wmem_allocator_t *scope, tvbuff_t *tvb, const gint offset, gint length) { 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 * Qualifed 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 guint8 *ptr; ptr = ensure_contiguous(tvb, offset, length); for (;;) { guint label_len; /* * Process this label. */ label_len = *ptr; ptr++; length--; while (label_len != 0) { guint8 ch; if (length == 0) goto end; ch = *ptr; if (ch < 0x80) wmem_strbuf_append_c(str, ch); else wmem_strbuf_append_unichar_repl(str); ptr++; label_len--; length--; } if (length == 0) goto end; wmem_strbuf_append_c(str, '.'); } } end: return (guint8 *) wmem_strbuf_finalize(str); } static guint8 * tvb_get_dect_standard_8bits_string(wmem_allocator_t *scope, tvbuff_t *tvb, gint offset, gint length) { const guint8 *ptr; ptr = ensure_contiguous(tvb, offset, length); return get_dect_standard_8bits_string(scope, ptr, length); } /* * 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. */ guint8 * tvb_get_string_enc(wmem_allocator_t *scope, tvbuff_t *tvb, const gint offset, const gint length, const guint encoding) { guint8 *strptr; gboolean odd, skip_first; DISSECTOR_ASSERT(tvb && tvb->initialized); /* make sure length = -1 fails */ if (length < 0) { THROW(ReportedBoundsError); } switch (encoding & ENC_CHARENCODING_MASK) { case ENC_ASCII: 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 gboolean 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_8: strptr = tvb_get_utf_8_string(scope, tvb, offset, length); break; case ENC_UTF_16: strptr = tvb_get_utf_16_string(scope, tvb, offset, length, encoding & (ENC_LITTLE_ENDIAN|ENC_BOM)); break; case ENC_UCS_2: strptr = tvb_get_ucs_2_string(scope, tvb, offset, length, encoding & (ENC_LITTLE_ENDIAN|ENC_BOM)); break; case ENC_UCS_4: strptr = tvb_get_ucs_4_string(scope, tvb, offset, length, encoding & (ENC_LITTLE_ENDIAN|ENC_BOM)); break; case ENC_ISO_8859_1: /* * 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_2: strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_2); break; case ENC_ISO_8859_3: strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_3); break; case ENC_ISO_8859_4: strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_4); break; case ENC_ISO_8859_5: strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_5); break; case ENC_ISO_8859_6: strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_6); break; case ENC_ISO_8859_7: strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_7); break; case ENC_ISO_8859_8: strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_8); break; case ENC_ISO_8859_9: strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_9); break; case ENC_ISO_8859_10: strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_10); break; case ENC_ISO_8859_11: strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_11); break; case ENC_ISO_8859_13: strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_13); break; case ENC_ISO_8859_14: strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_14); break; case ENC_ISO_8859_15: strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_15); break; case ENC_ISO_8859_16: strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_iso_8859_16); break; case ENC_WINDOWS_1250: strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_cp1250); break; case ENC_WINDOWS_1251: strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_cp1251); break; case ENC_WINDOWS_1252: strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_cp1252); break; case ENC_MAC_ROMAN: strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_mac_roman); break; case ENC_CP437: strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_cp437); break; case ENC_CP855: strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_cp855); break; case ENC_CP866: strptr = tvb_get_string_unichar2(scope, tvb, offset, length, charset_table_cp866); break; case ENC_ISO_646_BASIC: strptr = tvb_get_iso_646_string(scope, tvb, offset, length, charset_table_iso_646_basic); break; case ENC_3GPP_TS_23_038_7BITS_PACKED: { gint bit_offset = offset << 3; gint no_of_chars = (length << 3) / 7; strptr = tvb_get_ts_23_038_7bits_string_packed(scope, tvb, bit_offset, no_of_chars); } break; case ENC_ASCII_7BITS: { gint bit_offset = offset << 3; gint no_of_chars = (length << 3) / 7; strptr = tvb_get_ascii_7bits_string(scope, tvb, bit_offset, no_of_chars); } break; case ENC_EBCDIC: /* * "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_CP037: /* * EBCDIC code page 037. */ strptr = tvb_get_nonascii_unichar2_string(scope, tvb, offset, length, charset_table_ebcdic_cp037); break; case ENC_EBCDIC_CP500: /* * EBCDIC code page 500. */ strptr = tvb_get_nonascii_unichar2_string(scope, tvb, offset, length, charset_table_ebcdic_cp500); break; case ENC_T61: strptr = tvb_get_t61_string(scope, tvb, offset, length); break; case ENC_BCD_DIGITS_0_9: /* * Packed BCD, with digits 0-9. */ odd = (encoding & ENC_BCD_ODD_NUM_DIG) >> 16; skip_first = (encoding & ENC_BCD_SKIP_FIRST) >> 17; strptr = tvb_get_bcd_string(scope, tvb, offset, length, &Dgt0_9_bcd, skip_first, odd, FALSE); break; case ENC_KEYPAD_ABC_TBCD: /* * 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_DIG) >> 16; skip_first = (encoding & ENC_BCD_SKIP_FIRST) >> 17; strptr = tvb_get_bcd_string(scope, tvb, offset, length, &Dgt_keypad_abc_tbcd, skip_first, odd, FALSE); break; case ENC_KEYPAD_BC_TBCD: /* * Keypad-with-B/C "telephony BCD" - packed BCD, with * digits 0-9 and symbols B, C, *, and #. */ odd = (encoding & ENC_BCD_ODD_NUM_DIG) >> 16; skip_first = (encoding & ENC_BCD_SKIP_FIRST) >> 17; strptr = tvb_get_bcd_string(scope, tvb, offset, length, &Dgt_ansi_tbcd, skip_first, odd, FALSE); break; case ENC_3GPP_TS_23_038_7BITS_UNPACKED: strptr = tvb_get_ts_23_038_7bits_string_unpacked(scope, tvb, offset, length); break; case ENC_ETSI_TS_102_221_ANNEX_A: strptr = tvb_get_etsi_ts_102_221_annex_a_string(scope, tvb, offset, length); break; case ENC_GB18030: strptr = tvb_get_gb18030_string(scope, tvb, offset, length); break; case ENC_EUC_KR: strptr = tvb_get_euc_kr_string(scope, tvb, offset, length); break; case ENC_APN_STR: strptr = tvb_get_apn_string(scope, tvb, offset, length); break; case ENC_DECT_STANDARD_8BITS: strptr = tvb_get_dect_standard_8bits_string(scope, tvb, offset, length); break; case ENC_DECT_STANDARD_4BITS_TBCD: /* * DECT standard 4bits "telephony BCD" - packed BCD, with * digits 0-9 and symbol SPACE for 0xb. */ odd = (encoding & ENC_BCD_ODD_NUM_DIG) >> 16; skip_first = (encoding & ENC_BCD_SKIP_FIRST) >> 17; strptr = tvb_get_bcd_string(scope, tvb, offset, length, &Dgt_dect_standard_4bits_tbcd, skip_first, odd, FALSE); break; } return strptr; } /* * 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. */ guint8 * tvb_get_stringzpad(wmem_allocator_t *scope, tvbuff_t *tvb, const gint offset, const gint length, const guint encoding) { return tvb_get_string_enc(scope, tvb, offset, length, encoding); } /* * 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). */ static guint8 * tvb_get_ascii_stringz(wmem_allocator_t *scope, tvbuff_t *tvb, gint offset, gint *lengthp) { guint size; const guint8 *ptr; size = tvb_strsize(tvb, offset); ptr = ensure_contiguous(tvb, offset, size); /* XXX, conversion between signed/unsigned integer */ if (lengthp) *lengthp = size; return get_ascii_string(scope, ptr, size); } static guint8 * tvb_get_iso_646_stringz(wmem_allocator_t *scope, tvbuff_t *tvb, gint offset, gint *lengthp, const gunichar2 table[0x80]) { guint size; const guint8 *ptr; size = tvb_strsize(tvb, offset); ptr = ensure_contiguous(tvb, offset, size); /* XXX, conversion between signed/unsigned integer */ if (lengthp) *lengthp = size; return get_iso_646_string(scope, ptr, size, table); } static guint8 * tvb_get_utf_8_stringz(wmem_allocator_t *scope, tvbuff_t *tvb, const gint offset, gint *lengthp) { guint size; const guint8 *ptr; size = tvb_strsize(tvb, offset); ptr = ensure_contiguous(tvb, offset, size); /* XXX, conversion between signed/unsigned integer */ if (lengthp) *lengthp = size; return get_utf_8_string(scope, ptr, size); } static guint8 * tvb_get_stringz_8859_1(wmem_allocator_t *scope, tvbuff_t *tvb, gint offset, gint *lengthp) { guint size; const guint8 *ptr; size = tvb_strsize(tvb, offset); ptr = ensure_contiguous(tvb, offset, size); /* XXX, conversion between signed/unsigned integer */ if (lengthp) *lengthp = size; return get_8859_1_string(scope, ptr, size); } static guint8 * tvb_get_stringz_unichar2(wmem_allocator_t *scope, tvbuff_t *tvb, gint offset, gint *lengthp, const gunichar2 table[0x80]) { guint size; const guint8 *ptr; size = tvb_strsize(tvb, offset); ptr = ensure_contiguous(tvb, offset, size); /* XXX, conversion between signed/unsigned integer */ if (lengthp) *lengthp = size; return get_unichar2_string(scope, ptr, size, table); } /* * 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 unnecessariliy) in allocating a buffer and copying the string into * it. (If we do start using composite TVBs, we may want to replace this * function with the _ephemeral version.) */ const guint8 * tvb_get_const_stringz(tvbuff_t *tvb, const gint offset, gint *lengthp) { guint size; const guint8 *strptr; size = tvb_strsize(tvb, offset); strptr = ensure_contiguous(tvb, offset, size); if (lengthp) *lengthp = size; return strptr; } static gchar * tvb_get_ucs_2_stringz(wmem_allocator_t *scope, tvbuff_t *tvb, const gint offset, gint *lengthp, const guint encoding) { gint size; /* Number of bytes in string */ const guint8 *ptr; size = tvb_unicode_strsize(tvb, offset); ptr = ensure_contiguous(tvb, offset, size); /* XXX, conversion between signed/unsigned integer */ if (lengthp) *lengthp = size; return get_ucs_2_string(scope, ptr, size, encoding); } static gchar * tvb_get_utf_16_stringz(wmem_allocator_t *scope, tvbuff_t *tvb, const gint offset, gint *lengthp, const guint encoding) { gint size; const guint8 *ptr; size = tvb_unicode_strsize(tvb, offset); ptr = ensure_contiguous(tvb, offset, size); /* XXX, conversion between signed/unsigned integer */ if (lengthp) *lengthp = size; return get_utf_16_string(scope, ptr, size, encoding); } static gchar * tvb_get_ucs_4_stringz(wmem_allocator_t *scope, tvbuff_t *tvb, const gint offset, gint *lengthp, const guint encoding) { gint size; gunichar uchar; const guint8 *ptr; size = 0; do { /* Endianness doesn't matter when looking for null */ uchar = tvb_get_ntohl(tvb, offset + size); size += 4; } while(uchar != 0); ptr = ensure_contiguous(tvb, offset, size); /* XXX, conversion between signed/unsigned integer */ if (lengthp) *lengthp = size; return get_ucs_4_string(scope, ptr, size, encoding); } static guint8 * tvb_get_nonascii_unichar2_stringz(wmem_allocator_t *scope, tvbuff_t *tvb, gint offset, gint *lengthp, const gunichar2 table[256]) { guint size; const guint8 *ptr; size = tvb_strsize(tvb, offset); ptr = ensure_contiguous(tvb, offset, size); /* XXX, conversion between signed/unsigned integer */ if (lengthp) *lengthp = size; return get_nonascii_unichar2_string(scope, ptr, size, table); } static guint8 * tvb_get_t61_stringz(wmem_allocator_t *scope, tvbuff_t *tvb, gint offset, gint *lengthp) { guint size; const guint8 *ptr; size = tvb_strsize(tvb, offset); ptr = ensure_contiguous(tvb, offset, size); /* XXX, conversion between signed/unsigned integer */ if (lengthp) *lengthp = size; return get_t61_string(scope, ptr, size); } static guint8 * tvb_get_gb18030_stringz(wmem_allocator_t *scope, tvbuff_t *tvb, gint offset, gint *lengthp) { guint size; const guint8 *ptr; size = tvb_strsize(tvb, offset); ptr = ensure_contiguous(tvb, offset, size); /* XXX, conversion between signed/unsigned integer */ if (lengthp) *lengthp = size; return get_gb18030_string(scope, ptr, size); } static guint8 * tvb_get_euc_kr_stringz(wmem_allocator_t *scope, tvbuff_t *tvb, gint offset, gint *lengthp) { guint size; const guint8 *ptr; size = tvb_strsize(tvb, offset); ptr = ensure_contiguous(tvb, offset, size); /* XXX, conversion between signed/unsigned integer */ if (lengthp) *lengthp = size; return get_euc_kr_string(scope, ptr, size); } static guint8 * tvb_get_dect_standard_8bits_stringz(wmem_allocator_t *scope, tvbuff_t *tvb, gint offset, gint *lengthp) { guint size; const guint8 *ptr; size = tvb_strsize(tvb, offset); ptr = ensure_contiguous(tvb, offset, size); /* XXX, conversion between signed/unsigned integer */ if (lengthp) *lengthp = size; return get_t61_string(scope, ptr, size); } guint8 * tvb_get_stringz_enc(wmem_allocator_t *scope, tvbuff_t *tvb, const gint offset, gint *lengthp, const guint encoding) { guint8 *strptr; DISSECTOR_ASSERT(tvb && tvb->initialized); switch (encoding & ENC_CHARENCODING_MASK) { case ENC_ASCII: 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 gboolean 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_8: /* * XXX - should map all invalid UTF-8 sequences * to a "substitute" UTF-8 character. * XXX - should map code points > 10FFFF to REPLACEMENT * CHARACTERs. */ strptr = tvb_get_utf_8_stringz(scope, tvb, offset, lengthp); break; case ENC_UTF_16: strptr = tvb_get_utf_16_stringz(scope, tvb, offset, lengthp, encoding & (ENC_LITTLE_ENDIAN|ENC_BOM)); break; case ENC_UCS_2: strptr = tvb_get_ucs_2_stringz(scope, tvb, offset, lengthp, encoding & (ENC_LITTLE_ENDIAN|ENC_BOM)); break; case ENC_UCS_4: strptr = tvb_get_ucs_4_stringz(scope, tvb, offset, lengthp, encoding & (ENC_LITTLE_ENDIAN|ENC_BOM)); break; case ENC_ISO_8859_1: /* * 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_2: strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_2); break; case ENC_ISO_8859_3: strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_3); break; case ENC_ISO_8859_4: strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_4); break; case ENC_ISO_8859_5: strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_5); break; case ENC_ISO_8859_6: strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_6); break; case ENC_ISO_8859_7: strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_7); break; case ENC_ISO_8859_8: strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_8); break; case ENC_ISO_8859_9: strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_9); break; case ENC_ISO_8859_10: strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_10); break; case ENC_ISO_8859_11: strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_11); break; case ENC_ISO_8859_13: strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_13); break; case ENC_ISO_8859_14: strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_14); break; case ENC_ISO_8859_15: strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_15); break; case ENC_ISO_8859_16: strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_iso_8859_16); break; case ENC_WINDOWS_1250: strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_cp1250); break; case ENC_WINDOWS_1251: strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_cp1251); break; case ENC_WINDOWS_1252: strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_cp1252); break; case ENC_MAC_ROMAN: strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_mac_roman); break; case ENC_CP437: strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_cp437); break; case ENC_CP855: strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_cp855); break; case ENC_CP866: strptr = tvb_get_stringz_unichar2(scope, tvb, offset, lengthp, charset_table_cp866); break; case ENC_ISO_646_BASIC: strptr = tvb_get_iso_646_stringz(scope, tvb, offset, lengthp, charset_table_iso_646_basic); break; case ENC_3GPP_TS_23_038_7BITS_PACKED: case ENC_3GPP_TS_23_038_7BITS_UNPACKED: case ENC_ETSI_TS_102_221_ANNEX_A: REPORT_DISSECTOR_BUG("TS 23.038 7bits has no null character and doesn't support null-terminated strings"); break; case ENC_ASCII_7BITS: REPORT_DISSECTOR_BUG("tvb_get_stringz_enc function with ENC_ASCII_7BITS not implemented yet"); break; case ENC_EBCDIC: /* * "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_CP037: /* * EBCDIC code page 037. */ strptr = tvb_get_nonascii_unichar2_stringz(scope, tvb, offset, lengthp, charset_table_ebcdic_cp037); break; case ENC_EBCDIC_CP500: /* * EBCDIC code page 500. */ strptr = tvb_get_nonascii_unichar2_stringz(scope, tvb, offset, lengthp, charset_table_ebcdic_cp500); break; case ENC_T61: strptr = tvb_get_t61_stringz(scope, tvb, offset, lengthp); break; case ENC_GB18030: strptr = tvb_get_gb18030_stringz(scope, tvb, offset, lengthp); break; case ENC_EUC_KR: strptr = tvb_get_euc_kr_stringz(scope, tvb, offset, lengthp); break; case ENC_DECT_STANDARD_8BITS: strptr = tvb_get_dect_standard_8bits_stringz(scope, tvb, offset, lengthp); break; } return strptr; } /* 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), or -1 if the string was * truncated in the buffer due to not having reached the terminating NUL. * In this way, it acts like snprintf(). * * bufsize MUST be greater than 0. * * When processing a packet where the remaining number of bytes is less * than bufsize, an exception is not thrown if the end of the packet * is reached before the NUL is found. If no NUL is found before reaching * the end of the short packet, -1 is still returned, and the string * is truncated with a NUL, albeit not at buffer[bufsize - 1], but * at the correct spot, terminating the string. * * *bytes_copied will contain the number of bytes actually copied, * including the terminating-NUL. */ static gint _tvb_get_raw_bytes_as_stringz(tvbuff_t *tvb, const gint offset, const guint bufsize, guint8* buffer, gint *bytes_copied) { gint stringlen; guint abs_offset = 0; gint limit, len = 0; gboolean decreased_max = FALSE; /* Only read to end of tvbuff, w/o throwing exception. */ check_offset_length(tvb, offset, -1, &abs_offset, &len); /* There must at least be room for the terminating NUL. */ DISSECTOR_ASSERT(bufsize != 0); /* If there's no room for anything else, just return the NUL. */ if (bufsize == 1) { buffer[0] = 0; *bytes_copied = 1; return 0; } /* check_offset_length() won't throw an exception if we're * looking at the byte immediately after the end of the tvbuff. */ if (len == 0) { THROW(ReportedBoundsError); } /* This should not happen because check_offset_length() would * have already thrown an exception if 'offset' were out-of-bounds. */ DISSECTOR_ASSERT(len != -1); /* * If we've been passed a negative number, bufsize will * be huge. */ DISSECTOR_ASSERT(bufsize <= G_MAXINT); if ((guint)len < bufsize) { limit = len; decreased_max = TRUE; } else { limit = bufsize; } stringlen = tvb_strnlen(tvb, abs_offset, limit - 1); /* If NUL wasn't found, copy the data and return -1 */ if (stringlen == -1) { tvb_memcpy(tvb, buffer, abs_offset, limit); if (decreased_max) { buffer[limit] = 0; /* Add 1 for the extra NUL that we set at buffer[limit], * pretending that it was copied as part of the string. */ *bytes_copied = limit + 1; } else { *bytes_copied = limit; } return -1; } /* Copy the string to buffer */ tvb_memcpy(tvb, buffer, abs_offset, stringlen + 1); *bytes_copied = stringlen + 1; return stringlen; } gint tvb_get_raw_bytes_as_stringz(tvbuff_t *tvb, const gint offset, const guint bufsize, guint8* buffer) { gint len, bytes_copied; DISSECTOR_ASSERT(tvb && tvb->initialized); len = _tvb_get_raw_bytes_as_stringz(tvb, offset, bufsize, buffer, &bytes_copied); if (len == -1) { buffer[bufsize - 1] = 0; return bytes_copied - 1; } else { return len; } } /* * 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. */ gint tvb_get_raw_bytes_as_string(tvbuff_t *tvb, const gint offset, char *buffer, size_t bufsize) { gint len = 0; DISSECTOR_ASSERT(tvb && tvb->initialized); /* There must be room for the string and the terminating NUL. */ DISSECTOR_ASSERT(bufsize > 0); DISSECTOR_ASSERT(bufsize - 1 < G_MAXINT); len = tvb_captured_length_remaining(tvb, offset); if (len <= 0) { buffer[0] = '\0'; return 0; } if (len > (gint)(bufsize - 1)) len = (gint)(bufsize - 1); /* Copy the string to buffer */ tvb_memcpy(tvb, buffer, offset, len); buffer[len] = '\0'; return len; } gboolean tvb_ascii_isprint(tvbuff_t *tvb, const gint offset, const gint length) { const guint8* buf = tvb_get_ptr(tvb, offset, length); guint abs_offset, abs_length = length; if (length == -1) { /* tvb_get_ptr has already checked for exceptions. */ compute_offset_and_remaining(tvb, offset, &abs_offset, &abs_length); } for (guint i = 0; i < abs_length; i++, buf++) if (!g_ascii_isprint(*buf)) return FALSE; return TRUE; } gboolean tvb_utf_8_isprint(tvbuff_t *tvb, const gint offset, const gint length) { const guint8* buf = tvb_get_ptr(tvb, offset, length); guint abs_offset, abs_length = length; if (length == -1) { /* tvb_get_ptr has already checked for exceptions. */ compute_offset_and_remaining(tvb, offset, &abs_offset, &abs_length); } return isprint_utf8_string(buf, abs_length); } gboolean tvb_ascii_isdigit(tvbuff_t *tvb, const gint offset, const gint length) { const guint8* buf = tvb_get_ptr(tvb, offset, length); guint abs_offset, abs_length = length; if (length == -1) { /* tvb_get_ptr has already checked for exceptions. */ compute_offset_and_remaining(tvb, offset, &abs_offset, &abs_length); } for (guint i = 0; i < abs_length; i++, buf++) if (!g_ascii_isdigit(*buf)) return FALSE; return TRUE; } static ws_mempbrk_pattern pbrk_crlf; /* * 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. * * Return the length of the line (not counting the line terminator at * the end), or, if we don't find a line terminator: * * if "desegment" is true, return -1; * * if "desegment" is false, return the amount of data remaining in * the buffer. * * 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. (It's not set if we return -1.) */ gint tvb_find_line_end(tvbuff_t *tvb, const gint offset, int len, gint *next_offset, const gboolean desegment) { gint eob_offset; gint eol_offset; int linelen; guchar found_needle = 0; static gboolean compiled = FALSE; DISSECTOR_ASSERT(tvb && tvb->initialized); if (len == -1) { len = _tvb_captured_length_remaining(tvb, offset); /* if offset is past the end of the tvbuff, len is now 0 */ } eob_offset = offset + len; if (!compiled) { ws_mempbrk_compile(&pbrk_crlf, "\r\n"); compiled = TRUE; } /* * Look either for a CR or an LF. */ eol_offset = tvb_ws_mempbrk_pattern_guint8(tvb, offset, len, &pbrk_crlf, &found_needle); if (eol_offset == -1) { /* * No CR or LF - line is presumably continued in next packet. */ if (desegment) { /* * Tell our caller we saw no EOL, so they can * try to desegment and get the entire line * into one tvbuff. */ return -1; } else { /* * Pretend the line runs to the end of the tvbuff. */ linelen = eob_offset - offset; if (next_offset) *next_offset = eob_offset; } } else { /* * Find the number of bytes between the starting offset * and the CR or LF. */ 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 (desegment) { /* * We'll return -1, 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. */ return -1; } } else { /* * Well, we can at least look at the next * byte. */ if (tvb_get_guint8(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 linelen; } static ws_mempbrk_pattern pbrk_crlf_dquote; /* * 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. */ gint tvb_find_line_end_unquoted(tvbuff_t *tvb, const gint offset, int len, gint *next_offset) { gint cur_offset, char_offset; gboolean is_quoted; guchar c = 0; gint eob_offset; int linelen; static gboolean compiled = FALSE; DISSECTOR_ASSERT(tvb && tvb->initialized); if (len == -1) len = _tvb_captured_length_remaining(tvb, offset); if (!compiled) { ws_mempbrk_compile(&pbrk_crlf_dquote, "\r\n\""); compiled = TRUE; } /* * XXX - what if "len" is still -1, meaning "offset is past the * end of the tvbuff"? */ eob_offset = offset + len; cur_offset = offset; is_quoted = FALSE; for (;;) { /* * Is this part of the string quoted? */ if (is_quoted) { /* * Yes - look only for the terminating quote. */ char_offset = tvb_find_guint8(tvb, cur_offset, len, '"'); } else { /* * Look either for a CR, an LF, or a '"'. */ char_offset = tvb_ws_mempbrk_pattern_guint8(tvb, cur_offset, len, &pbrk_crlf_dquote, &c); } if (char_offset == -1) { /* * Not found - line is presumably continued in * next packet. * We pretend the line runs to the end of the tvbuff. */ 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 = FALSE; } else { /* * OK, what is it? */ if (c == '"') { /* * Un-quoted "; it begins a quoted * string. */ is_quoted = TRUE; } 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. */ 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_guint8(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. */ linelen = eob_offset - offset; if (next_offset) *next_offset = eob_offset; break; } } return linelen; } /* * 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. */ gint tvb_skip_wsp(tvbuff_t *tvb, const gint offset, const gint maxlength) { gint counter; gint end, tvb_len; guint8 tempchar; DISSECTOR_ASSERT(tvb && tvb->initialized); /* Get the length remaining */ /*tvb_len = tvb_captured_length(tvb);*/ tvb_len = tvb->length; end = offset + maxlength; if (end >= tvb_len) { end = tvb_len; } /* Skip past spaces, tabs, CRs and LFs until run out or meet something else */ for (counter = offset; counter < end && ((tempchar = tvb_get_guint8(tvb,counter)) == ' ' || tempchar == '\t' || tempchar == '\r' || tempchar == '\n'); counter++); return (counter); } gint tvb_skip_wsp_return(tvbuff_t *tvb, const gint offset) { gint counter; guint8 tempchar; DISSECTOR_ASSERT(tvb && tvb->initialized); for (counter = offset; counter > 0 && ((tempchar = tvb_get_guint8(tvb,counter)) == ' ' || tempchar == '\t' || tempchar == '\n' || tempchar == '\r'); counter--); counter++; return (counter); } int tvb_skip_guint8(tvbuff_t *tvb, int offset, const int maxlength, const guint8 ch) { int end, tvb_len; DISSECTOR_ASSERT(tvb && tvb->initialized); /* Get the length remaining */ /*tvb_len = tvb_captured_length(tvb);*/ tvb_len = tvb->length; end = offset + maxlength; if (end >= tvb_len) end = tvb_len; while (offset < end) { guint8 tempch = tvb_get_guint8(tvb, offset); if (tempch != ch) break; offset++; } return offset; } static ws_mempbrk_pattern pbrk_whitespace; int tvb_get_token_len(tvbuff_t *tvb, const gint offset, int len, gint *next_offset, const gboolean desegment) { gint eob_offset; gint eot_offset; int tokenlen; guchar found_needle = 0; static gboolean compiled = FALSE; DISSECTOR_ASSERT(tvb && tvb->initialized); if (len == -1) { len = _tvb_captured_length_remaining(tvb, offset); /* if offset is past the end of the tvbuff, len is now 0 */ } eob_offset = offset + len; if (!compiled) { ws_mempbrk_compile(&pbrk_whitespace, " \r\n"); compiled = TRUE; } /* * Look either for a space, CR, or LF. */ eot_offset = tvb_ws_mempbrk_pattern_guint8(tvb, offset, len, &pbrk_whitespace, &found_needle); if (eot_offset == -1) { /* * No space, CR or LF - token is presumably continued in next packet. */ if (desegment) { /* * Tell our caller we saw no whitespace, so they can * try to desegment and get the entire line * into one tvbuff. */ return -1; } else { /* * Pretend the token runs to the end of the tvbuff. */ tokenlen = eob_offset - offset; if (next_offset) *next_offset = eob_offset; } } else { /* * Find the number of bytes between the starting offset * and the space, CR or LF. */ tokenlen = eot_offset - 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 = eot_offset + 1; } return tokenlen; } /* * 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. */ gchar * tvb_bytes_to_str_punct(wmem_allocator_t *scope, tvbuff_t *tvb, const gint offset, const gint len, const gchar punct) { DISSECTOR_ASSERT(len > 0); return bytes_to_str_punct(scope, ensure_contiguous(tvb, offset, len), len, punct); } /* * 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 high-order nibble of 0xf is considered a * 'filler' and will end the conversion. Similarrily if odd is set the last * high nibble will be omitted. */ gchar * tvb_get_bcd_string(wmem_allocator_t *scope, tvbuff_t *tvb, const gint offset, gint len, const dgt_set_t *dgt, gboolean skip_first, gboolean odd, gboolean bigendian) { const guint8 *ptr; int i = 0; char *digit_str; guint8 octet; DISSECTOR_ASSERT(tvb && tvb->initialized); if (len == -1) { /* * Run to the end of the captured data. * * XXX - captured, or total? */ /*length = tvb_captured_length(tvb);*/ len = tvb->length; if (len < offset) { return (char *)""; } len -= offset; } ptr = ensure_contiguous(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) { digit_str[i] = dgt->out[(octet >> 4) & 0x0f]; } else { digit_str[i] = dgt->out[octet & 0x0f]; } i++; } skip_first = FALSE; /* * unpack second value in byte */ if (!bigendian) { octet = octet >> 4; } if (octet == 0x0f) { /* * This is the stop digit or a filler digit. Ignore * it. */ break; } if ((len == 1) && (odd == TRUE )){ /* Last octet, skipp last high nibble incase of odd number of digits*/ break; } digit_str[i] = dgt->out[octet & 0x0f]; i++; ptr++; len--; } digit_str[i] = '\0'; return digit_str; } /* XXXX Fix me - needs odd indicator added */ const gchar * tvb_bcd_dig_to_str(wmem_allocator_t *scope, tvbuff_t *tvb, const gint offset, const gint len, const dgt_set_t *dgt, gboolean skip_first) { if (!dgt) dgt = &Dgt0_9_bcd; return tvb_get_bcd_string(scope, tvb, offset, len, dgt, skip_first, FALSE, FALSE); } const gchar * tvb_bcd_dig_to_str_be(wmem_allocator_t *scope, tvbuff_t *tvb, const gint offset, const gint len, const dgt_set_t *dgt, gboolean skip_first) { if (!dgt) dgt = &Dgt0_9_bcd; return tvb_get_bcd_string(scope, tvb, offset, len, dgt, skip_first, FALSE, TRUE); } /* * Format a bunch of data from a tvbuff as bytes, returning a pointer * to the string with the formatted data. */ gchar *tvb_bytes_to_str(wmem_allocator_t *allocator, tvbuff_t *tvb, const gint offset, const gint len) { DISSECTOR_ASSERT(len > 0); return bytes_to_str(allocator, ensure_contiguous(tvb, offset, len), len); } /* Find a needle tvbuff within a haystack tvbuff. */ gint tvb_find_tvb(tvbuff_t *haystack_tvb, tvbuff_t *needle_tvb, const gint haystack_offset) { guint haystack_abs_offset = 0, haystack_abs_length = 0; const guint8 *haystack_data; const guint8 *needle_data; const guint needle_len = needle_tvb->length; const guint8 *location; DISSECTOR_ASSERT(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 (gint) (location - haystack_data); } return -1; } gint tvb_raw_offset(tvbuff_t *tvb) { return ((tvb->raw_offset==-1) ? (tvb->raw_offset = tvb_offset_from_real_beginning(tvb)) : tvb->raw_offset); } void tvb_set_fragment(tvbuff_t *tvb) { tvb->flags |= TVBUFF_FRAGMENT; } struct tvbuff * tvb_get_ds_tvb(tvbuff_t *tvb) { return(tvb->ds_tvb); } guint tvb_get_varint(tvbuff_t *tvb, guint offset, guint maxlen, guint64 *value, const guint encoding) { *value = 0; switch (encoding & ENC_VARINT_MASK) { case ENC_VARINT_PROTOBUF: { guint i; guint64 b; /* current byte */ for (i = 0; ((i < FT_VARINT_MAX_LEN) && (i < maxlen)); ++i) { b = tvb_get_guint8(tvb, offset++); *value |= ((b & 0x7F) << (i * 7)); /* add lower 7 bits to val */ if (b < 0x80) { /* end successfully becauseof last byte's msb(most significant bit) is zero */ return i + 1; } } break; } case ENC_VARINT_ZIGZAG: { guint i; guint64 b; /* current byte */ for (i = 0; ((i < FT_VARINT_MAX_LEN) && (i < maxlen)); ++i) { b = tvb_get_guint8(tvb, offset++); *value |= ((b & 0x7F) << (i * 7)); /* add lower 7 bits to val */ if (b < 0x80) { /* end successfully becauseof last byte's msb(most significant bit) is zero */ *value = (*value >> 1) ^ ((*value & 1) ? -1 : 0); return i + 1; } } break; } case ENC_VARINT_SDNV: { /* Decodes similar to protobuf but in MSByte order */ guint i; guint64 b; /* current byte */ for (i = 0; ((i < FT_VARINT_MAX_LEN) && (i < maxlen)); ++i) { b = tvb_get_guint8(tvb, offset++); if ((i == 9) && (*value >= G_GUINT64_CONSTANT(1)<<(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_QUIC: { /* calculate variable length */ *value = tvb_get_guint8(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) & G_GUINT64_CONSTANT(0x3FFFFFFFFFFFFFFF); return 8; default: /* No Possible */ ws_assert_not_reached(); break; } break; } default: DISSECTOR_ASSERT_NOT_REACHED(); } return 0; /* 10 bytes scanned, but no bytes' msb is zero */ } /* * 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: */