/builds/wireshark/wireshark/epan/wslua/wslua

Bug Summary

File:	builds/wireshark/wireshark/epan/wslua/wslua_tvb.c
Warning:	line 1056, column 5 2nd function call argument is an uninitialized value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name wslua_tvb.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -ffloat16-excess-precision=fast -fbfloat16-excess-precision=fast -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/builds/wireshark/wireshark/build -fcoverage-compilation-dir=/builds/wireshark/wireshark/build -resource-dir /usr/lib/llvm-21/lib/clang/21 -isystem /usr/include/glib-2.0 -isystem /usr/lib/x86_64-linux-gnu/glib-2.0/include -isystem /usr/include/lua5.4 -isystem /builds/wireshark/wireshark/build/epan/wslua -isystem /builds/wireshark/wireshark/epan/wslua -D G_DISABLE_DEPRECATED -D G_DISABLE_SINGLE_INCLUDES -D WS_BUILD_DLL -D WS_DEBUG -D WS_DEBUG_UTF_8 -I /builds/wireshark/wireshark/build -I /builds/wireshark/wireshark -I /builds/wireshark/wireshark/include -D _GLIBCXX_ASSERTIONS -internal-isystem /usr/lib/llvm-21/lib/clang/21/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/builds/wireshark/wireshark/= -fmacro-prefix-map=/builds/wireshark/wireshark/build/= -fmacro-prefix-map=../= -Wno-format-nonliteral -std=gnu11 -ferror-limit 19 -fvisibility=hidden -fwrapv -fwrapv-pointer -fstrict-flex-arrays=3 -stack-protector 2 -fstack-clash-protection -fcf-protection=full -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fexceptions -fcolor-diagnostics -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /builds/wireshark/wireshark/sbout/2026-01-25-100340-3605-1 -x c /builds/wireshark/wireshark/epan/wslua/wslua_tvb.c
1/*
* wslua_tvb.c
*
* Wireshark's interface to the Lua Programming Language
*
* (c) 2006, Luis E. Garcia Ontanon <[email protected]>
* (c) 2008, Balint Reczey <[email protected]>
* (c) 2009, Stig Bjorlykke <[email protected]>
* (c) 2014, Hadriel Kaplan <[email protected]>
*
* Wireshark - Network traffic analyzer
* By Gerald Combs <[email protected]>
* Copyright 1998 Gerald Combs
*
* SPDX-License-Identifier: GPL-2.0-or-later
*/

18#include "config.h"

20#include "wslua.h"
21#include <epan/wmem_scopes.h>


24/* WSLUA_MODULE Tvb Functions For Handling Packet Data */


27/*
* Tvb & TvbRange
*
* a Tvb represents a tvbuff_t in Lua.
* a TvbRange represents a range in a tvb (tvb,offset,length) its main purpose is to do bounds checking,
* It helps, too, simplifying argument passing to Tree.
*
* Normally in Wireshark explicit bounds checking is unnecessary as the tvbuff
* functions throw appropriate exceptions depending on why data wasn't present.
* In Lua, the interaction between the exception handling in epan and Lua's error
* handling, both of which use setjmp/longjmp, requires careful programming to
* avoid longjmp'ing down to the stack to a location that has already exited,
* particularly when Lua dissector calls are nested. TvbRange reduces the amount
* of possible exceptions (and TRY/CATCH to deal with them) by doing preemptive
* bounds checking - at a cost of making it impossible to support truncated
* captures where captured length < reported length (#15655).
*
* These lua objects refer to structures in wireshark that are freed independently from Lua's garbage collector.
* To avoid using pointers from Lua to Wireshark structures that are already freed, we maintain a list of the
* pointers each with a marker that tracks its expiry.
*
* All pointers are marked as expired when the dissection of the current frame is finished or when the garbage
* collector tries to free the object referring to the pointer, whichever comes first.
*
* All allocated memory chunks used for tracking the pointers' state are freed after marking the pointer as expired
* by the garbage collector or by the end of the dissection of the current frame, whichever comes second.
*
* We check the expiry state of the pointer before each access.
*
*/

58WSLUA_CLASS_DEFINE(Tvb,FAIL_ON_NULL_OR_EXPIRED("Tvb"))Tvb toTvb(lua_State* L, int idx) { Tvb* v = (Tvb*)lua_touserdata
 (L, idx); if (!v) luaL_error(L, "bad argument %d (%s expected, got %s)"
, idx, "Tvb", lua_typename(L, lua_type(L, idx))); return v ? *
v : ((void*)0); } Tvb checkTvb(lua_State* L, int idx) { Tvb* p
; luaL_checktype(L,idx,7); p = (Tvb*)luaL_checkudata(L, idx, "Tvb"
); if (!*p) { luaL_argerror(L,idx,"null " "Tvb"); } else if (
(*p)->expired) { luaL_argerror(L,idx,"expired " "Tvb"); };
 return p ? *p : ((void*)0); } Tvb* pushTvb(lua_State* L, Tvb
 v) { Tvb* p; luaL_checkstack(L,2,"Unable to grow stack\n"); p
 = (Tvb*)lua_newuserdatauv(L,sizeof(Tvb),1); *p = v; (lua_getfield
(L, (-1000000 - 1000), ("Tvb"))); lua_setmetatable(L, -2); return
 p; }_Bool isTvb(lua_State* L,int i) { void *p; if(!lua_isuserdata
(L,i)) return 0; p = lua_touserdata(L, i); lua_getfield(L, (-
1000000 - 1000), "Tvb"); if (p == ((void*)0) || !lua_getmetatable
(L, i) || !lua_rawequal(L, -1, -2)) p=((void*)0); lua_settop(
L, -(2)-1); return p ? 1 : 0; } Tvb shiftTvb(lua_State* L,int
 i) { Tvb* p; if(!lua_isuserdata(L,i)) return ((void*)0); p =
 (Tvb*)lua_touserdata(L, i); lua_getfield(L, (-1000000 - 1000
), "Tvb"); if (p == ((void*)0) || !lua_getmetatable(L, i) || !
lua_rawequal(L, -1, -2)) p=((void*)0); lua_settop(L, -(2)-1);
 if (p) { (lua_rotate(L, (i), -1), lua_settop(L, -(1)-1)); return
 *p; } else return ((void*)0);} typedef int dummyTvb;
59/* A <<lua_class_Tvb,`Tvb`>> represents the packet's buffer. It is passed as an argument to listeners and dissectors,
 and can be used to extract information (via <<lua_class_TvbRange,`TvbRange`>>) from the packet's data.

 To create a <<lua_class_TvbRange,`TvbRange`>> the <<lua_class_Tvb,`Tvb`>> must be called with offset and length as optional arguments;
 the offset defaults to 0 and the length to `tvb:captured_len()`.

 [WARNING]
 ====
 Tvbs are usable only by the current listener or dissector call and are destroyed
 as soon as the listener or dissector returns, so references to them are unusable once the function
 has returned.
 ====
71*/

73static GPtrArray* outstanding_Tvb;
74static GPtrArray* outstanding_TvbRange;

76/* this is used to push Tvbs that were created brand new by wslua code */
77int push_wsluaTvb(lua_State* L, Tvb t) {
  g_ptr_array_add(outstanding_Tvb,t);
  pushTvb(L,t);
  return 1;
81}

83#define PUSH_TVBRANGE(L,t){g_ptr_array_add(outstanding_TvbRange,t);pushTvbRange(L,t);} {g_ptr_array_add(outstanding_TvbRange,t);pushTvbRange(L,t);}


86static void free_Tvb(Tvb tvb) {
  if (!tvb) return;

  if (!tvb->expired) {
      tvb->expired = true1;
  } else {
      if (tvb->need_free)
          tvb_free(tvb->ws_tvb);
      g_free(tvb);
  }
96}

98void clear_outstanding_Tvb(void) {
  while (outstanding_Tvb->len) {
      Tvb tvb = (Tvb)g_ptr_array_remove_index_fast(outstanding_Tvb,0);
      free_Tvb(tvb);
  }
103}

105/* this is used to push Tvbs that just point to pre-existing C-code Tvbs */
106Tvb* push_Tvb(lua_State* L, tvbuff_t* ws_tvb) {
  Tvb tvb = (Tvb)g_malloc(sizeof(struct _wslua_tvb));
  tvb->ws_tvb = ws_tvb;
  tvb->expired = false0;
  tvb->need_free = false0;
  g_ptr_array_add(outstanding_Tvb,tvb);
  return pushTvb(L,tvb);
113}


116WSLUA_METAMETHODstatic int Tvb__tostring(lua_State* L) {
  /*
  Convert the bytes of a <<lua_class_Tvb,`Tvb`>> into a string.
  This is primarily useful for debugging purposes since the string will be truncated if it is too long.
  */
  Tvb tvb = checkTvb(L,1);
  int len = tvb_captured_length(tvb->ws_tvb);
  char* str = tvb_bytes_to_str(NULL((void*)0),tvb->ws_tvb,0,len);

  lua_pushfstring(L, "TVB(%d) : %s", len, str);

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

  WSLUA_RETURN(1)return (1); /* The string. */
130}

132/* Gets registered as metamethod automatically by WSLUA_REGISTER_CLASS/META */
133static int Tvb__gc(lua_State* L) {
  Tvb tvb = toTvb(L,1);

  free_Tvb(tvb);

  return 0;

140}

142WSLUA_METHODstatic int Tvb_reported_len(lua_State* L) {
  /* Obtain the reported length (length on the network) of a <<lua_class_Tvb,`Tvb`>>. */
  Tvb tvb = checkTvb(L,1);

  lua_pushinteger(L,tvb_reported_length(tvb->ws_tvb));
  WSLUA_RETURN(1)return (1); /* The reported length of the <<lua_class_Tvb,`Tvb`>>. */
148}

150WSLUA_METHODstatic int Tvb_captured_len(lua_State* L) {
  /* Obtain the captured length (amount saved in the capture process) of a <<lua_class_Tvb,`Tvb`>>. */
  Tvb tvb = checkTvb(L,1);

  lua_pushinteger(L,tvb_captured_length(tvb->ws_tvb));
  WSLUA_RETURN(1)return (1); /* The captured length of the <<lua_class_Tvb,`Tvb`>>. */
156}

158WSLUA_METHODstatic int Tvb_len(lua_State* L) {
  /* Obtain the captured length (amount saved in the capture process) of a <<lua_class_Tvb,`Tvb`>>.
     Same as captured_len; kept only for backwards compatibility */
  Tvb tvb = checkTvb(L,1);

  lua_pushinteger(L,tvb_captured_length(tvb->ws_tvb));
  WSLUA_RETURN(1)return (1); /* The captured length of the <<lua_class_Tvb,`Tvb`>>. */
165}

167WSLUA_METHODstatic int Tvb_reported_length_remaining(lua_State* L) {
  /* Obtain the reported (not captured) length of packet data to end of a <<lua_class_Tvb,`Tvb`>> or 0 if the
     offset is beyond the end of the <<lua_class_Tvb,`Tvb`>>. */
170#define WSLUA_OPTARG_Tvb_reported_length_remaining_OFFSET2 2 /* The offset (in octets) from the beginning of the <<lua_class_Tvb,`Tvb`>>. Defaults to 0. */
  Tvb tvb = checkTvb(L,1);
  int offset = (int) luaL_optinteger(L, WSLUA_OPTARG_Tvb_reported_length_remaining_OFFSET2, 0);

  lua_pushinteger(L,tvb_reported_length_remaining(tvb->ws_tvb, offset));
  WSLUA_RETURN(1)return (1); /* The remaining reported length of the <<lua_class_Tvb,`Tvb`>>. */
176}

