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

Bug Summary

File:	builds/wireshark/wireshark/epan/wslua/wslua_tvb.c
Warning:	line 1012, 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-22/lib/clang/22 -isystem /usr/include/glib-2.0 -isystem /usr/lib/x86_64-linux-gnu/glib-2.0/include -isystem /usr/include/lua5.5 -isystem /builds/wireshark/wireshark/build/epan/wslua -isystem /builds/wireshark/wireshark/epan/wslua -D CARES_NO_DEPRECATED -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-22/lib/clang/22/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/16/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/builds/wireshark/wireshark/= -fmacro-prefix-map=/builds/wireshark/wireshark/build/= -fmacro-prefix-map=../= -Wno-format-nonliteral -std=gnu17 -ferror-limit 19 -fvisibility=hidden -fwrapv -fwrapv-pointer -fstrict-flex-arrays=3 -stack-protector 2 -fstack-clash-protection -fcf-protection=full -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fexceptions -fcolor-diagnostics -analyzer-output=html -faddrsig -fdwarf2-cfi-asm -o /builds/wireshark/wireshark/sbout/2026-10-25-100335-3662-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, each object records the
* wslua_packet_generation in which it was created, and is expired once that changes, which happens when the
* dissection of the current frame is finished.
*
* We check the expiry state of the pointer before each access.
*
* The objects are stored in the Lua userdata itself and have no __gc metamethod, so that they are freed
* promptly by the garbage collector; see WSLUA_CLASS_DEFINE_INLINE.
*
*/

56WSLUA_CLASS_DEFINE_INLINE(Tvb,FAIL_ON_EXPIRED("Tvb"))Tvb pushTvb(lua_State* L, Tvb v) { Tvb p; luaL_checkstack(L,2
,"Unable to grow stack\n"); p = (Tvb)lua_newuserdatauv(L,sizeof
(*v),1); *p = *v; (lua_getfield(L, (-(2147483647/2 + 1000)), (
"Tvb"))); lua_setmetatable(L, -2); return p; }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; } Tvb checkTvb
(lua_State* L, int idx) { Tvb p; luaL_checktype(L,idx,7); p =
 (Tvb)luaL_checkudata(L, idx, "Tvb"); if (((p)->generation
 != wslua_packet_generation)) luaL_argerror(L,idx,"expired " "Tvb"
); 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, (-(2147483647/2 + 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 buf) { Tvb p; if(!lua_isuserdata(L,i))
 return ((void*)0); p = (Tvb)lua_touserdata(L, i); lua_getfield
(L, (-(2147483647/2 + 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) { *buf = *p; (lua_rotate(L
, (i), -1), lua_settop(L, -(1)-1)); return buf; } else return
 ((void*)0);} typedef int dummyTvb;
57/* 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.
 ====
69*/

71/* The tvbuff is not owned by the Tvb; it must be freed (if necessary)
* by the end of the dissection of the current frame, e.g. by being
* a child of the frame's tvbuff, or added as a new data source. */
74Tvb push_Tvb(lua_State* L, tvbuff_t* ws_tvb) {
  struct _wslua_tvb tvb = {
      .ws_tvb = ws_tvb,
      .generation = wslua_packet_generation,
  };
  return pushTvb(L,&tvb);
80}


83/* WSLUA_ATTRIBUTE Tvb_captured_length RO The captured length of the Tvb
 (amount saved in the capture process). Mirrors `tvb:captured_len()`. */
85WSLUA_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
87})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;

89/* WSLUA_ATTRIBUTE Tvb_reported_length RO The reported length of the Tvb
 (length on the network). Mirrors `tvb:reported_len()`. */
91WSLUA_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
93})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;

95/* WSLUA_ATTRIBUTE Tvb_raw_offset RO The raw offset of this (sub) Tvb in its
 source Tvb. Mirrors `tvb:offset()`. */
97WSLUA_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
99})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;

101WSLUA_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. */
121}

123WSLUA_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`>>. */
129}

131WSLUA_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`>>. */
137}

139WSLUA_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`>>. */
146}

148WSLUA_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`>>. */
151#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`>>. */
157}

159WSLUA_METHODstatic int Tvb_bytes(lua_State* L) {
  /* Obtain a <<lua_class_ByteArray,`ByteArray`>> from a <<lua_class_Tvb,`Tvb`>>. */
161#define WSLUA_OPTARG_Tvb_bytes_OFFSET2 2 /* The offset (in octets) from the beginning of the <<lua_class_Tvb,`Tvb`>>. Defaults to 0. */
162#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;
165#if LUA_VERSION_NUM(5 * 100 + 5) >= 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);
168#else
  int offset = luaL_optint(L, WSLUA_OPTARG_Tvb_bytes_OFFSET2, 0);
  int len = luaL_optint(L,WSLUA_OPTARG_Tvb_bytes_LENGTH3,-1);
171#endif
  if (WSLUA_EXPIRED(tvb)((tvb)->generation != wslua_packet_generation)) {
      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. */
196}

198WSLUA_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`>>. */
204}


207#if USED_FOR_DOC_PURPOSES
208WSLUA_METAMETHODstatic int Tvb__call(lua_State* L) {
  /* Equivalent to tvb:range(...) */
  return 0;
211}
212#endif


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

231WSLUA_METHODstatic int Tvb_raw(lua_State* L) {
  /* Obtain a Lua string of the binary bytes in a <<lua_class_Tvb,`Tvb`>>. */
233#define WSLUA_OPTARG_Tvb_raw_OFFSET2 2 /* The position of the first byte. Default is 0, or the first byte. */
234#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 (WSLUA_EXPIRED(tvb)((tvb)->generation != wslua_packet_generation)) {
      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`>>. */
264}

