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

Bug Summary

File:	builds/wireshark/wireshark/epan/wslua/wslua_tvb.c
Warning:	line 1092, 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-04-20-100401-3641-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}


116/* WSLUA_ATTRIBUTE Tvb_captured_length RO The captured length of the Tvb
 (amount saved in the capture process). Mirrors `tvb:captured_len()`. */
118WSLUA_ATTRIBUTE_GET(Tvb,captured_length, {static int Tvb_get_captured_length (lua_State* L) { Tvb obj =
 checkTvb (L,1); { lua_pushinteger(L, tvb_captured_length(obj
->ws_tvb));} return 1; } typedef void __dummyTvb_get_captured_length
  lua_pushinteger(L, tvb_captured_length(obj->ws_tvb));static int Tvb_get_captured_length (lua_State* L) { Tvb obj =
 checkTvb (L,1); { lua_pushinteger(L, tvb_captured_length(obj
->ws_tvb));} return 1; } typedef void __dummyTvb_get_captured_length
120})static int Tvb_get_captured_length (lua_State* L) { Tvb obj =
 checkTvb (L,1); { lua_pushinteger(L, tvb_captured_length(obj
->ws_tvb));} return 1; } typedef void __dummyTvb_get_captured_length;

122/* WSLUA_ATTRIBUTE Tvb_reported_length RO The reported length of the Tvb
 (length on the network). Mirrors `tvb:reported_len()`. */
124WSLUA_ATTRIBUTE_GET(Tvb,reported_length, {static int Tvb_get_reported_length (lua_State* L) { Tvb obj =
 checkTvb (L,1); { lua_pushinteger(L, tvb_reported_length(obj
->ws_tvb));} return 1; } typedef void __dummyTvb_get_reported_length
  lua_pushinteger(L, tvb_reported_length(obj->ws_tvb));static int Tvb_get_reported_length (lua_State* L) { Tvb obj =
 checkTvb (L,1); { lua_pushinteger(L, tvb_reported_length(obj
->ws_tvb));} return 1; } typedef void __dummyTvb_get_reported_length
126})static int Tvb_get_reported_length (lua_State* L) { Tvb obj =
 checkTvb (L,1); { lua_pushinteger(L, tvb_reported_length(obj
->ws_tvb));} return 1; } typedef void __dummyTvb_get_reported_length;

128/* WSLUA_ATTRIBUTE Tvb_raw_offset RO The raw offset of this (sub) Tvb in its
 source Tvb. Mirrors `tvb:offset()`. */
130WSLUA_ATTRIBUTE_GET(Tvb,raw_offset, {static int Tvb_get_raw_offset (lua_State* L) { Tvb obj = checkTvb
 (L,1); { lua_pushinteger(L, tvb_raw_offset(obj->ws_tvb));
} return 1; } typedef void __dummyTvb_get_raw_offset
  lua_pushinteger(L, tvb_raw_offset(obj->ws_tvb));static int Tvb_get_raw_offset (lua_State* L) { Tvb obj = checkTvb
 (L,1); { lua_pushinteger(L, tvb_raw_offset(obj->ws_tvb));
} return 1; } typedef void __dummyTvb_get_raw_offset
132})static int Tvb_get_raw_offset (lua_State* L) { Tvb obj = checkTvb
 (L,1); { lua_pushinteger(L, tvb_raw_offset(obj->ws_tvb));
} return 1; } typedef void __dummyTvb_get_raw_offset;

134WSLUA_METAMETHODstatic int Tvb__tostring(lua_State* L) {
  /*
  Convert the bytes of a <<lua_class_Tvb,`Tvb`>> into a string of
  the form `Tvb: captured=<C> reported=<R> bytes=<hex>`.
  The hex preview is automatically truncated by `tvb_bytes_to_str`
  to a small number of bytes (currently 36) so the rendering stays
  useful in the debugger Variables view and in `print()` for large
  packets.
  */
  Tvb tvb = checkTvb(L,1);
  int captured = tvb_captured_length(tvb->ws_tvb);
  int reported = tvb_reported_length(tvb->ws_tvb);
  char* str = tvb_bytes_to_str(NULL((void*)0), tvb->ws_tvb, 0, captured);

  lua_pushfstring(L, "Tvb: captured=%d reported=%d bytes=%s",
                  captured, reported, str ? str : "");

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

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

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

  free_Tvb(tvb);

  return 0;

164}