178WSLUA_METHODstatic int Tvb_bytes(lua_State* L) {
  /* Obtain a <<lua_class_ByteArray,`ByteArray`>> from a <<lua_class_Tvb,`Tvb`>>. */
180#define WSLUA_OPTARG_Tvb_bytes_OFFSET2 2 /* The offset (in octets) from the beginning of the <<lua_class_Tvb,`Tvb`>>. Defaults to 0. */
181#define WSLUA_OPTARG_Tvb_bytes_LENGTH3 3 /* The length (in octets) of the range. Defaults to until the end of the <<lua_class_Tvb,`Tvb`>>. */
  Tvb tvb = checkTvb(L,1);
  GByteArray* ba;
184#if LUA_VERSION_NUM504 >= 503
  int offset = (int)luaL_optinteger(L, WSLUA_OPTARG_Tvb_bytes_OFFSET2, 0);
  int len = (int)luaL_optinteger(L, WSLUA_OPTARG_Tvb_bytes_LENGTH3, -1);
187#else
  int offset = luaL_optint(L, WSLUA_OPTARG_Tvb_bytes_OFFSET2, 0);
  int len = luaL_optint(L,WSLUA_OPTARG_Tvb_bytes_LENGTH3,-1);
190#endif
  if (tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  /* XXX - Why is *any* negative value allowed here to mean "to the
   * end of the Tvb" instead of just -1 as elsewhere?
   */
  if (len < 0) {
      len = tvb_captured_length_remaining(tvb->ws_tvb,offset);
      if (len < 0) {
          luaL_error(L,"out of bounds");
          return 0;
      }
  } else if ( (unsigned)(len + offset) > tvb_captured_length(tvb->ws_tvb)) {
      luaL_error(L,"Range is out of bounds");
      return 0;
  }

  ba = g_byte_array_new();
  g_byte_array_append(ba, tvb_get_ptr(tvb->ws_tvb, offset, len), len);
  pushByteArray(L,ba);

  WSLUA_RETURN(1)return (1); /* The <<lua_class_ByteArray,`ByteArray`>> object or nil. */
215}

217WSLUA_METHODstatic int Tvb_offset(lua_State* L) {
  /* Returns the raw offset (from the beginning of the source <<lua_class_Tvb,`Tvb`>>) of a sub <<lua_class_Tvb,`Tvb`>>. */
  Tvb tvb = checkTvb(L,1);

  lua_pushinteger(L,tvb_raw_offset(tvb->ws_tvb));
  WSLUA_RETURN(1)return (1); /* The raw offset of the <<lua_class_Tvb,`Tvb`>>. */
223}


226#if USED_FOR_DOC_PURPOSES
227WSLUA_METAMETHODstatic int Tvb__call(lua_State* L) {
  /* Equivalent to tvb:range(...) */
  return 0;
230}
231#endif


234WSLUA_METHODstatic int Tvb_range(lua_State* L) {
  /* Creates a <<lua_class_TvbRange,`TvbRange`>> from this <<lua_class_Tvb,`Tvb`>>. */
236#define WSLUA_OPTARG_Tvb_range_OFFSET2 2 /* The offset (in octets) from the beginning of the <<lua_class_Tvb,`Tvb`>>. Defaults to 0. */
237#define WSLUA_OPTARG_Tvb_range_LENGTH3 3 /* The length (in octets) of the range. Defaults to -1, which specifies the remaining bytes in the <<lua_class_Tvb,`Tvb`>>. */

  Tvb tvb = checkTvb(L,1);
  int offset = (int) luaL_optinteger(L,WSLUA_OPTARG_Tvb_range_OFFSET2,0);
  int len = (int) luaL_optinteger(L,WSLUA_OPTARG_Tvb_range_LENGTH3,-1);

  if (push_TvbRange(L,tvb->ws_tvb,offset,len)) {
      WSLUA_RETURN(1)return (1); /* The TvbRange */
  }

  return 0;
248}

250WSLUA_METHODstatic int Tvb_raw(lua_State* L) {
  /* Obtain a Lua string of the binary bytes in a <<lua_class_Tvb,`Tvb`>>. */
252#define WSLUA_OPTARG_Tvb_raw_OFFSET2 2 /* The position of the first byte. Default is 0, or the first byte. */
253#define WSLUA_OPTARG_Tvb_raw_LENGTH3 3 /* The length of the segment to get. Default is -1, or the remaining bytes in the <<lua_class_Tvb,`Tvb`>>. */
  Tvb tvb = checkTvb(L,1);
  int offset = (int) luaL_optinteger(L,WSLUA_OPTARG_Tvb_raw_OFFSET2,0);
  int len = (int) luaL_optinteger(L,WSLUA_OPTARG_Tvb_raw_LENGTH3,-1);

  if (!tvb) return 0;
  if (tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  if ((unsigned)offset > tvb_captured_length(tvb->ws_tvb)) {
      WSLUA_OPTARG_ERROR(Tvb_raw,OFFSET,"offset beyond end of Tvb"){ luaL_argerror(L,2, "Tvb_raw" ": " "offset beyond end of Tvb"
); };
      return 0;
  }

  if (len == -1) {
      len = tvb_captured_length_remaining(tvb->ws_tvb,offset);
      if (len < 0) {
          luaL_error(L,"out of bounds");
          return false0;
      }
  } else if ( (unsigned)(len + offset) > tvb_captured_length(tvb->ws_tvb)) {
      luaL_error(L,"Range is out of bounds");
      return false0;
  }

  lua_pushlstring(L, (const char*)tvb_get_ptr(tvb->ws_tvb, offset, len), len);

  WSLUA_RETURN(1)return (1); /* A Lua string of the binary bytes in the <<lua_class_Tvb,`Tvb`>>. */
283}

285WSLUA_METAMETHODstatic int Tvb__eq(lua_State* L) {
  /* Checks whether contents of two <<lua_class_Tvb,`Tvb`>>s are equal. */
  Tvb tvb_l = checkTvb(L,1);
  Tvb tvb_r = checkTvb(L,2);

  int len_l = tvb_captured_length(tvb_l->ws_tvb);
  int len_r = tvb_captured_length(tvb_r->ws_tvb);

  /* it is not an error if their ds_tvb are different... they're just not equal */
  if (len_l == len_r)
  {
      const uint8_t* lp = tvb_get_ptr(tvb_l->ws_tvb, 0, len_l);
      const uint8_t* rp = tvb_get_ptr(tvb_r->ws_tvb, 0, len_r);

      int ret = memcmp(lp, rp, len_l) == 0 ? 1 : 0;

      lua_pushboolean(L,ret);
  } else {
      lua_pushboolean(L,0);
  }

  return 1;
307}

309WSLUA_METHODSstatic const luaL_Reg Tvb_methods[] = {
  WSLUA_CLASS_FNREG(Tvb,bytes){ "bytes", Tvb_bytes },
  WSLUA_CLASS_FNREG(Tvb,range){ "range", Tvb_range },
  WSLUA_CLASS_FNREG(Tvb,offset){ "offset", Tvb_offset },
  WSLUA_CLASS_FNREG(Tvb,reported_len){ "reported_len", Tvb_reported_len },
  WSLUA_CLASS_FNREG(Tvb,reported_length_remaining){ "reported_length_remaining", Tvb_reported_length_remaining },
  WSLUA_CLASS_FNREG(Tvb,captured_len){ "captured_len", Tvb_captured_len },
  WSLUA_CLASS_FNREG(Tvb,len){ "len", Tvb_len },
  WSLUA_CLASS_FNREG(Tvb,raw){ "raw", Tvb_raw },
  { NULL((void*)0), NULL((void*)0) }
319};

321WSLUA_METAstatic const luaL_Reg Tvb_meta[] = {
  WSLUA_CLASS_MTREG(Tvb,eq){ "__" "eq", Tvb__eq },
  WSLUA_CLASS_MTREG(Tvb,tostring){ "__" "tostring", Tvb__tostring },
  {"__call", Tvb_range},
  { NULL((void*)0), NULL((void*)0) }
326};

328int Tvb_register(lua_State* L) {
  WSLUA_REGISTER_CLASS(Tvb){ const wslua_class Tvb_class = { .name = "Tvb", .class_methods
 = Tvb_methods, .class_meta = Tvb_meta, .instance_methods = Tvb_methods
, .instance_meta = Tvb_meta, .attrs = ((void*)0) }; wslua_register_class
(L, &Tvb_class); (lua_getfield(L, (-1000000 - 1000), ("Tvb"
))); lua_pushcclosure(L, (Tvb__gc), 0); lua_setfield(L, -2, "__gc"
); lua_settop(L, -(1)-1); };
  if (outstanding_Tvb != NULL((void*)0)) {
      g_ptr_array_unref(outstanding_Tvb);
  }
  outstanding_Tvb = g_ptr_array_new();
  return 0;
335}




340WSLUA_CLASS_DEFINE(TvbRange,FAIL_ON_NULL("TvbRange"))TvbRange toTvbRange(lua_State* L, int idx) { TvbRange* v = (TvbRange
*)lua_touserdata (L, idx); if (!v) luaL_error(L, "bad argument %d (%s expected, got %s)"
, idx, "TvbRange", lua_typename(L, lua_type(L, idx))); return
 v ? *v : ((void*)0); } TvbRange checkTvbRange(lua_State* L, int
 idx) { TvbRange* p; luaL_checktype(L,idx,7); p = (TvbRange*)
luaL_checkudata(L, idx, "TvbRange"); if (! *p) luaL_argerror(
L,idx,"null " "TvbRange"); return p ? *p : ((void*)0); } TvbRange
* pushTvbRange(lua_State* L, TvbRange v) { TvbRange* p; luaL_checkstack
(L,2,"Unable to grow stack\n"); p = (TvbRange*)lua_newuserdatauv
(L,sizeof(TvbRange),1); *p = v; (lua_getfield(L, (-1000000 - 1000
), ("TvbRange"))); lua_setmetatable(L, -2); return p; }_Bool isTvbRange
(lua_State* L,int i) { void *p; if(!lua_isuserdata(L,i)) return
 0; p = lua_touserdata(L, i); lua_getfield(L, (-1000000 - 1000
), "TvbRange"); if (p == ((void*)0) || !lua_getmetatable(L, i
) || !lua_rawequal(L, -1, -2)) p=((void*)0); lua_settop(L, -(
2)-1); return p ? 1 : 0; } TvbRange shiftTvbRange(lua_State* L
,int i) { TvbRange* p; if(!lua_isuserdata(L,i)) return ((void
*)0); p = (TvbRange*)lua_touserdata(L, i); lua_getfield(L, (-
1000000 - 1000), "TvbRange"); if (p == ((void*)0) || !lua_getmetatable
(L, i) || !lua_rawequal(L, -1, -2)) p=((void*)0); lua_settop(
L, -(2)-1); if (p) { (lua_rotate(L, (i), -1), lua_settop(L, -
(1)-1)); return *p; } else return ((void*)0);} typedef int dummyTvbRange;
  /*
  A <<lua_class_TvbRange,`TvbRange`>> represents a usable range of a <<lua_class_Tvb,`Tvb`>> and is used to extract data from the <<lua_class_Tvb,`Tvb`>> that generated it.

  <<lua_class_TvbRange,`TvbRange`>>s are created by calling a <<lua_class_Tvb,`Tvb`>> (e.g. 'tvb(offset,length)').
  A length of -1, which is the default, means to use the bytes up to the end of the <<lua_class_Tvb,`Tvb`>>.
  If the <<lua_class_TvbRange,`TvbRange`>> span is outside the <<lua_class_Tvb,`Tvb`>>'s range the creation will cause a runtime error.
  */

349static void free_TvbRange(TvbRange tvbr) {
  if (!(tvbr && tvbr->tvb)) return;

  if (!tvbr->tvb->expired) {
      tvbr->tvb->expired = true1;
  } else {
      free_Tvb(tvbr->tvb);
      g_free(tvbr);
  }
358}

360void clear_outstanding_TvbRange(void) {
  while (outstanding_TvbRange->len) {
      TvbRange tvbr = (TvbRange)g_ptr_array_remove_index_fast(outstanding_TvbRange,0);
      free_TvbRange(tvbr);
  }
365}


368bool_Bool push_TvbRange(lua_State* L, tvbuff_t* ws_tvb, int offset, int len) {
  TvbRange tvbr;

  if (!ws_tvb) {
      luaL_error(L,"expired tvb");
      return false0;
  }

  /* XXX - What if offset is negative? In epan/tvbuff.h functions, a negative
   * offset means "the offset from the end of the backing tvbuff at which
   * the new tvbuff's data begins", but that's not done consistently in this
   * code when taking ranges and passing an offset. And maybe we don't want
   * to support negative offsets at all in the future (#20103).
   */
  if (len == -1) {
      len = tvb_captured_length_remaining(ws_tvb,offset);
      if (len < 0) {
          luaL_error(L,"out of bounds");
          return false0;
      }
  } else if (len < -1) {
      luaL_error(L, "negative length in tvb range");
      return false0;
  } else if ( (unsigned)(len + offset) > tvb_captured_length(ws_tvb)) {
      luaL_error(L,"Range is out of bounds");
      return false0;
  }

  tvbr = (TvbRange)g_malloc(sizeof(struct _wslua_tvbrange));
  tvbr->tvb = (Tvb)g_malloc(sizeof(struct _wslua_tvb));
  tvbr->tvb->ws_tvb = ws_tvb;
  tvbr->tvb->expired = false0;
  tvbr->tvb->need_free = false0;
  tvbr->offset = offset;
  tvbr->len = len;

  PUSH_TVBRANGE(L,tvbr){g_ptr_array_add(outstanding_TvbRange,tvbr);pushTvbRange(L,tvbr
);};

  return true1;
407}


410WSLUA_METHODstatic int TvbRange_tvb(lua_State *L) {
  /* Creates a  new <<lua_class_Tvb,`Tvb`>> from a <<lua_class_TvbRange,`TvbRange`>>. */

  TvbRange tvbr = checkTvbRange(L,1);
  Tvb tvb;

  if (! (tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  if (tvb_bytes_exist(tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len)) {
      tvb = (Tvb)g_malloc(sizeof(struct _wslua_tvb));
      tvb->expired = false0;
      tvb->need_free = false0;
      tvb->ws_tvb = tvb_new_subset_length(tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len);
      return push_wsluaTvb(L, tvb);
  } else {
      luaL_error(L,"Out Of Bounds");
      return 0;
  }
432}


435/*
*  get a Blefuscuoan unsigned integer from a tvb
*/
438WSLUA_METHODstatic int TvbRange_uint(lua_State* L) {
  /* Get a Big Endian (network order) unsigned integer from a <<lua_class_TvbRange,`TvbRange`>>.
     The range must be 1-4 octets long. */
  TvbRange tvbr = checkTvbRange(L,1);
  if (!(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  switch (tvbr->len) {
      case 1:
          lua_pushinteger(L,tvb_get_uint8(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 2:
          lua_pushinteger(L,tvb_get_ntohs(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 3:
          lua_pushinteger(L,tvb_get_ntoh24(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 4:
          lua_pushinteger(L,tvb_get_ntohl(tvbr->tvb->ws_tvb,tvbr->offset));
          WSLUA_RETURN(1)return (1); /* The unsigned integer value. */
      default:
          luaL_error(L,"TvbRange:uint() does not handle %d byte integers",tvbr->len);
          return 0;
  }
465}

467/*
*  get a Lilliputian unsigned integer from a tvb
*/
470WSLUA_METHODstatic int TvbRange_le_uint(lua_State* L) {
  /* Get a Little Endian unsigned integer from a <<lua_class_TvbRange,`TvbRange`>>.
     The range must be 1-4 octets long. */
  TvbRange tvbr = checkTvbRange(L,1);
  if (!(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  switch (tvbr->len) {
      case 1:
          /* XXX unsigned anyway */
          lua_pushinteger(L,(lua_Integer)(unsigned)tvb_get_uint8(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 2:
          lua_pushinteger(L,tvb_get_letohs(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 3:
          lua_pushinteger(L,tvb_get_letoh24(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 4:
          lua_pushinteger(L,tvb_get_letohl(tvbr->tvb->ws_tvb,tvbr->offset));
          WSLUA_RETURN(1)return (1); /* The unsigned integer value */
      default:
          luaL_error(L,"TvbRange:le_uint() does not handle %d byte integers",tvbr->len);
          return 0;
  }
498}

500/*
*  get a Blefuscuoan unsigned 64 bit integer from a tvb
*/
503WSLUA_METHODstatic int TvbRange_uint64(lua_State* L) {
  /* Get a Big Endian (network order) unsigned 64 bit integer from a <<lua_class_TvbRange,`TvbRange`>>, as a <<lua_class_UInt64,`UInt64`>> object.
     The range must be 1-8 octets long. */
  TvbRange tvbr = checkTvbRange(L,1);
  if (!(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  switch (tvbr->len) {
      case 1:
          pushUInt64(L,tvb_get_uint8(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 2:
          pushUInt64(L,tvb_get_ntohs(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 3:
          pushUInt64(L,tvb_get_ntoh24(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 4:
          pushUInt64(L,tvb_get_ntohl(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 5:
          pushUInt64(L,tvb_get_ntoh40(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 6:
          pushUInt64(L,tvb_get_ntoh48(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 7:
          pushUInt64(L,tvb_get_ntoh56(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 8:
          pushUInt64(L,tvb_get_ntoh64(tvbr->tvb->ws_tvb,tvbr->offset));
          WSLUA_RETURN(1)return (1); /* The <<lua_class_UInt64,`UInt64`>> object. */
      default:
          luaL_error(L,"TvbRange:uint64() does not handle %d byte integers",tvbr->len);
          return 0;
  }
542}

544/*
*  get a Lilliputian unsigned 64 bit integer from a tvb
*/
547WSLUA_METHODstatic int TvbRange_le_uint64(lua_State* L) {
  /* Get a Little Endian unsigned 64 bit integer from a <<lua_class_TvbRange,`TvbRange`>>, as a <<lua_class_UInt64,`UInt64`>> object.
     The range must be 1-8 octets long. */
  TvbRange tvbr = checkTvbRange(L,1);
  if (!(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  switch (tvbr->len) {
      case 1:
          pushUInt64(L,tvb_get_uint8(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 2:
          pushUInt64(L,tvb_get_letohs(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 3:
          pushUInt64(L,tvb_get_letoh24(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 4:
          pushUInt64(L,tvb_get_letohl(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 5:
          pushUInt64(L,tvb_get_letoh40(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 6:
          pushUInt64(L,tvb_get_letoh48(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 7:
          pushUInt64(L,tvb_get_letoh56(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 8:
          pushUInt64(L,tvb_get_letoh64(tvbr->tvb->ws_tvb,tvbr->offset));
          WSLUA_RETURN(1)return (1); /* The <<lua_class_UInt64,`UInt64`>> object. */
      default:
          luaL_error(L,"TvbRange:le_uint64() does not handle %d byte integers",tvbr->len);
          return 0;
  }
586}

588/*
*  get a Blefuscuoan signed integer from a tvb
*/
591WSLUA_METHODstatic int TvbRange_int(lua_State* L) {
  /* Get a Big Endian (network order) signed integer from a <<lua_class_TvbRange,`TvbRange`>>.
     The range must be 1-4 octets long. */
  TvbRange tvbr = checkTvbRange(L,1);
  if (!(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  switch (tvbr->len) {
      case 1:
          lua_pushinteger(L,tvb_get_int8(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 2:
          lua_pushinteger(L,tvb_get_ntohis(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 3:
          lua_pushinteger(L,tvb_get_ntohi24(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 4:
          lua_pushinteger(L,tvb_get_ntohil(tvbr->tvb->ws_tvb,tvbr->offset));
          WSLUA_RETURN(1)return (1); /* The signed integer value. */
          /*
           * XXX:
           *    lua uses double so we have 52 bits to play with
           *    we are missing 5 and 6 byte integers within lua's range
           *    and 64 bit integers are not supported (there's a lib for
           *    lua that does).
           */
      default:
          luaL_error(L,"TvbRange:int() does not handle %d byte integers",tvbr->len);
          return 0;
  }
625}

627/*
*  get a Lilliputian signed integer from a tvb
*/
630WSLUA_METHODstatic int TvbRange_le_int(lua_State* L) {
  /* Get a Little Endian signed integer from a <<lua_class_TvbRange,`TvbRange`>>.
     The range must be 1-4 octets long. */
  TvbRange tvbr = checkTvbRange(L,1);
  if (!(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  switch (tvbr->len) {
      case 1:
          lua_pushinteger(L,tvb_get_int8(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 2:
          lua_pushinteger(L,tvb_get_letohis(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 3:
          lua_pushinteger(L,tvb_get_letohi24(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 4:
          lua_pushinteger(L,tvb_get_letohil(tvbr->tvb->ws_tvb,tvbr->offset));
          WSLUA_RETURN(1)return (1); /* The signed integer value. */
      default:
          luaL_error(L,"TvbRange:le_int() does not handle %d byte integers",tvbr->len);
          return 0;
  }
657}

659/*
*  get a Blefuscuoan signed 64 bit integer from a tvb
*/
662WSLUA_METHODstatic int TvbRange_int64(lua_State* L) {
  /* Get a Big Endian (network order) signed 64 bit integer from a <<lua_class_TvbRange,`TvbRange`>>, as an <<lua_class_Int64,`Int64`>> object.
     The range must be 1-8 octets long. */
  TvbRange tvbr = checkTvbRange(L,1);
  if (!(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  switch (tvbr->len) {
      case 1:
          pushInt64(L,tvb_get_int8(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 2:
          pushInt64(L,tvb_get_ntohis(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 3:
          pushInt64(L,tvb_get_ntohi24(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 4:
          pushInt64(L,tvb_get_ntohil(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 5:
          pushInt64(L,tvb_get_ntohi40(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 6:
          pushInt64(L,tvb_get_ntohi48(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 7:
          pushInt64(L,tvb_get_ntohi56(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 8:
          pushInt64(L,tvb_get_ntohi64(tvbr->tvb->ws_tvb,tvbr->offset));
          WSLUA_RETURN(1)return (1); /* The <<lua_class_Int64,`Int64`>> object. */
      default:
          luaL_error(L,"TvbRange:int64() does not handle %d byte integers",tvbr->len);
          return 0;
  }
701}

703/*
*  get a Lilliputian signed 64 bit integer from a tvb
*/
706WSLUA_METHODstatic int TvbRange_le_int64(lua_State* L) {
  /* Get a Little Endian signed 64 bit integer from a <<lua_class_TvbRange,`TvbRange`>>, as an <<lua_class_Int64,`Int64`>> object.
     The range must be 1-8 octets long. */
  TvbRange tvbr = checkTvbRange(L,1);
  if (!(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  switch (tvbr->len) {
      case 1:
          pushInt64(L,tvb_get_int8(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 2:
          pushInt64(L,tvb_get_letohis(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 3:
          pushInt64(L,tvb_get_letohi24(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 4:
          pushInt64(L,tvb_get_letohil(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 5:
          pushInt64(L,tvb_get_letohi40(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 6:
          pushInt64(L,tvb_get_letohi48(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 7:
          pushInt64(L,tvb_get_letohi56(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 8:
          pushInt64(L,tvb_get_letohi64(tvbr->tvb->ws_tvb,tvbr->offset));
          WSLUA_RETURN(1)return (1); /* The <<lua_class_Int64,`Int64`>> object. */
      default:
          luaL_error(L,"TvbRange:le_int64() does not handle %d byte integers",tvbr->len);
          return 0;
  }
745}

747/*
*  get a Blefuscuoan float
*/
750WSLUA_METHODstatic int TvbRange_float(lua_State* L) {
  /* Get a Big Endian (network order) floating point number from a <<lua_class_TvbRange,`TvbRange`>>.
     The range must be 4 or 8 octets long. */
  TvbRange tvbr = checkTvbRange(L,1);
  if (!(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  switch (tvbr->len) {
      case 4:
          lua_pushnumber(L,(double)tvb_get_ntohieee_float(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 8:
          lua_pushnumber(L,tvb_get_ntohieee_double(tvbr->tvb->ws_tvb,tvbr->offset));
          WSLUA_RETURN(1)return (1); /* The floating point value. */
      default:
          luaL_error(L,"TvbRange:float() does not handle %d byte floating numbers",tvbr->len);
          return 0;
  }
771}

773/*
* get a Lilliputian float
*/
776WSLUA_METHODstatic int TvbRange_le_float(lua_State* L) {
  /* Get a Little Endian floating point number from a <<lua_class_TvbRange,`TvbRange`>>.
     The range must be 4 or 8 octets long. */
  TvbRange tvbr = checkTvbRange(L,1);
  if (!(tvbr && tvbr->tvb)) return 0;

  switch (tvbr->len) {
      case 4:
          lua_pushnumber(L,tvb_get_letohieee_float(tvbr->tvb->ws_tvb,tvbr->offset));
          return 1;
      case 8:
          lua_pushnumber(L,tvb_get_letohieee_double(tvbr->tvb->ws_tvb,tvbr->offset));
          WSLUA_RETURN(1)return (1); /* The floating point value. */
      default:
          luaL_error(L,"TvbRange:le_float() does not handle %d byte floating numbers",tvbr->len);
          return 0;
  }
793}

795WSLUA_METHODstatic int TvbRange_ipv4(lua_State* L) {
  /* Get an IPv4 Address from a <<lua_class_TvbRange,`TvbRange`>>, as an <<lua_class_Address,`Address`>> object. */
  TvbRange tvbr = checkTvbRange(L,1);
  Address addr;

  if ( !(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  if (tvbr->len != 4) {
      WSLUA_ERROR(TvbRange_ipv4,"The range must be 4 octets long"){ luaL_error(L, "%s%s", "TvbRange_ipv4" ": ", "The range must be 4 octets long"
); };
      return 0;
  }

  addr = g_new(address,1)((address *) g_malloc_n ((1), sizeof (address)));
  alloc_address_tvb(NULL((void*)0),addr,AT_IPv4,sizeof(uint32_t),tvbr->tvb->ws_tvb,tvbr->offset);
  pushAddress(L,addr);

  WSLUA_RETURN(1)return (1); /* The IPv4 <<lua_class_Address,`Address`>> object. */
816}

818WSLUA_METHODstatic int TvbRange_le_ipv4(lua_State* L) {
  /* Get an Little Endian IPv4 Address from a <<lua_class_TvbRange,`TvbRange`>>, as an <<lua_class_Address,`Address`>> object. */
  TvbRange tvbr = checkTvbRange(L,1);
  Address addr;
  uint32_t ip_addr;

  if ( !(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  if (tvbr->len != 4) {
      WSLUA_ERROR(TvbRange_ipv4,"The range must be 4 octets long"){ luaL_error(L, "%s%s", "TvbRange_ipv4" ": ", "The range must be 4 octets long"
); };
      return 0;
  }

  addr = g_new(address,1)((address *) g_malloc_n ((1), sizeof (address)));
  ip_addr = GUINT32_SWAP_LE_BE(tvb_get_ipv4(tvbr->tvb->ws_tvb,tvbr->offset))(((guint32) ( (((guint32) (tvb_get_ipv4(tvbr->tvb->ws_tvb
,tvbr->offset)) & (guint32) 0x000000ffU) << 24) |
 (((guint32) (tvb_get_ipv4(tvbr->tvb->ws_tvb,tvbr->offset
)) & (guint32) 0x0000ff00U) << 8) | (((guint32) (tvb_get_ipv4
(tvbr->tvb->ws_tvb,tvbr->offset)) & (guint32) 0x00ff0000U
) >> 8) | (((guint32) (tvb_get_ipv4(tvbr->tvb->ws_tvb
,tvbr->offset)) & (guint32) 0xff000000U) >> 24))
));
  alloc_address_wmem(NULL((void*)0), addr, AT_IPv4, sizeof(ip_addr), &ip_addr);
  pushAddress(L,addr);

  WSLUA_RETURN(1)return (1); /* The IPv4 <<lua_class_Address,`Address`>> object. */
841}

843WSLUA_METHODstatic int TvbRange_ipv6(lua_State* L) {
  /* Get an IPv6 Address from a <<lua_class_TvbRange,`TvbRange`>>, as an <<lua_class_Address,`Address`>> object. */
  TvbRange tvbr = checkTvbRange(L,1);
  Address addr;

  if ( !(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  if (tvbr->len != 16) {
      WSLUA_ERROR(TvbRange_ipv6,"The range must be 16 octets long"){ luaL_error(L, "%s%s", "TvbRange_ipv6" ": ", "The range must be 16 octets long"
); };
      return 0;
  }

  addr = g_new(address,1)((address *) g_malloc_n ((1), sizeof (address)));
  alloc_address_tvb(NULL((void*)0),addr,AT_IPv6,16,tvbr->tvb->ws_tvb,tvbr->offset);
  pushAddress(L,addr);

  WSLUA_RETURN(1)return (1); /* The IPv6 <<lua_class_Address,`Address`>> object. */
864}

866WSLUA_METHODstatic int TvbRange_ether(lua_State* L) {
  /* Get an Ethernet Address from a <<lua_class_TvbRange,`TvbRange`>>, as an <<lua_class_Address,`Address`>> object. */
  TvbRange tvbr = checkTvbRange(L,1);
  Address addr;

  if ( !(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  if (tvbr->len != 6) {
      WSLUA_ERROR(TvbRange_ether,"The range must be 6 bytes long"){ luaL_error(L, "%s%s", "TvbRange_ether" ": ", "The range must be 6 bytes long"
); };
      return 0;
  }

  addr = g_new(address,1)((address *) g_malloc_n ((1), sizeof (address)));
  alloc_address_tvb(NULL((void*)0),addr,AT_ETHER,6,tvbr->tvb->ws_tvb,tvbr->offset);
  pushAddress(L,addr);

  WSLUA_RETURN(1)return (1); /* The Ethernet <<lua_class_Address,`Address`>> object. */
887}

889WSLUA_METHODstatic int TvbRange_nstime(lua_State* L) {
  /* Obtain a time_t structure from a <<lua_class_TvbRange,`TvbRange`>>, as an <<lua_class_NSTime,`NSTime`>> object. */
891#define WSLUA_OPTARG_TvbRange_nstime_ENCODING2 2 /* An optional ENC_* encoding value to use */
  TvbRange tvbr = checkTvbRange(L,1);
  NSTime nstime;
  const unsigned encoding = (unsigned) luaL_optinteger(L, WSLUA_OPTARG_TvbRange_nstime_ENCODING2, 0);

  if ( !(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  if (encoding & ~ENC_STR_TIME_MASK0x001F0000) {
      WSLUA_OPTARG_ERROR(TvbRange_nstime, ENCODING, "invalid encoding value"){ luaL_argerror(L,2, "TvbRange_nstime" ": " "invalid encoding value"
); };
      return 0;
  }

  nstime = g_new(nstime_t,1)((nstime_t *) g_malloc_n ((1), sizeof (nstime_t)));

  if (encoding == 0) {
      if (tvbr->len == 4) {
        nstime->secs = tvb_get_ntohl(tvbr->tvb->ws_tvb, tvbr->offset);
        nstime->nsecs = 0;
      } else if (tvbr->len == 8) {
        nstime->secs = tvb_get_ntohl(tvbr->tvb->ws_tvb, tvbr->offset);
        nstime->nsecs = tvb_get_ntohl(tvbr->tvb->ws_tvb, tvbr->offset + 4);
      } else {
        g_free(nstime);
        WSLUA_ERROR(TvbRange_nstime,"The range must be 4 or 8 bytes long"){ luaL_error(L, "%s%s", "TvbRange_nstime" ": ", "The range must be 4 or 8 bytes long"
); };
        return 0;
      }
      pushNSTime(L, nstime);
      lua_pushinteger(L, tvbr->len);
  }
  else {
      unsigned endoff = 0;
      nstime_t *retval = tvb_get_string_time(tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len,
                                             encoding, nstime, &endoff);
      if (!retval || endoff == 0) {
          g_free(nstime);
          /* push nil nstime and offset */
          lua_pushnil(L);
          lua_pushnil(L);
      }
      else {
          pushNSTime(L, nstime);
          lua_pushinteger(L, endoff);
      }
  }

  WSLUA_RETURN(2)return (2); /* The <<lua_class_NSTime,`NSTime`>> object and number of bytes used, or nil on failure. */
941}

943WSLUA_METHODstatic int TvbRange_le_nstime(lua_State* L) {
  /* Obtain a nstime from a <<lua_class_TvbRange,`TvbRange`>>, as an <<lua_class_NSTime,`NSTime`>> object. */
  TvbRange tvbr = checkTvbRange(L,1);
  NSTime nstime;

  if ( !(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  nstime = g_new(nstime_t,1)((nstime_t *) g_malloc_n ((1), sizeof (nstime_t)));

  if (tvbr->len == 4) {
    nstime->secs = tvb_get_letohl(tvbr->tvb->ws_tvb, tvbr->offset);
    nstime->nsecs = 0;
  } else if (tvbr->len == 8) {
    nstime->secs = tvb_get_letohl(tvbr->tvb->ws_tvb, tvbr->offset);
    nstime->nsecs = tvb_get_letohl(tvbr->tvb->ws_tvb, tvbr->offset + 4);
  } else {
    g_free(nstime);
    WSLUA_ERROR(TvbRange_nstime,"The range must be 4 or 8 bytes long"){ luaL_error(L, "%s%s", "TvbRange_nstime" ": ", "The range must be 4 or 8 bytes long"
); };
    return 0;
  }

  pushNSTime(L, nstime);

  WSLUA_RETURN(1)return (1); /* The <<lua_class_NSTime,`NSTime`>> object. */
971}

973WSLUA_METHODstatic int TvbRange_string(lua_State* L) {
  /* Obtain a string from a <<lua_class_TvbRange,`TvbRange`>>. */
975#define WSLUA_OPTARG_TvbRange_string_ENCODING2 2 /* The encoding to use. Defaults to ENC_ASCII. */
  TvbRange tvbr = checkTvbRange(L,1);
  unsigned encoding = (unsigned)luaL_optinteger(L,WSLUA_OPTARG_TvbRange_string_ENCODING2, ENC_ASCII0x00000000|ENC_NA0x00000000);
  char * str;

  if ( !(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  str = (char*)tvb_get_string_enc(NULL((void*)0),tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len,encoding);
  lua_pushlstring(L, str, strlen(str));
  wmem_free(NULL((void*)0), str);

  WSLUA_RETURN(1)return (1); /* A string containing all bytes in the <<lua_class_TvbRange,`TvbRange`>> including all zeroes (e.g., "a\000bc\000"). */
991}

993static int TvbRange_ustring_any(lua_State* L, bool_Bool little_endian) {
  /* Obtain a UTF-16 encoded string from a <<lua_class_TvbRange,`TvbRange`>>. */
  TvbRange tvbr = checkTvbRange(L,1);
  char * str;

  if ( !(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  str = (char*)tvb_get_string_enc(NULL((void*)0),tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len,(little_endian ? ENC_UTF_160x00000004|ENC_LITTLE_ENDIAN0x80000000 : ENC_UTF_160x00000004|ENC_BIG_ENDIAN0x00000000));
  lua_pushlstring(L, str, strlen(str));
  wmem_free(NULL((void*)0), str);

  return 1; /* The string */
1009}

1011WSLUA_METHODstatic int TvbRange_ustring(lua_State* L) {
  /* Obtain a Big Endian (network order) UTF-16 encoded string from a <<lua_class_TvbRange,`TvbRange`>>. */
  WSLUA_RETURN(TvbRange_ustring_any(L, false))return (TvbRange_ustring_any(L, 0)); /* A string containing all bytes in the <<lua_class_TvbRange,`TvbRange`>> including all zeroes (e.g., "a\000bc\000"). */
1014}

1016WSLUA_METHODstatic int TvbRange_le_ustring(lua_State* L) {
  /* Obtain a Little Endian UTF-16 encoded string from a <<lua_class_TvbRange,`TvbRange`>>. */
  WSLUA_RETURN(TvbRange_ustring_any(L, true))return (TvbRange_ustring_any(L, 1)); /* A string containing all bytes in the <<lua_class_TvbRange,`TvbRange`>> including all zeroes (e.g., "a\000bc\000"). */
1019}

1021WSLUA_METHODstatic int TvbRange_stringz(lua_State* L) {
  /* Obtain a zero terminated string from a <<lua_class_TvbRange,`TvbRange`>>. */
1023#define WSLUA_OPTARG_TvbRange_stringz_ENCODING2 2 /* The encoding to use. Defaults to ENC_ASCII. */
  TvbRange tvbr = checkTvbRange(L,1);
  unsigned encoding = (unsigned)luaL_optinteger(L,WSLUA_OPTARG_TvbRange_stringz_ENCODING2, ENC_ASCII0x00000000|ENC_NA0x00000000);
  char *str = NULL((void*)0);
  unsigned length;
1
'length' declared without an initial value→
  const char* error = NULL((void*)0);

  if ( !(tvbr1.1
'tvbr' is non-null
 && tvbr->tvb)) return 0;
2
←
Assuming the condition is false→
3
←
Taking false branch→
  if (tvbr->tvb->expired) {
4
←
Assuming field 'expired' is false→
5
←
Taking false branch→
      luaL_error(L,"expired tvb");
      return 0;
  }

  /* XXX - This leaks outside the length of the TvbRange to scan the entire
   * underlying tvbuffer. It has always done that, but that does seem odd. */
  TRY{ except_t *volatile exc; volatile int except_state = 0; static
 const except_id_t catch_spec[] = { { 1, 0 } }; { struct except_stacknode
 except_sn; struct except_catch except_ch; except_setup_try(&
except_sn, &except_ch, catch_spec, 1); if (_setjmp (except_ch
.except_jmp)) *(&exc) = &except_ch.except_obj; else *
(&exc) = 0; if(except_state & 1) except_state |= 2; except_state
 &= ~1; if (except_state == 0 && exc == 0) {
6
←
Assuming the condition is true→
7
←
Taking true branch→
8
←
Taking false branch→
      str = (char*)tvb_get_stringz_enc(NULL((void*)0),tvbr->tvb->ws_tvb,tvbr->offset,&length,encoding);
  } CATCH(DissectorError)if (except_state == 0 && exc != 0 && exc->
except_id.except_code == (6) && (except_state |= 1)) {
9
←
Taking false branch→
10
←
Assuming field 'except_code' is equal to 6→
11
←
Taking true branch→
      /* Presumably an unsupported encoding */
      error = lua_pushstring(L, GET_MESSAGE((exc)->except_message));
  } CATCH_BOUNDS_ERRORSif (except_state == 0 && exc != 0 && (exc->
except_id.except_code == (1) || exc->except_id.except_code
 == (4) || exc->except_id.except_code == (3) || exc->except_id
.except_code == (2) || exc->except_id.except_code == (7)) &&
 (except_state|=1)) {
      error = lua_pushstring(L, "Out of bounds");
  } ENDTRYif(!(except_state&1) && exc != 0) except_rethrow(
exc); except_free(except_ch.except_obj.except_dyndata); except_pop
(); };};

  if (error) {
12
←
Assuming 'error' is null→
13
←
Taking false branch→
      /* By converting the exceptions into Lua errors, we also add
       * the Lua traceback. */
      WSLUA_ERROR(TvbRange_stringz, lua_tostring(L, 1)){ luaL_error(L, "%s%s", "TvbRange_stringz" ": ", lua_tolstring
(L, (1), ((void*)0))); };
      return 0;
  }

  lua_pushstring(L, str);
  wmem_free(NULL((void*)0), str);
  lua_pushinteger(L, length);
14
←
2nd function call argument is an uninitialized value

  WSLUA_RETURN(2)return (2); /* The string containing all bytes in the <<lua_class_TvbRange,`TvbRange`>> up to the first terminating zero, and the length of that string. */
1059}

1061WSLUA_METHODstatic int TvbRange_strsize(lua_State* L) {
  /*
  Find the size of a zero terminated string from a <<lua_class_TvbRange,`TvbRange`>>.
  The size of the string includes the terminating zero. */
1065#define WSLUA_OPTARG_TvbRange_strsize_ENCODING2 2 /* The encoding to use. Defaults to ENC_ASCII. */
  TvbRange tvbr = checkTvbRange(L,1);
  unsigned encoding = (unsigned)luaL_optinteger(L,WSLUA_OPTARG_TvbRange_strsize_ENCODING2, ENC_ASCII0x00000000|ENC_NA0x00000000);
  const char* error = NULL((void*)0);

  if ( !(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  /* XXX - This leaks outside the length of the TvbRange to scan the entire
   * underlying tvbuffer. It has always done that, but that does seem odd. */
  TRY{ except_t *volatile exc; volatile int except_state = 0; static
 const except_id_t catch_spec[] = { { 1, 0 } }; { struct except_stacknode
 except_sn; struct except_catch except_ch; except_setup_try(&
except_sn, &except_ch, catch_spec, 1); if (_setjmp (except_ch
.except_jmp)) *(&exc) = &except_ch.except_obj; else *
(&exc) = 0; if(except_state & 1) except_state |= 2; except_state
 &= ~1; if (except_state == 0 && exc == 0) {
      lua_pushinteger(L, tvb_strsize_enc(tvbr->tvb->ws_tvb, tvbr->offset, encoding));
  } CATCH(DissectorError)if (except_state == 0 && exc != 0 && exc->
except_id.except_code == (6) && (except_state |= 1)) {
      /* Presumably an unsupported encoding */
      error = lua_pushstring(L, GET_MESSAGE((exc)->except_message));
  } CATCH_BOUNDS_ERRORSif (except_state == 0 && exc != 0 && (exc->
except_id.except_code == (1) || exc->except_id.except_code
 == (4) || exc->except_id.except_code == (3) || exc->except_id
.except_code == (2) || exc->except_id.except_code == (7)) &&
 (except_state|=1)) {
      error = lua_pushstring(L, "Out of bounds");
  } ENDTRYif(!(except_state&1) && exc != 0) except_rethrow(
exc); except_free(except_ch.except_obj.except_dyndata); except_pop
(); };};

  if (error) {
      /* By converting the exceptions into Lua errors, we also add
       * the Lua traceback. */
      WSLUA_ERROR(TvbRange_strsize, lua_tostring(L, 1)){ luaL_error(L, "%s%s", "TvbRange_strsize" ": ", lua_tolstring
(L, (1), ((void*)0))); };
      return 0;
  }

  WSLUA_RETURN(1)return (1); /* Length of the zero terminated string. */
1095}


1098static int TvbRange_ustringz_any(lua_State* L, bool_Bool little_endian) {
  /* Obtain a zero terminated string from a TvbRange */
  unsigned count;
  TvbRange tvbr = checkTvbRange(L,1);
  int offset;
  gunichar2 uchar;
  char *str;

  if ( !(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  offset = tvbr->offset;
  do {
    if (!tvb_bytes_exist (tvbr->tvb->ws_tvb, offset, 2)) {
      luaL_error(L,"out of bounds");
      return 0;
    }
    /* Endianness doesn't matter when looking for null */
    uchar = tvb_get_ntohs (tvbr->tvb->ws_tvb, offset);
    offset += 2;
  } while (uchar != 0);

  str = (char*)tvb_get_stringz_enc(NULL((void*)0),tvbr->tvb->ws_tvb,tvbr->offset,&count,
                              (little_endian ? ENC_UTF_160x00000004|ENC_LITTLE_ENDIAN0x80000000 : ENC_UTF_160x00000004|ENC_BIG_ENDIAN0x00000000));
  lua_pushstring(L, str);
  lua_pushinteger(L,count);
  wmem_free(NULL((void*)0), str);

  return 2; /* The zero terminated string, the length found in tvbr */
1130}

1132WSLUA_METHODstatic int TvbRange_ustringz(lua_State* L) {
  /* Obtain a Big Endian (network order) UTF-16 encoded zero terminated string from a <<lua_class_TvbRange,`TvbRange`>>. */
  WSLUA_RETURN(TvbRange_ustringz_any(L, false))return (TvbRange_ustringz_any(L, 0)); /* Two return values: the zero terminated string, and the length. */
1135}

1137WSLUA_METHODstatic int TvbRange_le_ustringz(lua_State* L) {
  /* Obtain a Little Endian UTF-16 encoded zero terminated string from a TvbRange */
  WSLUA_RETURN(TvbRange_ustringz_any(L, true))return (TvbRange_ustringz_any(L, 1)); /* Two return values: the zero terminated string, and the length. */
1140}

1142WSLUA_METHODstatic int TvbRange_bytes(lua_State* L) {
  /* Obtain a <<lua_class_ByteArray,`ByteArray`>> from a <<lua_class_TvbRange,`TvbRange`>>.

     Starting in 1.11.4, this function also takes an optional `encoding` argument,
     which can be set to `ENC_STR_HEX` to decode a hex-string from the <<lua_class_TvbRange,`TvbRange`>>
     into the returned <<lua_class_ByteArray,`ByteArray`>>. The `encoding` can be bitwise-or'ed with one
     or more separator encodings, such as `ENC_SEP_COLON`, to allow separators
     to occur between each pair of hex characters.

     The return value also now returns the number of bytes used as a second return value.

     On failure or error, nil is returned for both return values.

     [NOTE]
     ====
     The encoding type of the hex string should also be set, for example
     `ENC_ASCII` or `ENC_UTF_8`, along with `ENC_STR_HEX`.
     ====
   */
1161#define WSLUA_OPTARG_TvbRange_bytes_ENCODING2 2 /* An optional ENC_* encoding value to use */
  TvbRange tvbr = checkTvbRange(L,1);
  GByteArray* ba;
  uint8_t* raw;
  const unsigned encoding = (unsigned)luaL_optinteger(L, WSLUA_OPTARG_TvbRange_bytes_ENCODING2, 0);


  if ( !(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  if (encoding == 0) {
      ba = g_byte_array_new();
      raw = (uint8_t *)tvb_memdup(NULL((void*)0),tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len);
      g_byte_array_append(ba,raw,tvbr->len);
      wmem_free(NULL((void*)0), raw);
      pushByteArray(L,ba);
      lua_pushinteger(L, tvbr->len);
  }
  else if ((encoding & ENC_STR_HEX0x02000000) == 0) {
      WSLUA_OPTARG_ERROR(TvbRange_nstime, ENCODING, "invalid encoding value"){ luaL_argerror(L,2, "TvbRange_nstime" ": " "invalid encoding value"
); };
  }
  else {
      unsigned endoff = 0;
      GByteArray* retval;

      ba = g_byte_array_new();
      retval = tvb_get_string_bytes(tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len,
                                                encoding, ba, &endoff);
      if (!retval || endoff == 0) {
          g_byte_array_free(ba, true1);
          /* push nil nstime and offset */
          lua_pushnil(L);
          lua_pushnil(L);
      }
      else {
          pushByteArray(L,ba);
          lua_pushinteger(L, endoff);
      }
  }

  WSLUA_RETURN(2)return (2); /* The <<lua_class_ByteArray,`ByteArray`>> object or nil, and number of bytes consumed or nil. */
1205}

1207WSLUA_METHODstatic int TvbRange_bitfield(lua_State* L) {
  /* Get a bitfield from a <<lua_class_TvbRange,`TvbRange`>>. */
1209#define WSLUA_OPTARG_TvbRange_bitfield_POSITION2 2 /* The bit offset (link:https://en.wikipedia.org/wiki/Bit_numbering#MSB_0_bit_numbering[MSB 0 bit numbering]) from the beginning of the <<lua_class_TvbRange,`TvbRange`>>. Defaults to 0. */
1210#define WSLUA_OPTARG_TvbRange_bitfield_LENGTH3 3 /* The length in bits of the field. Defaults to 1. */

  TvbRange tvbr = checkTvbRange(L,1);
  unsigned pos = (unsigned)luaL_optinteger(L,WSLUA_OPTARG_TvbRange_bitfield_POSITION2,0);
  unsigned len = (unsigned)luaL_optinteger(L,WSLUA_OPTARG_TvbRange_bitfield_LENGTH3,1);

  if (!(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  if ((pos+len) > (tvbr->len<<3)) {
      luaL_error(L, "Requested bitfield out of range");
      return 0;
  }

  if (len <= 32) {
      /* XXX - If LUA_INTEGER_SIZE is 4 (on Lua 5.3/5.4 it's usually 8), then
       * for len == 32 an unsigned won't necessarily fit in a lua_Integer.
       * Should we use a UInt64 then?
       */
      WRAP_NON_LUA_EXCEPTIONS({ volatile _Bool has_error = 0; { except_t *volatile exc; volatile
 int except_state = 0; static const except_id_t catch_spec[] =
 { { 1, 0 } }; { struct except_stacknode except_sn; struct except_catch
 except_ch; except_setup_try(&except_sn, &except_ch, catch_spec
, 1); if (_setjmp (except_ch.except_jmp)) *(&exc) = &
except_ch.except_obj; else *(&exc) = 0; if(except_state &
 1) except_state |= 2; except_state &= ~1; if (except_state
 == 0 && exc == 0) { lua_pushinteger(L,tvb_get_bits32
(tvbr->tvb->ws_tvb,tvbr->offset*8 + pos, len, 0)); }
 if (except_state == 0 && exc != 0 && (exc->
except_id.except_code == (1) || exc->except_id.except_code
 == (4) || exc->except_id.except_code == (7)) && (
except_state|=1)) { show_exception(lua_tvb, lua_pinfo, lua_tree
->tree, ((exc)->except_id.except_code), ((exc)->except_message
)); } if (except_state == 0 && exc != 0 && (except_state
|=1)) { show_exception(lua_tvb, lua_pinfo, lua_tree->tree,
 ((exc)->except_id.except_code), ((exc)->except_message
)); lua_pushfstring(L, "%s: %s", __func__, ((exc)->except_message
) ? ((exc)->except_message) : "Malformed packet"); has_error
 = 1; } if(!(except_state&1) && exc != 0) except_rethrow
(exc); except_free(except_ch.except_obj.except_dyndata); except_pop
(); };}; if (has_error) { lua_error(L); } }
          lua_pushinteger(L,tvb_get_bits32(tvbr->tvb->ws_tvb,tvbr->offset*8 + pos, len, false));{ volatile _Bool has_error = 0; { except_t *volatile exc; volatile
 int except_state = 0; static const except_id_t catch_spec[] =
 { { 1, 0 } }; { struct except_stacknode except_sn; struct except_catch
 except_ch; except_setup_try(&except_sn, &except_ch, catch_spec
, 1); if (_setjmp (except_ch.except_jmp)) *(&exc) = &
except_ch.except_obj; else *(&exc) = 0; if(except_state &
 1) except_state |= 2; except_state &= ~1; if (except_state
 == 0 && exc == 0) { lua_pushinteger(L,tvb_get_bits32
(tvbr->tvb->ws_tvb,tvbr->offset*8 + pos, len, 0)); }
 if (except_state == 0 && exc != 0 && (exc->
except_id.except_code == (1) || exc->except_id.except_code
 == (4) || exc->except_id.except_code == (7)) && (
except_state|=1)) { show_exception(lua_tvb, lua_pinfo, lua_tree
->tree, ((exc)->except_id.except_code), ((exc)->except_message
)); } if (except_state == 0 && exc != 0 && (except_state
|=1)) { show_exception(lua_tvb, lua_pinfo, lua_tree->tree,
 ((exc)->except_id.except_code), ((exc)->except_message
)); lua_pushfstring(L, "%s: %s", __func__, ((exc)->except_message
) ? ((exc)->except_message) : "Malformed packet"); has_error
 = 1; } if(!(except_state&1) && exc != 0) except_rethrow
(exc); except_free(except_ch.except_obj.except_dyndata); except_pop
(); };}; if (has_error) { lua_error(L); } }
      ){ volatile _Bool has_error = 0; { except_t *volatile exc; volatile
 int except_state = 0; static const except_id_t catch_spec[] =
 { { 1, 0 } }; { struct except_stacknode except_sn; struct except_catch
 except_ch; except_setup_try(&except_sn, &except_ch, catch_spec
, 1); if (_setjmp (except_ch.except_jmp)) *(&exc) = &
except_ch.except_obj; else *(&exc) = 0; if(except_state &
 1) except_state |= 2; except_state &= ~1; if (except_state
 == 0 && exc == 0) { lua_pushinteger(L,tvb_get_bits32
(tvbr->tvb->ws_tvb,tvbr->offset*8 + pos, len, 0)); }
 if (except_state == 0 && exc != 0 && (exc->
except_id.except_code == (1) || exc->except_id.except_code
 == (4) || exc->except_id.except_code == (7)) && (
except_state|=1)) { show_exception(lua_tvb, lua_pinfo, lua_tree
->tree, ((exc)->except_id.except_code), ((exc)->except_message
)); } if (except_state == 0 && exc != 0 && (except_state
|=1)) { show_exception(lua_tvb, lua_pinfo, lua_tree->tree,
 ((exc)->except_id.except_code), ((exc)->except_message
)); lua_pushfstring(L, "%s: %s", __func__, ((exc)->except_message
) ? ((exc)->except_message) : "Malformed packet"); has_error
 = 1; } if(!(except_state&1) && exc != 0) except_rethrow
(exc); except_free(except_ch.except_obj.except_dyndata); except_pop
(); };}; if (has_error) { lua_error(L); } }
  } else if (len <= 64) {
      WRAP_NON_LUA_EXCEPTIONS({ volatile _Bool has_error = 0; { except_t *volatile exc; volatile
 int except_state = 0; static const except_id_t catch_spec[] =
 { { 1, 0 } }; { struct except_stacknode except_sn; struct except_catch
 except_ch; except_setup_try(&except_sn, &except_ch, catch_spec
, 1); if (_setjmp (except_ch.except_jmp)) *(&exc) = &
except_ch.except_obj; else *(&exc) = 0; if(except_state &
 1) except_state |= 2; except_state &= ~1; if (except_state
 == 0 && exc == 0) { pushUInt64(L,tvb_get_bits64(tvbr
->tvb->ws_tvb,tvbr->offset*8 + pos, len, 0)); } if (
except_state == 0 && exc != 0 && (exc->except_id
.except_code == (1) || exc->except_id.except_code == (4) ||
 exc->except_id.except_code == (7)) && (except_state
|=1)) { show_exception(lua_tvb, lua_pinfo, lua_tree->tree,
 ((exc)->except_id.except_code), ((exc)->except_message
)); } if (except_state == 0 && exc != 0 && (except_state
|=1)) { show_exception(lua_tvb, lua_pinfo, lua_tree->tree,
 ((exc)->except_id.except_code), ((exc)->except_message
)); lua_pushfstring(L, "%s: %s", __func__, ((exc)->except_message
) ? ((exc)->except_message) : "Malformed packet"); has_error
 = 1; } if(!(except_state&1) && exc != 0) except_rethrow
(exc); except_free(except_ch.except_obj.except_dyndata); except_pop
(); };}; if (has_error) { lua_error(L); } }
          pushUInt64(L,tvb_get_bits64(tvbr->tvb->ws_tvb,tvbr->offset*8 + pos, len, false));{ volatile _Bool has_error = 0; { except_t *volatile exc; volatile
 int except_state = 0; static const except_id_t catch_spec[] =
 { { 1, 0 } }; { struct except_stacknode except_sn; struct except_catch
 except_ch; except_setup_try(&except_sn, &except_ch, catch_spec
, 1); if (_setjmp (except_ch.except_jmp)) *(&exc) = &
except_ch.except_obj; else *(&exc) = 0; if(except_state &
 1) except_state |= 2; except_state &= ~1; if (except_state
 == 0 && exc == 0) { pushUInt64(L,tvb_get_bits64(tvbr
->tvb->ws_tvb,tvbr->offset*8 + pos, len, 0)); } if (
except_state == 0 && exc != 0 && (exc->except_id
.except_code == (1) || exc->except_id.except_code == (4) ||
 exc->except_id.except_code == (7)) && (except_state
|=1)) { show_exception(lua_tvb, lua_pinfo, lua_tree->tree,
 ((exc)->except_id.except_code), ((exc)->except_message
)); } if (except_state == 0 && exc != 0 && (except_state
|=1)) { show_exception(lua_tvb, lua_pinfo, lua_tree->tree,
 ((exc)->except_id.except_code), ((exc)->except_message
)); lua_pushfstring(L, "%s: %s", __func__, ((exc)->except_message
) ? ((exc)->except_message) : "Malformed packet"); has_error
 = 1; } if(!(except_state&1) && exc != 0) except_rethrow
(exc); except_free(except_ch.except_obj.except_dyndata); except_pop
(); };}; if (has_error) { lua_error(L); } }
      ){ volatile _Bool has_error = 0; { except_t *volatile exc; volatile
 int except_state = 0; static const except_id_t catch_spec[] =
 { { 1, 0 } }; { struct except_stacknode except_sn; struct except_catch
 except_ch; except_setup_try(&except_sn, &except_ch, catch_spec
, 1); if (_setjmp (except_ch.except_jmp)) *(&exc) = &
except_ch.except_obj; else *(&exc) = 0; if(except_state &
 1) except_state |= 2; except_state &= ~1; if (except_state
 == 0 && exc == 0) { pushUInt64(L,tvb_get_bits64(tvbr
->tvb->ws_tvb,tvbr->offset*8 + pos, len, 0)); } if (
except_state == 0 && exc != 0 && (exc->except_id
.except_code == (1) || exc->except_id.except_code == (4) ||
 exc->except_id.except_code == (7)) && (except_state
|=1)) { show_exception(lua_tvb, lua_pinfo, lua_tree->tree,
 ((exc)->except_id.except_code), ((exc)->except_message
)); } if (except_state == 0 && exc != 0 && (except_state
|=1)) { show_exception(lua_tvb, lua_pinfo, lua_tree->tree,
 ((exc)->except_id.except_code), ((exc)->except_message
)); lua_pushfstring(L, "%s: %s", __func__, ((exc)->except_message
) ? ((exc)->except_message) : "Malformed packet"); has_error
 = 1; } if(!(except_state&1) && exc != 0) except_rethrow
(exc); except_free(except_ch.except_obj.except_dyndata); except_pop
(); };}; if (has_error) { lua_error(L); } }
  } else {
      luaL_error(L,"TvbRange:bitfield() does not handle %d bits",len);
      return 0;
  }

  WSLUA_RETURN(1)return (1); /* The bitfield value */
1245}

1247WSLUA_METHODstatic int TvbRange_range(lua_State* L) {
  /* Creates a sub-<<lua_class_TvbRange,`TvbRange`>> from this <<lua_class_TvbRange,`TvbRange`>>. */
1249#define WSLUA_OPTARG_TvbRange_range_OFFSET2 2 /* The offset (in octets) from the beginning of the <<lua_class_TvbRange,`TvbRange`>>. Defaults to 0. */
1250#define WSLUA_OPTARG_TvbRange_range_LENGTH3 3 /* The length (in octets) of the range. Defaults to until the end of the <<lua_class_TvbRange,`TvbRange`>>. */

  TvbRange tvbr = checkTvbRange(L,1);
  int offset = (int)luaL_optinteger(L,WSLUA_OPTARG_TvbRange_range_OFFSET2,0);
  int len = (int)luaL_optinteger(L,WSLUA_OPTARG_TvbRange_range_LENGTH3,-1);

  if (!(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  if (offset < 0) {
      WSLUA_OPTARG_ERROR(TvbRange_range,OFFSET,"offset before start of TvbRange"){ luaL_argerror(L,2, "TvbRange_range" ": " "offset before start of TvbRange"
); };
      return 0;
  }
  if ((unsigned)offset > tvbr->len) {
      WSLUA_OPTARG_ERROR(TvbRange_range,OFFSET,"offset beyond end of TvbRange"){ luaL_argerror(L,2, "TvbRange_range" ": " "offset beyond end of TvbRange"
); };
      return 0;
  }

  if (len == -1) {
      len = tvbr->len - offset;
  }
  if (len < 0) {
      luaL_error(L,"out of bounds");
      return 0;
  } else if ( (unsigned)(len + offset) > tvbr->len) {
      luaL_error(L,"Range is out of bounds");
      return 0;
  }

  if (push_TvbRange(L,tvbr->tvb->ws_tvb,tvbr->offset+offset,len)) {
      WSLUA_RETURN(1)return (1); /* The <<lua_class_TvbRange,`TvbRange`>>. */
  }

  return 0;
1287}

1289WSLUA_METHODstatic int TvbRange_uncompress_zlib(lua_State* L) {
  /* Given a <<lua_class_TvbRange,`TvbRange`>> containing zlib compressed data, decompresses the data and returns a new <<lua_class_TvbRange,`TvbRange`>> containing the uncompressed data.
   @since 4.3.0
   */
1293#define WSLUA_ARG_TvbRange_uncompress_zlib_NAME2 2 /* The name to be given to the new data-source. */
  TvbRange tvbr = checkTvbRange(L,1);
1295#if defined (HAVE_ZLIB1) || defined (HAVE_ZLIBNG)
  const char* name = luaL_optstring(L,WSLUA_ARG_TvbRange_uncompress_zlib_NAME,"Uncompressed")(luaL_optlstring(L, (2), ("Uncompressed"), ((void*)0)));
  tvbuff_t *uncompr_tvb;
1298#endif

  if (!(tvbr && tvbr->tvb)) return 0;

  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

1307#if defined (HAVE_ZLIB1) || defined (HAVE_ZLIBNG)
  uncompr_tvb = tvb_child_uncompress_zlib(tvbr->tvb->ws_tvb, tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len);
  if (uncompr_tvb) {
     add_new_data_source (lua_pinfo, uncompr_tvb, name);
     if (push_TvbRange(L,uncompr_tvb,0,tvb_captured_length(uncompr_tvb))) {
        WSLUA_RETURN(1)return (1); /* The <<lua_class_TvbRange,`TvbRange`>>. */
     }
  }
1315#else
  luaL_error(L,"Missing support for ZLIB");
1317#endif

  return 0;
1320}

1322WSLUA_METHODstatic int TvbRange_uncompress(lua_State* L) {
  /* Given a <<lua_class_TvbRange,`TvbRange`>> containing zlib compressed data, decompresses the data and returns a new <<lua_class_TvbRange,`TvbRange`>> containing the uncompressed data. Deprecated; use tvbrange:uncompress_zlib() instead. */
1324#define WSLUA_ARG_TvbRange_uncompress_NAME2 2 /* The name to be given to the new data-source. */
  return TvbRange_uncompress_zlib(L);
1326}

1328/* Gets registered as metamethod automatically by WSLUA_REGISTER_CLASS/META */
1329static int TvbRange__gc(lua_State* L) {
  TvbRange tvbr = checkTvbRange(L,1);

  free_TvbRange(tvbr);

  return 0;

1336}

1338WSLUA_METHODstatic int TvbRange_uncompress_brotli(lua_State* L) {
  /* Given a <<lua_class_TvbRange,`TvbRange`>> containing Brotli compressed data, decompresses the data and returns a new <<lua_class_TvbRange,`TvbRange`>> containing the uncompressed data.
   @since 4.3.0
   */
1342#define WSLUA_ARG_TvbRange_uncompress_brotli_NAME2 2 /* The name to be given to the new data-source. */
  TvbRange tvbr = checkTvbRange(L,1);
1344#ifdef HAVE_BROTLI1
  const char* name = luaL_optstring(L,WSLUA_ARG_TvbRange_uncompress_brotli_NAME,"Uncompressed")(luaL_optlstring(L, (2), ("Uncompressed"), ((void*)0)));
  tvbuff_t *uncompr_tvb;
1347#endif

  if (!(tvbr && tvbr->tvb)) return 0;

  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

1356#ifdef HAVE_BROTLI1
  uncompr_tvb = tvb_child_uncompress_brotli(tvbr->tvb->ws_tvb, tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len);
  if (uncompr_tvb) {
     add_new_data_source (lua_pinfo, uncompr_tvb, name);
     if (push_TvbRange(L,uncompr_tvb,0,tvb_captured_length(uncompr_tvb))) {
        WSLUA_RETURN(1)return (1); /* The <<lua_class_TvbRange,`TvbRange`>>. */
     }
  }
1364#else
  luaL_error(L,"Missing support for Brotli");
1366#endif

  return 0;
1369}

1371WSLUA_METHODstatic int TvbRange_uncompress_hpack_huff(lua_State* L) {
  /* Given a <<lua_class_TvbRange,`TvbRange`>> containing data compressed using the Huffman encoding in HTTP/2 HPACK and HTTP/3 QPACK, decompresses the data and returns a new <<lua_class_TvbRange,`TvbRange`>> containing the uncompressed data.
   @since 4.3.0
   */
1375#define WSLUA_ARG_TvbRange_uncompress_hpack_huff_NAME2 2 /* The name to be given to the new data-source. */
  TvbRange tvbr = checkTvbRange(L,1);
  const char* name = luaL_optstring(L,WSLUA_ARG_TvbRange_uncompress_hpack_huff_NAME,"Uncompressed")(luaL_optlstring(L, (2), ("Uncompressed"), ((void*)0)));
  tvbuff_t *uncompr_tvb;

  if (!(tvbr && tvbr->tvb)) return 0;

  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  uncompr_tvb = tvb_child_uncompress_hpack_huff(tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len);
  if (uncompr_tvb) {
     add_new_data_source (lua_pinfo, uncompr_tvb, name);
     if (push_TvbRange(L,uncompr_tvb,0,tvb_captured_length(uncompr_tvb))) {
        WSLUA_RETURN(1)return (1); /* The <<lua_class_TvbRange,`TvbRange`>>. */
     }
  }

  return 0;
1396}

1398WSLUA_METHODstatic int TvbRange_uncompress_lz77(lua_State* L) {
  /* Given a <<lua_class_TvbRange,`TvbRange`>> containing Microsoft Plain LZ77 compressed data, decompresses the data and returns a new <<lua_class_TvbRange,`TvbRange`>> containing the uncompressed data.
   @since 4.3.0
   */
1402#define WSLUA_ARG_TvbRange_uncompress_lz77_NAME2 2 /* The name to be given to the new data-source. */
  TvbRange tvbr = checkTvbRange(L,1);
  const char* name = luaL_optstring(L,WSLUA_ARG_TvbRange_uncompress_lz77_NAME,"Uncompressed")(luaL_optlstring(L, (2), ("Uncompressed"), ((void*)0)));
  tvbuff_t *uncompr_tvb;

  if (!(tvbr && tvbr->tvb)) return 0;

  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  uncompr_tvb = tvb_child_uncompress_lz77(tvbr->tvb->ws_tvb, tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len);
  if (uncompr_tvb) {
     add_new_data_source (lua_pinfo, uncompr_tvb, name);
     if (push_TvbRange(L,uncompr_tvb,0,tvb_captured_length(uncompr_tvb))) {
        WSLUA_RETURN(1)return (1); /* The <<lua_class_TvbRange,`TvbRange`>>. */
     }
  }

  return 0;
1423}

1425WSLUA_METHODstatic int TvbRange_uncompress_lz77huff(lua_State* L) {
  /* Given a <<lua_class_TvbRange,`TvbRange`>> containing Microsoft LZ77+Huffman compressed data, decompresses the data and returns a new <<lua_class_TvbRange,`TvbRange`>> containing the uncompressed data.
   @since 4.3.0
   */
1429#define WSLUA_ARG_TvbRange_uncompress_lz77huff_NAME2 2 /* The name to be given to the new data-source. */
  TvbRange tvbr = checkTvbRange(L,1);
  const char* name = luaL_optstring(L,WSLUA_ARG_TvbRange_uncompress_lz77huff_NAME,"Uncompressed")(luaL_optlstring(L, (2), ("Uncompressed"), ((void*)0)));
  tvbuff_t *uncompr_tvb;

  if (!(tvbr && tvbr->tvb)) return 0;

  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  uncompr_tvb = tvb_child_uncompress_lz77huff(tvbr->tvb->ws_tvb, tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len);
  if (uncompr_tvb) {
     add_new_data_source (lua_pinfo, uncompr_tvb, name);
     if (push_TvbRange(L,uncompr_tvb,0,tvb_captured_length(uncompr_tvb))) {
        WSLUA_RETURN(1)return (1); /* The <<lua_class_TvbRange,`TvbRange`>>. */
     }
  }

  return 0;
1450}

1452WSLUA_METHODstatic int TvbRange_uncompress_lznt1(lua_State* L) {
  /* Given a <<lua_class_TvbRange,`TvbRange`>> containing Microsoft LZNT1 compressed data, decompresses the data and returns a new <<lua_class_TvbRange,`TvbRange`>> containing the uncompressed data.
   @since 4.3.0
   */
1456#define WSLUA_ARG_TvbRange_uncompress_lznt1_NAME2 2 /* The name to be given to the new data-source. */
  TvbRange tvbr = checkTvbRange(L,1);
  const char* name = luaL_optstring(L,WSLUA_ARG_TvbRange_uncompress_lznt1_NAME,"Uncompressed")(luaL_optlstring(L, (2), ("Uncompressed"), ((void*)0)));
  tvbuff_t *uncompr_tvb;

  if (!(tvbr && tvbr->tvb)) return 0;

  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  uncompr_tvb = tvb_child_uncompress_lznt1(tvbr->tvb->ws_tvb, tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len);
  if (uncompr_tvb) {
     add_new_data_source (lua_pinfo, uncompr_tvb, name);
     if (push_TvbRange(L,uncompr_tvb,0,tvb_captured_length(uncompr_tvb))) {
        WSLUA_RETURN(1)return (1); /* The <<lua_class_TvbRange,`TvbRange`>>. */
     }
  }

  return 0;
1477}

1479WSLUA_METHODstatic int TvbRange_uncompress_snappy(lua_State* L) {
  /* Given a <<lua_class_TvbRange,`TvbRange`>> containing Snappy compressed data, decompresses the data and returns a new <<lua_class_TvbRange,`TvbRange`>> containing the uncompressed data.
   @since 4.3.0
   */
1483#define WSLUA_ARG_TvbRange_uncompress_snappy_NAME2 2 /* The name to be given to the new data-source. */
  TvbRange tvbr = checkTvbRange(L,1);
1485#ifdef HAVE_SNAPPY1
  const char* name = luaL_optstring(L,WSLUA_ARG_TvbRange_uncompress_snappy_NAME,"Uncompressed")(luaL_optlstring(L, (2), ("Uncompressed"), ((void*)0)));
  tvbuff_t *uncompr_tvb;
1488#endif

  if (!(tvbr && tvbr->tvb)) return 0;

  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

1497#ifdef HAVE_SNAPPY1
  uncompr_tvb = tvb_child_uncompress_snappy(tvbr->tvb->ws_tvb, tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len);
  if (uncompr_tvb) {
     add_new_data_source (lua_pinfo, uncompr_tvb, name);
     if (push_TvbRange(L,uncompr_tvb,0,tvb_captured_length(uncompr_tvb))) {
        WSLUA_RETURN(1)return (1); /* The <<lua_class_TvbRange,`TvbRange`>>. */
     }
  }
1505#else
  luaL_error(L,"Missing support for Snappy");
1507#endif

  return 0;
1510}

1512WSLUA_METHODstatic int TvbRange_uncompress_zstd(lua_State* L) {
  /* Given a <<lua_class_TvbRange,`TvbRange`>> containing Zstandard compressed data, decompresses the data and returns a new <<lua_class_TvbRange,`TvbRange`>> containing the uncompressed data.
   @since 4.3.0
   */
1516#define WSLUA_ARG_TvbRange_uncompress_zstd_NAME2 2 /* The name to be given to the new data-source. */
  TvbRange tvbr = checkTvbRange(L,1);
1518#ifdef HAVE_ZSTD1
  const char* name = luaL_optstring(L,WSLUA_ARG_TvbRange_uncompress_zstd_NAME,"Uncompressed")(luaL_optlstring(L, (2), ("Uncompressed"), ((void*)0)));
  tvbuff_t *uncompr_tvb;
1521#endif

  if (!(tvbr && tvbr->tvb)) return 0;

  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

1530#ifdef HAVE_ZSTD1
  uncompr_tvb = tvb_child_uncompress_zstd(tvbr->tvb->ws_tvb, tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len);
  if (uncompr_tvb) {
     add_new_data_source (lua_pinfo, uncompr_tvb, name);
     if (push_TvbRange(L,uncompr_tvb,0,tvb_captured_length(uncompr_tvb))) {
        WSLUA_RETURN(1)return (1); /* The <<lua_class_TvbRange,`TvbRange`>>. */
     }
  }
1538#else
  luaL_error(L,"Missing support for ZStandard");
1540#endif

  return 0;
1543}

1545WSLUA_METHODstatic int TvbRange_decode_base64(lua_State* L) {
  /* Given a <<lua_class_TvbRange,`TvbRange`>> containing Base64 encoded data, return a new <<lua_class_TvbRange,`TvbRange`>> containing the decoded data.
   @since 4.3.0
   */
1549#define WSLUA_ARG_TvbRange_decode_base64_NAME2 2 /* The name to be given to the new data-source. */
  TvbRange tvbr = checkTvbRange(L,1);
  const char* name = luaL_optstring(L,WSLUA_ARG_TvbRange_decode_base64_NAME,"Decoded")(luaL_optlstring(L, (2), ("Decoded"), ((void*)0)));
  tvbuff_t *decoded_tvb;

  if (!(tvbr && tvbr->tvb)) return 0;

  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  decoded_tvb = base64_tvb_to_new_tvb(tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len);
  if (decoded_tvb) {
     add_new_data_source (lua_pinfo, decoded_tvb, name);
     if (push_TvbRange(L,decoded_tvb,0,tvb_captured_length(decoded_tvb))) {
        WSLUA_RETURN(1)return (1); /* The <<lua_class_TvbRange,`TvbRange`>>. */
     }
  }

  return 0;
1570}

1572WSLUA_METHODstatic int TvbRange_decode_base64url(lua_State* L) {
  /* Given a <<lua_class_TvbRange,`TvbRange`>> containing base64url encoded data, return a new <<lua_class_TvbRange,`TvbRange`>> containing the decoded data.
   @since 4.3.0
   */
1576#define WSLUA_ARG_TvbRange_decode_base64url_NAME2 2 /* The name to be given to the new data-source. */
  TvbRange tvbr = checkTvbRange(L,1);
  const char* name = luaL_optstring(L,WSLUA_ARG_TvbRange_decode_base64url_NAME,"Decoded")(luaL_optlstring(L, (2), ("Decoded"), ((void*)0)));
  tvbuff_t *decoded_tvb;

  if (!(tvbr && tvbr->tvb)) return 0;

  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  decoded_tvb = base64uri_tvb_to_new_tvb(tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len);
  if (decoded_tvb) {
     add_new_data_source (lua_pinfo, decoded_tvb, name);
     if (push_TvbRange(L,decoded_tvb,0,tvb_captured_length(decoded_tvb))) {
        WSLUA_RETURN(1)return (1); /* The <<lua_class_TvbRange,`TvbRange`>>. */
     }
  }

  return 0;
1597}

1599WSLUA_METHODstatic int TvbRange_len(lua_State* L) {
  /* Obtain the length of a <<lua_class_TvbRange,`TvbRange`>>. */
  TvbRange tvbr = checkTvbRange(L,1);

  if (!(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }
  lua_pushinteger(L,(lua_Integer)tvbr->len);
  return 1;
1610}

1612WSLUA_METHODstatic int TvbRange_offset(lua_State* L) {
  /* Obtain the offset in a <<lua_class_TvbRange,`TvbRange`>>. */
  TvbRange tvbr = checkTvbRange(L,1);

  if (!(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }
  lua_pushinteger(L,(lua_Integer)tvbr->offset);
  return 1;
1623}

1625WSLUA_METHODstatic int TvbRange_raw(lua_State* L) {
  /* Obtain a Lua string of the binary bytes in a <<lua_class_TvbRange,`TvbRange`>>. */
1627#define WSLUA_OPTARG_TvbRange_raw_OFFSET2 2 /* The position of the first byte within the range. Default is 0, or first byte. */
1628#define WSLUA_OPTARG_TvbRange_raw_LENGTH3 3 /* The length of the segment to get. Default is -1, or the remaining bytes in the range. */
  TvbRange tvbr = checkTvbRange(L,1);
  int offset = (int)luaL_optinteger(L,WSLUA_OPTARG_TvbRange_raw_OFFSET2,0);
  int len = (int)luaL_optinteger(L,WSLUA_OPTARG_TvbRange_raw_LENGTH3,-1);

  if (!tvbr || !tvbr->tvb) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  if (offset < 0) {
      WSLUA_OPTARG_ERROR(TvbRange_raw,OFFSET,"offset before start of TvbRange"){ luaL_argerror(L,2, "TvbRange_raw" ": " "offset before start of TvbRange"
); };
      return 0;
  }
  if ((unsigned)offset > tvbr->len) {
      WSLUA_OPTARG_ERROR(TvbRange_raw,OFFSET,"offset beyond end of TvbRange"){ luaL_argerror(L,2, "TvbRange_raw" ": " "offset beyond end of TvbRange"
); };
      return 0;
  }

  if (len == -1) {
      len = tvbr->len - offset;
  }
  if (len < 0) {
      luaL_error(L,"out of bounds");
      return false0;
  } else if ( (unsigned)(len + offset) > tvbr->len) {
      luaL_error(L,"Range is out of bounds");
      return false0;
  }

  lua_pushlstring(L, (const char*)tvb_get_ptr(tvbr->tvb->ws_tvb, tvbr->offset+offset, len), len);

  WSLUA_RETURN(1)return (1); /* A Lua string of the binary bytes in the <<lua_class_TvbRange,`TvbRange`>>. */
1662}

1664WSLUA_METAMETHODstatic int TvbRange__eq(lua_State* L) {
  /* Checks whether the contents of two <<lua_class_TvbRange,`TvbRange`>>s are equal. */
  TvbRange tvb_l = checkTvbRange(L,1);
  TvbRange tvb_r = checkTvbRange(L,2);

  /* it is not an error if their ds_tvb are different... they're just not equal */
  if (tvb_l->len == tvb_r->len &&
      tvb_l->len <= tvb_captured_length_remaining(tvb_l->tvb->ws_tvb, tvb_l->offset) &&
      tvb_r->len <= tvb_captured_length_remaining(tvb_r->tvb->ws_tvb, tvb_r->offset))
  {
      const char* lp = (const char*)tvb_get_ptr(tvb_l->tvb->ws_tvb, tvb_l->offset, tvb_l->len);
      const char* rp = (const char*)tvb_get_ptr(tvb_r->tvb->ws_tvb, tvb_r->offset, tvb_r->len);
      unsigned i = 0;

      for (; i < tvb_r->len; ++i) {
          if (lp[i] != rp[i]) {
              lua_pushboolean(L,0);
              return 1;
          }
      }
      lua_pushboolean(L,1);
  } else {
      lua_pushboolean(L,0);
  }

  return 1;
1690}

1692WSLUA_METAMETHODstatic int TvbRange__tostring(lua_State* L) {
  /*
  Converts the <<lua_class_TvbRange,`TvbRange`>> into a string.
  The string can be truncated, so this is primarily useful for debugging or in cases where truncation is preferred, e.g. "67:89:AB:...".
  */
  TvbRange tvbr = checkTvbRange(L,1);
  char* str = NULL((void*)0);

  if (!(tvbr && tvbr->tvb)) return 0;
  if (tvbr->tvb->expired) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  if (tvbr->len == 0) {
      lua_pushstring(L, "<EMPTY>");
  } else {
      str = tvb_bytes_to_str(NULL((void*)0),tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len);
      lua_pushstring(L,str);
      wmem_free(NULL((void*)0), str);
  }

  WSLUA_RETURN(1)return (1); /* A Lua hex string of the <<lua_class_TvbRange,`TvbRange`>> truncated to 24 bytes. */
1715}

1717WSLUA_METHODSstatic const luaL_Reg TvbRange_methods[] = {
  WSLUA_CLASS_FNREG(TvbRange,uint){ "uint", TvbRange_uint },
  WSLUA_CLASS_FNREG(TvbRange,le_uint){ "le_uint", TvbRange_le_uint },
  WSLUA_CLASS_FNREG(TvbRange,int){ "int", TvbRange_int },
  WSLUA_CLASS_FNREG(TvbRange,le_int){ "le_int", TvbRange_le_int },
  WSLUA_CLASS_FNREG(TvbRange,uint64){ "uint64", TvbRange_uint64 },
  WSLUA_CLASS_FNREG(TvbRange,le_uint64){ "le_uint64", TvbRange_le_uint64 },
  WSLUA_CLASS_FNREG(TvbRange,int64){ "int64", TvbRange_int64 },
  WSLUA_CLASS_FNREG(TvbRange,le_int64){ "le_int64", TvbRange_le_int64 },
  WSLUA_CLASS_FNREG(TvbRange,float){ "float", TvbRange_float },
  WSLUA_CLASS_FNREG(TvbRange,le_float){ "le_float", TvbRange_le_float },
  WSLUA_CLASS_FNREG(TvbRange,ether){ "ether", TvbRange_ether },
  WSLUA_CLASS_FNREG(TvbRange,ipv4){ "ipv4", TvbRange_ipv4 },
  WSLUA_CLASS_FNREG(TvbRange,le_ipv4){ "le_ipv4", TvbRange_le_ipv4 },
  WSLUA_CLASS_FNREG(TvbRange,ipv6){ "ipv6", TvbRange_ipv6 },
  WSLUA_CLASS_FNREG(TvbRange,nstime){ "nstime", TvbRange_nstime },
  WSLUA_CLASS_FNREG(TvbRange,le_nstime){ "le_nstime", TvbRange_le_nstime },
  WSLUA_CLASS_FNREG(TvbRange,string){ "string", TvbRange_string },
  WSLUA_CLASS_FNREG(TvbRange,stringz){ "stringz", TvbRange_stringz },
  WSLUA_CLASS_FNREG(TvbRange,strsize){ "strsize", TvbRange_strsize },
  WSLUA_CLASS_FNREG(TvbRange,bytes){ "bytes", TvbRange_bytes },
  WSLUA_CLASS_FNREG(TvbRange,bitfield){ "bitfield", TvbRange_bitfield },
  WSLUA_CLASS_FNREG(TvbRange,range){ "range", TvbRange_range },
  WSLUA_CLASS_FNREG(TvbRange,len){ "len", TvbRange_len },
  WSLUA_CLASS_FNREG(TvbRange,offset){ "offset", TvbRange_offset },
  WSLUA_CLASS_FNREG(TvbRange,tvb){ "tvb", TvbRange_tvb },
  WSLUA_CLASS_FNREG(TvbRange,le_ustring){ "le_ustring", TvbRange_le_ustring },
  WSLUA_CLASS_FNREG(TvbRange,ustring){ "ustring", TvbRange_ustring },
  WSLUA_CLASS_FNREG(TvbRange,le_ustringz){ "le_ustringz", TvbRange_le_ustringz },
  WSLUA_CLASS_FNREG(TvbRange,ustringz){ "ustringz", TvbRange_ustringz },
  WSLUA_CLASS_FNREG(TvbRange,uncompress){ "uncompress", TvbRange_uncompress },
  WSLUA_CLASS_FNREG(TvbRange,uncompress_zlib){ "uncompress_zlib", TvbRange_uncompress_zlib },
  WSLUA_CLASS_FNREG(TvbRange,uncompress_brotli){ "uncompress_brotli", TvbRange_uncompress_brotli },
  WSLUA_CLASS_FNREG(TvbRange,uncompress_hpack_huff){ "uncompress_hpack_huff", TvbRange_uncompress_hpack_huff },
  WSLUA_CLASS_FNREG(TvbRange,uncompress_lz77){ "uncompress_lz77", TvbRange_uncompress_lz77 },
  WSLUA_CLASS_FNREG(TvbRange,uncompress_lz77huff){ "uncompress_lz77huff", TvbRange_uncompress_lz77huff },
  WSLUA_CLASS_FNREG(TvbRange,uncompress_lznt1){ "uncompress_lznt1", TvbRange_uncompress_lznt1 },
  WSLUA_CLASS_FNREG(TvbRange,uncompress_snappy){ "uncompress_snappy", TvbRange_uncompress_snappy },
  WSLUA_CLASS_FNREG(TvbRange,uncompress_zstd){ "uncompress_zstd", TvbRange_uncompress_zstd },
  WSLUA_CLASS_FNREG(TvbRange,decode_base64){ "decode_base64", TvbRange_decode_base64 },
  WSLUA_CLASS_FNREG(TvbRange,decode_base64url){ "decode_base64url", TvbRange_decode_base64url },
  WSLUA_CLASS_FNREG(TvbRange,raw){ "raw", TvbRange_raw },
  { NULL((void*)0), NULL((void*)0) }
1760};

1762WSLUA_METAstatic const luaL_Reg TvbRange_meta[] = {
  WSLUA_CLASS_MTREG(TvbRange,tostring){ "__" "tostring", TvbRange__tostring },
  WSLUA_CLASS_MTREG(wslua,concat){ "__" "concat", wslua__concat },
  WSLUA_CLASS_MTREG(TvbRange,eq){ "__" "eq", TvbRange__eq },
  {"__call", TvbRange_range},
  { NULL((void*)0), NULL((void*)0) }
1768};

1770int TvbRange_register(lua_State* L) {
  if (outstanding_TvbRange != NULL((void*)0)) {
      g_ptr_array_unref(outstanding_TvbRange);
  }
  outstanding_TvbRange = g_ptr_array_new();
  WSLUA_REGISTER_CLASS(TvbRange){ const wslua_class TvbRange_class = { .name = "TvbRange", .class_methods
 = TvbRange_methods, .class_meta = TvbRange_meta, .instance_methods
 = TvbRange_methods, .instance_meta = TvbRange_meta, .attrs =
 ((void*)0) }; wslua_register_class(L, &TvbRange_class); (
lua_getfield(L, (-1000000 - 1000), ("TvbRange"))); lua_pushcclosure
(L, (TvbRange__gc), 0); lua_setfield(L, -2, "__gc"); lua_settop
(L, -(1)-1); };
  return 0;
1777}

1779/*
* Editor modelines  -  https://www.wireshark.org/tools/modelines.html
*
* Local variables:
* c-basic-offset: 4
* tab-width: 8
* indent-tabs-mode: nil
* End:
*
* vi: set shiftwidth=4 tabstop=8 expandtab:
* :indentSize=4:tabSize=8:noTabs=true:
*/