266WSLUA_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;
288}

290WSLUA_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) }
300};

302WSLUA_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) }
307};

309/* 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. */
314WSLUA_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) }
319};

321int Tvb_register(lua_State* L) {
  WSLUA_REGISTER_CLASS_WITH_ATTRS_NOGC(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); };
  return 0;
324}




329WSLUA_CLASS_DEFINE_INLINE(TvbRange,NOP)TvbRange pushTvbRange(lua_State* L, TvbRange v) { TvbRange p;
 luaL_checkstack(L,2,"Unable to grow stack\n"); p = (TvbRange
)lua_newuserdatauv(L,sizeof(*v),1); *p = *v; (lua_getfield(L,
 (-(2147483647/2 + 1000)), ("TvbRange"))); lua_setmetatable(L
, -2); return p; }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; } TvbRange checkTvbRange
(lua_State* L, int idx) { TvbRange p; luaL_checktype(L,idx,7)
; p = (TvbRange)luaL_checkudata(L, idx, "TvbRange"); (void)p;
 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, (-(2147483647/2 + 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 buf) { TvbRange p;
 if(!lua_isuserdata(L,i)) return ((void*)0); p = (TvbRange)lua_touserdata
(L, i); lua_getfield(L, (-(2147483647/2 + 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) { *buf
 = *p; (lua_rotate(L, (i), -1), lua_settop(L, -(1)-1)); return
 buf; } 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.
  */

338bool_Bool push_TvbRange(lua_State* L, tvbuff_t* ws_tvb, int offset, int len) {
  struct _wslua_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.tvb.ws_tvb = ws_tvb;
  tvbr.tvb.generation = wslua_packet_generation;
  tvbr.offset = offset;
  tvbr.len = len;

  pushTvbRange(L,&tvbr);

  return true1;
374}


377WSLUA_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);

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

  if (tvb_bytes_exist(tvbr->tvb.ws_tvb, tvbr->offset, tvbr->len)) {
      push_Tvb(L, tvb_new_subset_length(tvbr->tvb.ws_tvb,tvbr->offset,tvbr->len));
      return 1;
  } else {
      luaL_error(L,"Out Of Bounds");
      return 0;
  }
395}


398/*
*  get a Blefuscuoan unsigned integer from a tvb
*/
401WSLUA_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) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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;
  }
428}

430/*
*  get a Lilliputian unsigned integer from a tvb
*/
433WSLUA_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) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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;
  }
461}

463/*
*  get a Blefuscuoan unsigned 64 bit integer from a tvb
*/
466WSLUA_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) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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;
  }
505}

507/*
*  get a Lilliputian unsigned 64 bit integer from a tvb
*/
510WSLUA_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) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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;
  }
549}

551/*
*  get a Blefuscuoan signed integer from a tvb
*/
554WSLUA_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) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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;
  }
588}

590/*
*  get a Lilliputian signed integer from a tvb
*/
593WSLUA_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) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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;
  }
620}

622/*
*  get a Blefuscuoan signed 64 bit integer from a tvb
*/
625WSLUA_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) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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;
  }
664}

666/*
*  get a Lilliputian signed 64 bit integer from a tvb
*/
669WSLUA_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) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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;
  }
708}

710/*
*  get a Blefuscuoan float
*/
713WSLUA_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) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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;
  }
734}

736/*
* get a Lilliputian float
*/
739WSLUA_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) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      luaL_error(L,"expired 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;
  }
760}

762WSLUA_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) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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;
  }

  set_address_tvb(&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. */
782}

784WSLUA_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) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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;
  }

  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))
));
  set_address(&addr, AT_IPv4, sizeof(ip_addr), &ip_addr);
  pushAddress(L,&addr);

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

808WSLUA_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) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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;
  }

  set_address_tvb(&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. */
828}

830WSLUA_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) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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;
  }

  set_address_tvb(&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. */
850}

852WSLUA_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. */
854#define WSLUA_OPTARG_TvbRange_nstime_ENCODING2 2 /* An optional ENC_* encoding value to use */
  TvbRange tvbr = checkTvbRange(L,1);
  nstime_t nstime;
  const unsigned encoding = (unsigned) luaL_optinteger(L, WSLUA_OPTARG_TvbRange_nstime_ENCODING2, 0);

  if (!tvbr) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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;
  }

  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 {
        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) {
          /* 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. */
900}