166WSLUA_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`>>. */
172}

174WSLUA_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`>>. */
180}

182WSLUA_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`>>. */
189}

191WSLUA_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`>>. */
194#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`>>. */
200}

202WSLUA_METHODstatic int Tvb_bytes(lua_State* L) {
  /* Obtain a <<lua_class_ByteArray,`ByteArray`>> from a <<lua_class_Tvb,`Tvb`>>. */
204#define WSLUA_OPTARG_Tvb_bytes_OFFSET2 2 /* The offset (in octets) from the beginning of the <<lua_class_Tvb,`Tvb`>>. Defaults to 0. */
205#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;
208#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);
211#else
  int offset = luaL_optint(L, WSLUA_OPTARG_Tvb_bytes_OFFSET2, 0);
  int len = luaL_optint(L,WSLUA_OPTARG_Tvb_bytes_LENGTH3,-1);
214#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. */
239}

241WSLUA_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`>>. */
247}


250#if USED_FOR_DOC_PURPOSES
251WSLUA_METAMETHODstatic int Tvb__call(lua_State* L) {
  /* Equivalent to tvb:range(...) */
  return 0;
254}
255#endif


258WSLUA_METHODstatic int Tvb_range(lua_State* L) {
  /* Creates a <<lua_class_TvbRange,`TvbRange`>> from this <<lua_class_Tvb,`Tvb`>>. */
260#define WSLUA_OPTARG_Tvb_range_OFFSET2 2 /* The offset (in octets) from the beginning of the <<lua_class_Tvb,`Tvb`>>. Defaults to 0. */
261#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;
272}

274WSLUA_METHODstatic int Tvb_raw(lua_State* L) {
  /* Obtain a Lua string of the binary bytes in a <<lua_class_Tvb,`Tvb`>>. */
276#define WSLUA_OPTARG_Tvb_raw_OFFSET2 2 /* The position of the first byte. Default is 0, or the first byte. */
277#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`>>. */
307}

309WSLUA_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;
331}

333WSLUA_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) }
343};

345WSLUA_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) }
350};

352/* Read-only attributes. Registered so the Lua debugger can expand a Tvb
* in the Variables view without having to invoke methods. The attribute
* names intentionally differ from the corresponding method names to
* avoid the attribute/method collision check performed by
* wslua_push_attributes. */
357WSLUA_ATTRIBUTESstatic const wslua_attribute_table Tvb_attributes[] = {
  WSLUA_ATTRIBUTE_ROREG(Tvb,captured_length){ "captured_length", Tvb_get_captured_length, ((void*)0) },
  WSLUA_ATTRIBUTE_ROREG(Tvb,reported_length){ "reported_length", Tvb_get_reported_length, ((void*)0) },
  WSLUA_ATTRIBUTE_ROREG(Tvb,raw_offset){ "raw_offset", Tvb_get_raw_offset, ((void*)0) },
  { NULL((void*)0), NULL((void*)0), NULL((void*)0) }
362};

364int Tvb_register(lua_State* L) {
  WSLUA_REGISTER_CLASS_WITH_ATTRS(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 = Tvb_attributes }; 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;
371}




376WSLUA_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.
  */

385static 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);
  }
394}

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


404bool_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;
443}


446WSLUA_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;
  }
468}


471/*
*  get a Blefuscuoan unsigned integer from a tvb
*/
474WSLUA_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;
  }
501}

503/*
*  get a Lilliputian unsigned integer from a tvb
*/
506WSLUA_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;
  }
534}

536/*
*  get a Blefuscuoan unsigned 64 bit integer from a tvb
*/
539WSLUA_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;
  }
578}

580/*
*  get a Lilliputian unsigned 64 bit integer from a tvb
*/
583WSLUA_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;
  }
622}

624/*
*  get a Blefuscuoan signed integer from a tvb
*/
627WSLUA_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;
  }
661}

663/*
*  get a Lilliputian signed integer from a tvb
*/
666WSLUA_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;
  }
693}

695/*
*  get a Blefuscuoan signed 64 bit integer from a tvb
*/
698WSLUA_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;
  }
737}

739/*
*  get a Lilliputian signed 64 bit integer from a tvb
*/
742WSLUA_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;
  }
781}