902WSLUA_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_t nstime;

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

  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 {
    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. */
927}

929WSLUA_METHODstatic int TvbRange_string(lua_State* L) {
  /* Obtain a string from a <<lua_class_TvbRange,`TvbRange`>>. */
931#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) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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"). */
947}

949static 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) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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 */
965}

967WSLUA_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"). */
970}

972WSLUA_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"). */
975}

977WSLUA_METHODstatic int TvbRange_stringz(lua_State* L) {
  /* Obtain a zero terminated string from a <<lua_class_TvbRange,`TvbRange`>>. */
979#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 (!tvbr) return 0;
2
←
Assuming 'tvbr' is non-null→
3
←
Taking false branch→
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
4
←
Assuming 'wslua_packet_generation' is equal to field 'generation'→
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. */
1015}

1017WSLUA_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. */
1021#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) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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. */
1051}


1054static 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) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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 */
1086}

1088WSLUA_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. */
1091}

1093WSLUA_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. */
1096}

1098WSLUA_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`.
     ====
   */
1117#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) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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. */
1161}

1163WSLUA_METHODstatic int TvbRange_bitfield(lua_State* L) {
  /* Get a bitfield from a <<lua_class_TvbRange,`TvbRange`>>. */
1165#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. */
1166#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) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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 */
1201}

1203WSLUA_METHODstatic int TvbRange_range(lua_State* L) {
  /* Creates a sub-<<lua_class_TvbRange,`TvbRange`>> from this <<lua_class_TvbRange,`TvbRange`>>. */
1205#define WSLUA_OPTARG_TvbRange_range_OFFSET2 2 /* The offset (in octets) from the beginning of the <<lua_class_TvbRange,`TvbRange`>>. Defaults to 0. */
1206#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) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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;
1243}

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

  if (!tvbr) return 0;

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

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

  return 0;
1276}

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

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

  if (!tvbr) return 0;

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

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

  return 0;
1315}

1317WSLUA_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
   */
1321#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) return 0;

  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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;
1342}

1344WSLUA_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
   */
1348#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) return 0;

  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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;
1369}

1371WSLUA_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
   */
1375#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) return 0;

  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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;
1396}

1398WSLUA_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
   */
1402#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) return 0;

  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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;
1423}

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

  if (!tvbr) return 0;

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

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

  return 0;
1456}

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

  if (!tvbr) return 0;

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

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

  return 0;
1489}

1491WSLUA_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
   */
1495#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) return 0;

  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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;
1516}

1518WSLUA_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
   */
1522#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) return 0;

  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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;
1543}

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

  if (!tvbr) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      luaL_error(L,"expired tvb");
      return 0;
  }
  lua_pushinteger(L,(lua_Integer)tvbr->len);
  return 1;
1556}

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

  if (!tvbr) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      luaL_error(L,"expired tvb");
      return 0;
  }
  lua_pushinteger(L,(lua_Integer)tvbr->offset);
  return 1;
1569}

1571WSLUA_METHODstatic int TvbRange_raw(lua_State* L) {
  /* Obtain a Lua string of the binary bytes in a <<lua_class_TvbRange,`TvbRange`>>. */
1573#define WSLUA_OPTARG_TvbRange_raw_OFFSET2 2 /* The position of the first byte within the range. Default is 0, or first byte. */
1574#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) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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`>>. */
1608}

1610/* WSLUA_ATTRIBUTE TvbRange_length RO The length (in bytes) of the range.
 Mirrors `range:len()`. */
1612WSLUA_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
1614})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;

1616/* WSLUA_ATTRIBUTE TvbRange_position RO The offset within the parent Tvb at
 which the range starts. Mirrors `range:offset()`. */
1618WSLUA_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
1620})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;

1622WSLUA_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);

  if (WSLUA_EXPIRED(&tvb_l->tvb)((&tvb_l->tvb)->generation != wslua_packet_generation
) || WSLUA_EXPIRED(&tvb_r->tvb)((&tvb_r->tvb)->generation != wslua_packet_generation
)) {
      luaL_error(L,"expired tvb");
      return 0;
  }

  /* 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;
1653}

1655WSLUA_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) return 0;
  if (WSLUA_EXPIRED(&tvbr->tvb)((&tvbr->tvb)->generation != wslua_packet_generation
)) {
      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. */
1685}

1687WSLUA_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) }
1730};

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

1740/* Read-only attributes for debugger introspection; see the comment on
* Tvb_attributes for the naming rationale. */
1742WSLUA_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) }
1746};

1748int TvbRange_register(lua_State* L) {
  WSLUA_REGISTER_CLASS_WITH_ATTRS_NOGC(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
); };
  return 0;
1751}

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