783/*
*  get a Blefuscuoan float
*/
786WSLUA_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;
  }
807}

809/*
* get a Lilliputian float
*/
812WSLUA_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;
  }
829}

831WSLUA_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. */
852}

854WSLUA_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. */
877}

879WSLUA_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. */
900}

902WSLUA_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. */
923}

925WSLUA_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. */
927#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. */
977}

979WSLUA_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. */
1007}

1009WSLUA_METHODstatic int TvbRange_string(lua_State* L) {
  /* Obtain a string from a <<lua_class_TvbRange,`TvbRange`>>. */
1011#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"). */
1027}

1029static 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 */
1045}

1047WSLUA_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"). */
1050}

1052WSLUA_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"). */
1055}

1057WSLUA_METHODstatic int TvbRange_stringz(lua_State* L) {
  /* Obtain a zero terminated string from a <<lua_class_TvbRange,`TvbRange`>>. */
1059#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. */
1095}

1097WSLUA_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. */
1101#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. */
1131}


1134static 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 */
1166}

1168WSLUA_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. */
1171}

1173WSLUA_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. */
1176}

1178WSLUA_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`.
     ====
   */
1197#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. */
1241}

1243WSLUA_METHODstatic int TvbRange_bitfield(lua_State* L) {
  /* Get a bitfield from a <<lua_class_TvbRange,`TvbRange`>>. */
1245#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. */
1246#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 */
1281}

1283WSLUA_METHODstatic int TvbRange_range(lua_State* L) {
  /* Creates a sub-<<lua_class_TvbRange,`TvbRange`>> from this <<lua_class_TvbRange,`TvbRange`>>. */
1285#define WSLUA_OPTARG_TvbRange_range_OFFSET2 2 /* The offset (in octets) from the beginning of the <<lua_class_TvbRange,`TvbRange`>>. Defaults to 0. */
1286#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;
1323}

1325WSLUA_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
   */
1329#define WSLUA_ARG_TvbRange_uncompress_zlib_NAME2 2 /* The name to be given to the new data-source. */
  TvbRange tvbr = checkTvbRange(L,1);
1331#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;
1334#endif

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

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

1343#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`>>. */
     }
  }
1351#else
  luaL_error(L,"Missing support for ZLIB");
1353#endif

  return 0;
1356}

1358WSLUA_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. */
1360#define WSLUA_ARG_TvbRange_uncompress_NAME2 2 /* The name to be given to the new data-source. */
  return TvbRange_uncompress_zlib(L);
1362}

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

  free_TvbRange(tvbr);

  return 0;

1372}

1374WSLUA_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
   */
1378#define WSLUA_ARG_TvbRange_uncompress_brotli_NAME2 2 /* The name to be given to the new data-source. */
  TvbRange tvbr = checkTvbRange(L,1);
1380#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;
1383#endif

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

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

1392#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`>>. */
     }
  }
1400#else
  luaL_error(L,"Missing support for Brotli");
1402#endif

  return 0;
1405}

1407WSLUA_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
   */
1411#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;
1432}

1434WSLUA_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
   */
1438#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;
1459}

1461WSLUA_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
   */
1465#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;
1486}

1488WSLUA_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
   */
1492#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;
1513}

1515WSLUA_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
   */
1519#define WSLUA_ARG_TvbRange_uncompress_snappy_NAME2 2 /* The name to be given to the new data-source. */
  TvbRange tvbr = checkTvbRange(L,1);
1521#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;
1524#endif

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

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

1533#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`>>. */
     }
  }
1541#else
  luaL_error(L,"Missing support for Snappy");
1543#endif

  return 0;
1546}

1548WSLUA_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
   */
1552#define WSLUA_ARG_TvbRange_uncompress_zstd_NAME2 2 /* The name to be given to the new data-source. */
  TvbRange tvbr = checkTvbRange(L,1);
1554#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;
1557#endif

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

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

1566#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`>>. */
     }
  }
1574#else
  luaL_error(L,"Missing support for ZStandard");
1576#endif

  return 0;
1579}

1581WSLUA_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
   */
1585#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;
1606}

1608WSLUA_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
   */
1612#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;
1633}

1635WSLUA_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;
1646}

1648WSLUA_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;
1659}

1661WSLUA_METHODstatic int TvbRange_raw(lua_State* L) {
  /* Obtain a Lua string of the binary bytes in a <<lua_class_TvbRange,`TvbRange`>>. */
1663#define WSLUA_OPTARG_TvbRange_raw_OFFSET2 2 /* The position of the first byte within the range. Default is 0, or first byte. */
1664#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`>>. */
1698}

1700/* WSLUA_ATTRIBUTE TvbRange_length RO The length (in bytes) of the range.
 Mirrors `range:len()`. */
1702WSLUA_ATTRIBUTE_GET(TvbRange,length, {static int TvbRange_get_length (lua_State* L) { TvbRange obj =
 checkTvbRange (L,1); { lua_pushinteger(L, (lua_Integer)obj->
len);} return 1; } typedef void __dummyTvbRange_get_length
  lua_pushinteger(L, (lua_Integer)obj->len);static int TvbRange_get_length (lua_State* L) { TvbRange obj =
 checkTvbRange (L,1); { lua_pushinteger(L, (lua_Integer)obj->
len);} return 1; } typedef void __dummyTvbRange_get_length
1704})static int TvbRange_get_length (lua_State* L) { TvbRange obj =
 checkTvbRange (L,1); { lua_pushinteger(L, (lua_Integer)obj->
len);} return 1; } typedef void __dummyTvbRange_get_length;

1706/* WSLUA_ATTRIBUTE TvbRange_position RO The offset within the parent Tvb at
 which the range starts. Mirrors `range:offset()`. */
1708WSLUA_ATTRIBUTE_GET(TvbRange,position, {static int TvbRange_get_position (lua_State* L) { TvbRange obj
 = checkTvbRange (L,1); { lua_pushinteger(L, (lua_Integer)obj
->offset);} return 1; } typedef void __dummyTvbRange_get_position
  lua_pushinteger(L, (lua_Integer)obj->offset);static int TvbRange_get_position (lua_State* L) { TvbRange obj
 = checkTvbRange (L,1); { lua_pushinteger(L, (lua_Integer)obj
->offset);} return 1; } typedef void __dummyTvbRange_get_position
1710})static int TvbRange_get_position (lua_State* L) { TvbRange obj
 = checkTvbRange (L,1); { lua_pushinteger(L, (lua_Integer)obj
->offset);} return 1; } typedef void __dummyTvbRange_get_position;

1712WSLUA_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;
1738}

1740WSLUA_METAMETHODstatic int TvbRange__tostring(lua_State* L) {
  /*
  Converts the <<lua_class_TvbRange,`TvbRange`>> into a string of
  the form `TvbRange: offset=<O> length=<L> bytes=<hex>`. The hex
  preview is truncated by `tvb_bytes_to_str` to a small number of
  bytes so the rendering stays useful in the debugger Variables
  view and in `print()` for large ranges. Empty ranges render as
  `TvbRange: offset=<O> length=0 (empty)`.
  */
  TvbRange tvbr = checkTvbRange(L,1);

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

  if (tvbr->len == 0) {
      lua_pushfstring(L, "TvbRange: offset=%d length=0 (empty)",
                      tvbr->offset);
  } else {
      char *str = tvb_bytes_to_str(NULL((void*)0), tvbr->tvb->ws_tvb,
                                   tvbr->offset, tvbr->len);
      lua_pushfstring(L, "TvbRange: offset=%d length=%d bytes=%s",
                      tvbr->offset, tvbr->len, str ? str : "");
      wmem_free(NULL((void*)0), str);
  }

  WSLUA_RETURN(1)return (1); /* A short label including the offset, length,
                      and a truncated hex preview. */
1770}

1772WSLUA_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) }
1815};

1817WSLUA_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) }
1823};

1825/* Read-only attributes for debugger introspection; see the comment on
* Tvb_attributes for the naming rationale. */
1827WSLUA_ATTRIBUTESstatic const wslua_attribute_table TvbRange_attributes[] = {
  WSLUA_ATTRIBUTE_ROREG(TvbRange,length){ "length", TvbRange_get_length, ((void*)0) },
  WSLUA_ATTRIBUTE_ROREG(TvbRange,position){ "position", TvbRange_get_position, ((void*)0) },
  { NULL((void*)0), NULL((void*)0), NULL((void*)0) }
1831};

1833int 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_WITH_ATTRS(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 =
 TvbRange_attributes }; 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;
1840}

1842/*
* 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:
*/