Bug Summary

File:builds/wireshark/wireshark/epan/wslua/wslua_tree.c
Warning:line 742, column 5
Undefined or garbage value returned to caller

Annotated Source Code

Press '?' to see keyboard shortcuts

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_tree.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -ffloat16-excess-precision=fast -fbfloat16-excess-precision=fast -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/builds/wireshark/wireshark/build -fcoverage-compilation-dir=/builds/wireshark/wireshark/build -resource-dir /usr/lib/llvm-21/lib/clang/21 -isystem /usr/include/glib-2.0 -isystem /usr/lib/x86_64-linux-gnu/glib-2.0/include -isystem /usr/include/lua5.4 -isystem /builds/wireshark/wireshark/build/epan/wslua -isystem /builds/wireshark/wireshark/epan/wslua -D G_DISABLE_DEPRECATED -D G_DISABLE_SINGLE_INCLUDES -D WS_BUILD_DLL -D WS_DEBUG -D WS_DEBUG_UTF_8 -I /builds/wireshark/wireshark/build -I /builds/wireshark/wireshark -I /builds/wireshark/wireshark/include -D _GLIBCXX_ASSERTIONS -internal-isystem /usr/lib/llvm-21/lib/clang/21/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/builds/wireshark/wireshark/= -fmacro-prefix-map=/builds/wireshark/wireshark/build/= -fmacro-prefix-map=../= -Wno-format-nonliteral -std=gnu11 -ferror-limit 19 -fvisibility=hidden -fwrapv -fwrapv-pointer -fstrict-flex-arrays=3 -stack-protector 2 -fstack-clash-protection -fcf-protection=full -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fexceptions -fcolor-diagnostics -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /builds/wireshark/wireshark/sbout/2026-01-29-100357-3623-1 -x c /builds/wireshark/wireshark/epan/wslua/wslua_tree.c
1/*
2 * wslua_tree.c
3 *
4 * Wireshark's interface to the Lua Programming Language
5 *
6 * (c) 2006, Luis E. Garcia Ontanon <[email protected]>
7 * (c) 2008, Balint Reczey <[email protected]>
8 *
9 * Wireshark - Network traffic analyzer
10 * By Gerald Combs <[email protected]>
11 * Copyright 1998 Gerald Combs
12 *
13 * SPDX-License-Identifier: GPL-2.0-or-later
14 */
15
16#include "config.h"
17
18/* WSLUA_MODULE Tree Adding Information To The Dissection Tree */
19
20#include "wslua.h"
21#include <epan/exceptions.h>
22#include <epan/show_exception.h>
23
24static int wslua_ett = -1;
25
26static GPtrArray* outstanding_TreeItem;
27
28
29/* pushing a TreeItem with a NULL item or subtree is completely valid for this function */
30TreeItem push_TreeItem(lua_State *L, proto_tree *tree, proto_item *item) {
31 TreeItem ti = g_new(struct _wslua_treeitem, 1)((struct _wslua_treeitem *) g_malloc_n ((1), sizeof (struct _wslua_treeitem
)));
32
33 ti->tree = tree;
34 ti->item = item;
35 ti->expired = false0;
36
37 g_ptr_array_add(outstanding_TreeItem, ti);
38
39 return *(pushTreeItem(L,ti));
40}
41
42/* creates the TreeItem but does NOT push it into Lua */
43TreeItem create_TreeItem(proto_tree* tree, proto_item* item)
44{
45 TreeItem tree_item = (TreeItem)g_malloc(sizeof(struct _wslua_treeitem));
46 tree_item->tree = tree;
47 tree_item->item = item;
48 tree_item->expired = false0;
49
50 return tree_item;
51}
52
53CLEAR_OUTSTANDING(TreeItem, expired, true)void clear_outstanding_TreeItem(void) { while (outstanding_TreeItem
->len) { TreeItem p = (TreeItem)g_ptr_array_remove_index_fast
(outstanding_TreeItem,0); if (p) { if (p->expired != 1) p->
expired = 1; else g_free(p); } } }
54
55WSLUA_CLASS_DEFINE(TreeItem,FAIL_ON_NULL_OR_EXPIRED("TreeItem"))TreeItem toTreeItem(lua_State* L, int idx) { TreeItem* v = (TreeItem
*)lua_touserdata (L, idx); if (!v) luaL_error(L, "bad argument %d (%s expected, got %s)"
, idx, "TreeItem", lua_typename(L, lua_type(L, idx))); return
v ? *v : ((void*)0); } TreeItem checkTreeItem(lua_State* L, int
idx) { TreeItem* p; luaL_checktype(L,idx,7); p = (TreeItem*)
luaL_checkudata(L, idx, "TreeItem"); if (!*p) { luaL_argerror
(L,idx,"null " "TreeItem"); } else if ((*p)->expired) { luaL_argerror
(L,idx,"expired " "TreeItem"); }; return p ? *p : ((void*)0);
} TreeItem* pushTreeItem(lua_State* L, TreeItem v) { TreeItem
* p; luaL_checkstack(L,2,"Unable to grow stack\n"); p = (TreeItem
*)lua_newuserdatauv(L,sizeof(TreeItem),1); *p = v; (lua_getfield
(L, (-1000000 - 1000), ("TreeItem"))); lua_setmetatable(L, -2
); return p; }_Bool isTreeItem(lua_State* L,int i) { void *p;
if(!lua_isuserdata(L,i)) return 0; p = lua_touserdata(L, i);
lua_getfield(L, (-1000000 - 1000), "TreeItem"); 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; } TreeItem
shiftTreeItem(lua_State* L,int i) { TreeItem* p; if(!lua_isuserdata
(L,i)) return ((void*)0); p = (TreeItem*)lua_touserdata(L, i)
; lua_getfield(L, (-1000000 - 1000), "TreeItem"); 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 dummyTreeItem;
56/* <<lua_class_TreeItem,`TreeItem`>>s represent information in the https://www.wireshark.org/docs/wsug_html_chunked/ChUsePacketDetailsPaneSection.html[packet details] pane of Wireshark, and the packet details view of TShark.
57 A <<lua_class_TreeItem,`TreeItem`>> represents a node in the tree, which might also be a subtree and have a list of children.
58 The children of a subtree have zero or more siblings which are other children of the same <<lua_class_TreeItem,`TreeItem`>> subtree.
59
60 During dissection, heuristic-dissection, and post-dissection, a root <<lua_class_TreeItem,`TreeItem`>> is passed to dissectors as the third argument of the function
61 callback (e.g., `myproto.dissector(tvbuf,pktinfo,root)`).
62
63 In some cases the tree is not truly added to, in order to improve performance.
64 For example for packets not currently displayed/selected in Wireshark's visible
65 window pane, or if TShark isn't invoked with the `-V` switch. However the
66 "add" type <<lua_class_TreeItem,`TreeItem`>> functions can still be called, and still return <<lua_class_TreeItem,`TreeItem`>>
67 objects - but the info isn't really added to the tree. Therefore you do not
68 typically need to worry about whether there's a real tree or not. If, for some
69 reason, you need to know it, you can use the <<lua_class_attrib_treeitem_visible,`TreeItem.visible`>> attribute getter
70 to retrieve the state.
71 */
72
73/* the following is used by TreeItem_add_packet_field() - this can THROW errors */
74static proto_item *
75try_add_packet_field(lua_State *L, TreeItem tree_item, TvbRange tvbr, const int hfid,
76 const ftenum_t type, const unsigned encoding, int *ret_err)
77{
78 int err = 0;
79 proto_item *volatile item = NULL((void*)0);
80 unsigned endoff = 0;
81
82 switch(type) {
83 /* these all generate ByteArrays */
84 case FT_BYTES:
85 case FT_UINT_BYTES:
86 case FT_OID:
87 case FT_REL_OID:
88 case FT_SYSTEM_ID:
89 {
90 /* GByteArray and its data will be g_free'd by Lua */
91 GByteArray *gba = g_byte_array_new();
92 item = proto_tree_add_bytes_item(tree_item->tree, hfid, tvbr->tvb->ws_tvb,
93 tvbr->offset, tvbr->len, encoding,
94 gba, &endoff, &err);
95 if (err == 0) {
96 pushByteArray(L, gba);
97 lua_pushinteger(L, endoff);
98 }
99 }
100 break;
101
102 case FT_ABSOLUTE_TIME:
103 case FT_RELATIVE_TIME:
104 {
105 /* nstime_t will be g_free'd by Lua */
106 nstime_t *nstime = g_new0(nstime_t, 1)((nstime_t *) g_malloc0_n ((1), sizeof (nstime_t)));
107 item = proto_tree_add_time_item(tree_item->tree, hfid, tvbr->tvb->ws_tvb,
108 tvbr->offset, tvbr->len, encoding,
109 nstime, &endoff, &err);
110 if (err == 0) {
111 pushNSTime(L,nstime);
112 lua_pushinteger(L, endoff);
113 }
114 }
115 break;
116
117 case FT_INT8:
118 case FT_INT16:
119 case FT_INT24:
120 case FT_INT32:
121 {
122 int32_t ret;
123 item = proto_tree_add_item_ret_int(tree_item->tree, hfid, tvbr->tvb->ws_tvb,
124 tvbr->offset, tvbr->len, encoding,
125 &ret);
126 lua_pushinteger(L, (lua_Integer)ret);
127 lua_pushinteger(L, tvbr->offset + tvbr->len);
128 }
129 break;
130
131 case FT_INT40:
132 case FT_INT48:
133 case FT_INT56:
134 case FT_INT64:
135 {
136 int64_t ret;
137 item = proto_tree_add_item_ret_int64(tree_item->tree, hfid, tvbr->tvb->ws_tvb,
138 tvbr->offset, tvbr->len, encoding,
139 &ret);
140 pushInt64(L, ret);
141 lua_pushinteger(L, tvbr->offset + tvbr->len);
142 }
143 break;
144
145 case FT_CHAR:
146 case FT_UINT8:
147 case FT_UINT16:
148 case FT_UINT24:
149 case FT_UINT32:
150 {
151 uint32_t ret;
152 item = proto_tree_add_item_ret_uint(tree_item-> tree, hfid, tvbr->tvb->ws_tvb,
153 tvbr->offset, tvbr->len, encoding,
154 &ret);
155 lua_pushinteger(L, (lua_Integer)ret);
156 lua_pushinteger(L, tvbr->offset + tvbr->len);
157 }
158 break;
159
160 case FT_UINT40:
161 case FT_UINT48:
162 case FT_UINT56:
163 case FT_UINT64:
164 {
165 uint64_t ret;
166 item = proto_tree_add_item_ret_uint64(tree_item->tree, hfid, tvbr->tvb->ws_tvb,
167 tvbr->offset, tvbr->len, encoding,
168 &ret);
169 pushUInt64(L, ret);
170 lua_pushinteger(L, tvbr->offset + tvbr->len);
171 }
172 break;
173
174 case FT_BOOLEAN:
175 {
176 bool_Bool ret;
177 item = proto_tree_add_item_ret_boolean(tree_item->tree, hfid, tvbr->tvb->ws_tvb,
178 tvbr->offset, tvbr->len, encoding,
179 &ret);
180 lua_pushboolean(L, ret);
181 lua_pushinteger(L, tvbr->offset + tvbr->len);
182 }
183 break;
184
185 case FT_STRING:
186 case FT_STRINGZ:
187 case FT_STRINGZPAD:
188 case FT_STRINGZTRUNC:
189 case FT_UINT_STRING:
190 {
191 const uint8_t *ret;
192 int len;
193 item = proto_tree_add_item_ret_string_and_length(tree_item->tree, hfid, tvbr->tvb->ws_tvb,
194 tvbr->offset, tvbr->len, encoding,
195 NULL((void*)0), &ret, &len);
196 lua_pushstring(L, (const char*)ret);
197 lua_pushinteger(L, tvbr->offset + len);
198 wmem_free(NULL((void*)0), (void*)ret);
199 }
200 break;
201
202 case FT_FLOAT:
203 {
204 float ret;
205 item = proto_tree_add_item_ret_float(tree_item->tree, hfid, tvbr->tvb->ws_tvb,
206 tvbr->offset, tvbr->len, encoding,
207 &ret);
208 lua_pushnumber(L, (lua_Number)ret);
209 lua_pushinteger(L, tvbr->offset + tvbr->len);
210 }
211 break;
212
213 case FT_DOUBLE:
214 {
215 double ret;
216 item = proto_tree_add_item_ret_double(tree_item->tree, hfid, tvbr->tvb->ws_tvb,
217 tvbr->offset, tvbr->len, encoding,
218 &ret);
219 lua_pushnumber(L, (lua_Number)ret);
220 lua_pushinteger(L, tvbr->offset + tvbr->len);
221 }
222 break;
223
224 case FT_IPv4:
225 {
226 Address addr = g_new(address,1)((address *) g_malloc_n ((1), sizeof (address)));
227 ws_in4_addr ret;
228 item = proto_tree_add_item_ret_ipv4(tree_item->tree, hfid, tvbr->tvb->ws_tvb,
229 tvbr->offset, tvbr->len, encoding,
230 &ret);
231 alloc_address_wmem(NULL((void*)0), addr, AT_IPv4, sizeof(ret), &ret);
232 pushAddress(L, addr);
233 lua_pushinteger(L, tvbr->offset + tvbr->len);
234 }
235 break;
236
237 case FT_IPv6:
238 {
239 Address addr = g_new(address, 1)((address *) g_malloc_n ((1), sizeof (address)));
240 ws_in6_addr ret;
241 item = proto_tree_add_item_ret_ipv6(tree_item->tree, hfid, tvbr->tvb->ws_tvb,
242 tvbr->offset, tvbr->len, encoding,
243 &ret);
244 alloc_address_wmem(NULL((void*)0), addr, AT_IPv6, sizeof(ret), &ret);
245 pushAddress(L, addr);
246 lua_pushinteger(L, tvbr->offset + tvbr->len);
247 }
248 break;
249
250 case FT_ETHER:
251 {
252 Address addr = g_new(address, 1)((address *) g_malloc_n ((1), sizeof (address)));
253 uint8_t bytes[FT_ETHER_LEN6];
254
255 item = proto_tree_add_item_ret_ether(tree_item->tree, hfid, tvbr->tvb->ws_tvb,
256 tvbr->offset, tvbr->len, encoding,
257 bytes);
258 alloc_address_wmem(NULL((void*)0), addr, AT_ETHER, sizeof(bytes), bytes);
259 pushAddress(L, addr);
260 lua_pushinteger(L, tvbr->offset + tvbr->len);
261 }
262 break;
263
264 default:
265 item = proto_tree_add_item(tree_item->tree, hfid, tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len, encoding);
266 lua_pushnil(L);
267 lua_pushnil(L);
268 break;
269 }
270
271 if (ret_err) *ret_err = err;
272
273 return item;
274}
275
276WSLUA_METHODstatic int TreeItem_add_packet_field(lua_State *L) {
277 /*
278 Adds a new child tree for the given <<lua_class_ProtoField,`ProtoField`>> object to this tree item,
279 returning the new child <<lua_class_TreeItem,`TreeItem`>>.
280
281 Unlike `TreeItem:add()` and `TreeItem:add_le()`, the <<lua_class_ProtoField,`ProtoField`>> argument
282 is not optional, and cannot be a `Proto` object. Instead, this function always
283 uses the <<lua_class_ProtoField,`ProtoField`>> to determine the type of field to extract from the
284 passed-in `TvbRange`, highlighting the relevant bytes in the Packet Bytes pane
285 of the GUI (if there is a GUI), etc. If no <<lua_class_TvbRange,`TvbRange`>>is given, no bytes are
286 highlighted and the field's value cannot be determined; the <<lua_class_ProtoField,`ProtoField`>> must
287 have been defined/created not to have a length in such a case, or an error will
288 occur. For backwards-compatibility reasons the `encoding` argument, however,
289 must still be given.
290
291 Unlike `TreeItem:add()` and `TreeItem:add_le()`, this function performs both
292 big-endian and little-endian decoding, by setting the `encoding` argument to
293 be `ENC_BIG_ENDIAN` or `ENC_LITTLE_ENDIAN`.
294
295 The signature of this function:
296
297 [source,lua]
298 ----
299 tree_item:add_packet_field(proto_field [,tvbrange], encoding, ...)
300 ----
301
302 This function returns more than just the new child <<lua_class_TreeItem,`TreeItem`>>.
303 The child is the first return value, so that function chaining will still work; but it
304 also returns more information. The second return is the value of the extracted field
305 (i.e., a number, `UInt64`, `Address`, etc.). The third return is is the offset where
306 data should be read next. This is useful when the length of the field is not known in
307 advance. The additional return values may be null if the field type is not well supported
308 in the Lua API.
309
310 This function can extract a <<lua_class_ProtoField,`ProtoField`>> of type `ftypes.BYTES`
311 or `ftypes.ABSOLUTE_TIME` from a string in the `TvbRange` in ASCII-based and similar
312 encodings. For example, a `ProtoField` of `ftypes.BYTES` can be extracted from a `TvbRange`
313 containing the ASCII string "a1b2c3d4e5f6", and it will correctly decode the ASCII both in the
314 tree as well as for the second return value, which will be a <<lua_class_ByteArray,`ByteArray`>>.
315 To do so, you must set the `encoding` argument of this function to the appropriate string `ENC_*`
316 value, bitwise-or'd (or added) with the `ENC_STR_HEX` value and one or more `ENC_SEP_XXX` values
317 indicating which encodings are allowed. For `ftypes.ABSOLUTE_TIME`, one of the `ENC_ISO_8601_*`
318 encodings or `ENC_IMF_DATE_TIME` must be used, and the second return value is a <<lua_class_NSTime,`NSTime`>>.
319 Only single-byte ASCII digit string encodings such as `ENC_ASCII` and `ENC_UTF_8` can be used for this.
320
321 For example, assuming the <<lua_class_Tvb,`Tvb`>> named "`tvb`" contains the string "abcdef"
322 (61 62 63 64 65 66 in hex):
323
324 [source,lua]
325 ----
326 -- this is done earlier in the script
327 local myfield = ProtoField.new("Transaction ID", "myproto.trans_id", ftypes.BYTES)
328 myproto.fields = { myfield }
329
330 -- this is done inside a dissector, post-dissector, or heuristic function
331 -- child will be the created child tree, and value will be the ByteArray "abcdef" or nil on failure
332 local child, value = tree:add_packet_field(myfield, tvb:range(0,6), ENC_UTF_8 + ENC_STR_HEX + ENC_SEP_NONE)
333 ----
334
335 */
336#define WSLUA_ARG_TreeItem_add_packet_field_PROTOFIELD2 2 /* The ProtoField field object to add to the tree. */
337#define WSLUA_OPTARG_TreeItem_add_packet_field_TVBRANGE3 3 /* The <<lua_class_TvbRange,`TvbRange`>> of bytes in the packet this tree item covers/represents. */
338#define WSLUA_ARG_TreeItem_add_packet_field_ENCODING4 4 /* The field's encoding in the `TvbRange`. */
339#define WSLUA_OPTARG_TreeItem_add_packet_field_LABEL5 5 /* One or more strings to append to the created <<lua_class_TreeItem,`TreeItem`>>. */
340 volatile TvbRange tvbr;
341 ProtoField field;
342 int hfid;
343 volatile int ett;
344 ftenum_t type;
345 TreeItem tree_item = shiftTreeItem(L,1);
346 unsigned encoding;
347 proto_item* item = NULL((void*)0);
348 volatile int nargs;
349 volatile int err = 0;
350 const char *volatile error = NULL((void*)0);
351
352 if (!tree_item) {
353 return luaL_error(L,"not a TreeItem!");
354 }
355 if (tree_item->expired) {
356 luaL_error(L,"expired TreeItem");
357 return 0;
358 }
359
360 if (! ( field = shiftProtoField(L,1) ) ) {
361 luaL_error(L,"TreeField:add_packet_field not passed a ProtoField");
362 return 0;
363 }
364 if (field->hfid == -2) {
365 luaL_error(L, "ProtoField %s unregistered (not added to a Proto.fields attribute)", field->abbrev);
366 }
367 hfid = field->hfid;
368 type = field->type;
369 ett = field->ett;
370
371 tvbr = shiftTvbRange(L,1);
372 if (!tvbr) {
373 /* No TvbRange specified */
374 tvbr = wmem_new(lua_pinfo->pool, struct _wslua_tvbrange)((struct _wslua_tvbrange*)wmem_alloc((lua_pinfo->pool), sizeof
(struct _wslua_tvbrange)));
375 tvbr->tvb = wmem_new(lua_pinfo->pool, struct _wslua_tvb)((struct _wslua_tvb*)wmem_alloc((lua_pinfo->pool), sizeof(
struct _wslua_tvb)));
376 tvbr->tvb->ws_tvb = lua_tvb;
377 tvbr->offset = 0;
378 tvbr->len = 0;
379 }
380
381 encoding = wslua_checkuint(L,1)(unsigned) ( luaL_checkinteger(L,1) );
382 lua_remove(L,1)(lua_rotate(L, (1), -1), lua_settop(L, -(1)-1));
383
384 /* get the number of additional args before we add more to the stack */
385 nargs = lua_gettop(L);
386
387 /* XXX: why is this being done? If the length was -1, FT_STRINGZ figures out
388 * the right length in tvb_get_stringz_enc(); if it was 0, it should remain zero;
389 * if it was greater than zero, then it's the length the caller wanted.
390 */
391 if (type == FT_STRINGZ) {
392 switch (encoding & ENC_CHARENCODING_MASK0x0000FFFE) {
393
394 case ENC_UTF_160x00000004:
395 case ENC_UCS_20x00000006:
396 tvbr->len = tvb_unicode_strsize (tvbr->tvb->ws_tvb, tvbr->offset);
397 break;
398
399 default:
400 if (!tvb_find_uint8_remaining(tvbr->tvb->ws_tvb, tvbr->offset, 0, NULL((void*)0))) {
401 luaL_error(L,"out of bounds");
402 return 0;
403 }
404 tvbr->len = tvb_strsize (tvbr->tvb->ws_tvb, tvbr->offset);
405 break;
406 }
407 }
408
409 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) {
410 int errx = 0;
411 item = try_add_packet_field(L, tree_item, tvbr, hfid, type, encoding, &errx);
412 err = errx;
413 } CATCH_ALLif (except_state == 0 && exc != 0 && (except_state
|=1)) {
414 show_exception(tvbr->tvb->ws_tvb, lua_pinfo, tree_item->tree, EXCEPT_CODE((exc)->except_id.except_code), GET_MESSAGE((exc)->except_message));
415 error = "Lua programming error";
416 } ENDTRYif(!(except_state&1) && exc != 0) except_rethrow(
exc); except_free(except_ch.except_obj.except_dyndata); except_pop
(); };};
417
418 if (error) { WSLUA_ERROR(TreeItem_add_packet_field,error){ luaL_error(L, "%s%s", "TreeItem_add_packet_field" ": ", error
); }; }
419
420 if (err != 0) {
421 lua_pushnil(L);
422 lua_pushnil(L);
423 }
424
425 while(nargs) {
426 const char* s;
427 s = lua_tostring(L,1)lua_tolstring(L, (1), ((void*)0));
428 if (s) proto_item_append_text(item, " %s", s);
429 lua_remove(L,1)(lua_rotate(L, (1), -1), lua_settop(L, -(1)-1));
430 nargs--;
431 }
432
433 push_TreeItem(L, proto_item_add_subtree(item,ett > 0 ? ett : wslua_ett), item);
434
435 /* move the tree object before the field value */
436 lua_insert(L, 1)lua_rotate(L, (1), 1);
437
438 WSLUA_RETURN(3)return (3); /* The new child <<lua_class_TreeItem,`TreeItem`>>, the field's extracted value or nil, and offset or nil. */
439}
440
441/* The following is used by TreeItem_add() and TreeItem_le() and can THROW.
442 * It should be called inside a TRY (e.g. WRAP_NON_LUA_EXCEPTIONS) block and
443 * THROW_LUA_ERROR should be used insteadof lua[L]_error.
444 */
445static int TreeItem_add_item_any(lua_State *L, bool_Bool little_endian) {
446 TvbRange tvbr;
447 Proto proto;
448 ProtoField field;
449 int hfid = -1;
450 int ett = -1;
451 ftenum_t type = FT_NONE;
452 TreeItem tree_item = shiftTreeItem(L,1);
453 proto_item* item = NULL((void*)0);
454
455 if (!tree_item) {
456 THROW_LUA_ERROR("not a TreeItem!")except_throwf(1, (6), "not a TreeItem!");
457 }
458 if (tree_item->expired) {
459 THROW_LUA_ERROR("expired TreeItem")except_throwf(1, (6), "expired TreeItem");
460 return 0;
461 }
462
463 if (! ( field = shiftProtoField(L,1) ) ) {
464 if (( proto = shiftProto(L,1) )) {
465 hfid = proto->hfid;
466 type = FT_PROTOCOL;
467 ett = proto->ett;
468 } else if (lua_isnil(L, 1)(lua_type(L, (1)) == 0)) {
469 THROW_LUA_ERROR("first argument to TreeItem:add is nil!")except_throwf(1, (6), "first argument to TreeItem:add is nil!"
);
470 }
471 } else {
472 hfid = field->hfid;
473 type = field->type;
474 ett = field->ett;
475 }
476
477 tvbr = shiftTvbRange(L,1);
478
479 if (!tvbr) {
480 tvbr = wmem_new(lua_pinfo->pool, struct _wslua_tvbrange)((struct _wslua_tvbrange*)wmem_alloc((lua_pinfo->pool), sizeof
(struct _wslua_tvbrange)));
481 tvbr->tvb = wmem_new(lua_pinfo->pool, struct _wslua_tvb)((struct _wslua_tvb*)wmem_alloc((lua_pinfo->pool), sizeof(
struct _wslua_tvb)));
482 tvbr->tvb->ws_tvb = lua_tvb;
483 tvbr->offset = 0;
484 tvbr->len = 0;
485 }
486
487 if (hfid > 0 ) {
488 /* hfid is > 0 when the first arg was a ProtoField or Proto */
489
490 if (type == FT_STRINGZ) {
491 if (!tvb_find_uint8_remaining(tvbr->tvb->ws_tvb, tvbr->offset, 0, NULL((void*)0))) {
492 THROW_LUA_ERROR("out of bounds")except_throwf(1, (6), "out of bounds");
493 return 0;
494 }
495 tvbr->len = tvb_strsize (tvbr->tvb->ws_tvb, tvbr->offset);
496 }
497
498 if (lua_gettop(L)) {
499 /* if we got here, the (L,1) index is the value to add, instead of decoding from the Tvb */
500
501 /* It's invalid for it to be nil (which has been documented for
502 * a long time). Make sure we throw our error instead of an
503 * internal Lua error (due to nested setjmp/longjmp).
504 */
505 if (lua_isnil(L, 1)(lua_type(L, (1)) == 0)) {
506 THROW_LUA_ERROR("TreeItem:add value argument is nil!")except_throwf(1, (6), "TreeItem:add value argument is nil!");
507 }
508
509 switch(type) {
510 case FT_PROTOCOL:
511 item = proto_tree_add_item(tree_item->tree,hfid,tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len,ENC_NA0x00000000);
512 lua_pushinteger(L,0);
513 lua_insert(L,1)lua_rotate(L, (1), 1);
514 break;
515 case FT_BOOLEAN:
516 {
517 uint64_t val;
518 switch(lua_type(L, 1)) {
519
520 case LUA_TUSERDATA7:
521 val = checkUInt64(L, 1);
522 break;
523
524 default:
525 /* this needs to use checkinteger so that it can accept a Lua boolean and coerce it to an int */
526 val = (uint64_t) (wslua_tointeger(L,1));
527 }
528 item = proto_tree_add_boolean(tree_item->tree,hfid,tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len,val);
529 }
530 break;
531 case FT_CHAR:
532 case FT_UINT8:
533 case FT_UINT16:
534 case FT_UINT24:
535 case FT_UINT32:
536 case FT_FRAMENUM:
537 item = proto_tree_add_uint(tree_item->tree,hfid,tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len,wslua_checkuint32(L,1)(uint32_t) ( luaL_checkinteger(L,1) ));
538 break;
539 case FT_INT8:
540 case FT_INT16:
541 case FT_INT24:
542 case FT_INT32:
543 item = proto_tree_add_int(tree_item->tree,hfid,tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len,wslua_checkint32(L,1)(int32_t) ( luaL_checkinteger(L,1) ));
544 break;
545 case FT_FLOAT:
546 item = proto_tree_add_float(tree_item->tree,hfid,tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len,(float)luaL_checknumber(L,1));
547 break;
548 case FT_DOUBLE:
549 item = proto_tree_add_double(tree_item->tree,hfid,tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len,(double)luaL_checknumber(L,1));
550 break;
551 case FT_ABSOLUTE_TIME:
552 case FT_RELATIVE_TIME:
553 item = proto_tree_add_time(tree_item->tree,hfid,tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len,checkNSTime(L,1));
554 break;
555 case FT_STRING:
556 case FT_STRINGZ:
557 item = proto_tree_add_string(tree_item->tree,hfid,tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len,luaL_checkstring(L,1)(luaL_checklstring(L, (1), ((void*)0))));
558 break;
559 case FT_BYTES:
560 item = proto_tree_add_bytes(tree_item->tree,hfid,tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len, (const uint8_t*) luaL_checkstring(L,1)(luaL_checklstring(L, (1), ((void*)0))));
561 break;
562 case FT_UINT64:
563 item = proto_tree_add_uint64(tree_item->tree,hfid,tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len,checkUInt64(L,1));
564 break;
565 case FT_INT64:
566 item = proto_tree_add_int64(tree_item->tree,hfid,tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len,checkInt64(L,1));
567 break;
568 case FT_IPv4:
569 {
570 Address addr = checkAddress(L,1);
571 uint32_t addr_value;
572
573 if (addr->type != AT_IPv4) {
574 THROW_LUA_ERROR("Expected IPv4 address for FT_IPv4 field")except_throwf(1, (6), "Expected IPv4 address for FT_IPv4 field"
);
575 return 0;
576 }
577
578 /*
579 * The address is not guaranteed to be aligned on a
580 * 32-bit boundary, so we can't safely dereference
581 * the pointer as if it were so aligned.
582 */
583 memcpy(&addr_value, addr->data, sizeof addr_value);
584 item = proto_tree_add_ipv4(tree_item->tree,hfid,tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len,addr_value);
585 }
586 break;
587 case FT_IPv6:
588 {
589 Address addr = checkAddress(L,1);
590 if (addr->type != AT_IPv6) {
591 THROW_LUA_ERROR("Expected IPv6 address for FT_IPv6 field")except_throwf(1, (6), "Expected IPv6 address for FT_IPv6 field"
);
592 return 0;
593 }
594
595 item = proto_tree_add_ipv6(tree_item->tree, hfid, tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len, (const ws_in6_addr *)addr->data);
596 }
597 break;
598 case FT_ETHER:
599 {
600 Address addr = checkAddress(L,1);
601 if (addr->type != AT_ETHER) {
602 THROW_LUA_ERROR("Expected MAC address for FT_ETHER field")except_throwf(1, (6), "Expected MAC address for FT_ETHER field"
);
603 return 0;
604 }
605
606 item = proto_tree_add_ether(tree_item->tree, hfid, tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len, (const uint8_t *)addr->data);
607 }
608 break;
609 case FT_UINT_BYTES:
610 case FT_IPXNET:
611 case FT_GUID:
612 case FT_OID:
613 case FT_REL_OID:
614 case FT_SYSTEM_ID:
615 case FT_VINES:
616 case FT_FCWWN:
617 default:
618 THROW_LUA_ERROR("%s not yet supported", ftype_name(type))except_throwf(1, (6), "%s not yet supported", ftype_name(type
));
619 return 0;
620 }
621
622 lua_remove(L,1)(lua_rotate(L, (1), -1), lua_settop(L, -(1)-1));
623
624 } else {
625 if (type == FT_FRAMENUM) {
626 THROW_LUA_ERROR("ProtoField FRAMENUM cannot fetch value from Tvb")except_throwf(1, (6), "ProtoField FRAMENUM cannot fetch value from Tvb"
);
627 return 0;
628 }
629 /* the Lua stack is empty - no value was given - so decode the value from the tvb */
630 item = proto_tree_add_item(tree_item->tree, hfid, tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len, little_endian ? ENC_LITTLE_ENDIAN0x80000000 : ENC_BIG_ENDIAN0x00000000);
631 }
632
633 if ( lua_gettop(L) ) {
634 /* if there was a value, it was removed earlier, so what's left is the display string to set */
635 const char* s = lua_tostring(L,1)lua_tolstring(L, (1), ((void*)0));
636 if (s) proto_item_set_text(item,"%s",s);
637 lua_remove(L,1)(lua_rotate(L, (1), -1), lua_settop(L, -(1)-1));
638 }
639
640 } else {
641 /* no ProtoField or Proto was given - we're adding a text-only field,
642 * any remaining parameters are parts of the text label. */
643 if (lua_gettop(L)) {
644 const char* s = lua_tostring(L,1)lua_tolstring(L, (1), ((void*)0));
645 const int hf = get_hf_wslua_text();
646 if (hf > -1) {
647 /* use proto_tree_add_none_format() instead? */
648 item = proto_tree_add_item(tree_item->tree, hf, tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len, ENC_NA0x00000000);
649 proto_item_set_text(item, "%s", s);
650 } else {
651 THROW_LUA_ERROR("Internal error: hf_wslua_text not registered")except_throwf(1, (6), "Internal error: hf_wslua_text not registered"
);
652 }
653 lua_remove(L,1)(lua_rotate(L, (1), -1), lua_settop(L, -(1)-1));
654 } else {
655 THROW_LUA_ERROR("Tree item ProtoField/Protocol handle is invalid (ProtoField/Proto not registered?)")except_throwf(1, (6), "Tree item ProtoField/Protocol handle is invalid (ProtoField/Proto not registered?)"
);
656 }
657 }
658
659 while(lua_gettop(L)) {
660 /* keep appending more text */
661 const char* s = lua_tostring(L,1)lua_tolstring(L, (1), ((void*)0));
662 if (s) proto_item_append_text(item, " %s", s);
663 lua_remove(L,1)(lua_rotate(L, (1), -1), lua_settop(L, -(1)-1));
664 }
665
666 push_TreeItem(L, proto_item_add_subtree(item,ett > 0 ? ett : wslua_ett), item);
667
668 return 1;
669}
670
671
672WSLUA_METHODstatic int TreeItem_add(lua_State *L) {
673 /*
674 Adds a child item to this tree item, returning the new child <<lua_class_TreeItem,`TreeItem`>>.
675
676 If the <<lua_class_ProtoField,`ProtoField`>> represents a numeric value (int, uint or float), then it's treated as a Big Endian (network order) value.
677
678 This function has a complicated form: 'treeitem:add([protofield,] [tvbrange,] [[value], label]])', such that if the first
679 argument is a <<lua_class_ProtoField,`ProtoField`>> or a <<lua_class_Proto,`Proto`>>, the second argument is a <<lua_class_TvbRange,`TvbRange`>>, and a third argument is given, it's a value;
680 but if the second argument is a non-<<lua_class_TvbRange,`TvbRange`>>, then it's the value (as opposed to filling that argument with 'nil',
681 which is invalid for this function). If the first argument is a non-<<lua_class_ProtoField,`ProtoField`>> and a non-<<lua_class_Proto,`Proto`>> then this argument can
682 be either a <<lua_class_TvbRange,`TvbRange`>> or a label, and the value is not in use.
683
684 [discrete]
685 ====== Example
686
687 [source,lua]
688 ----
689 local proto_foo = Proto("foo", "Foo Protocol")
690 proto_foo.fields.bytes = ProtoField.bytes("foo.bytes", "Byte array")
691 proto_foo.fields.u16 = ProtoField.uint16("foo.u16", "Unsigned short", base.HEX)
692
693 function proto_foo.dissector(buf, pinfo, tree)
694 -- ignore packets less than 4 bytes long
695 if buf:len() < 4 then return end
696
697 -- ##############################################
698 -- # Assume buf(0,4) == {0x00, 0x01, 0x00, 0x02}
699 -- ##############################################
700
701 local t = tree:add( proto_foo, buf() )
702
703 -- Adds a byte array that shows as: "Byte array: 00010002"
704 t:add( proto_foo.fields.bytes, buf(0,4) )
705
706 -- Adds a byte array that shows as "Byte array: 313233"
707 -- (the ASCII char code of each character in "123")
708 t:add( proto_foo.fields.bytes, buf(0,4), "123" )
709
710 -- Adds a tree item that shows as: "Unsigned short: 0x0001"
711 t:add( proto_foo.fields.u16, buf(0,2) )
712
713 -- Adds a tree item that shows as: "Unsigned short: 0x0064"
714 t:add( proto_foo.fields.u16, buf(0,2), 100 )
715
716 -- Adds a tree item that shows as: "Unsigned short: 0x0064 ( big endian )"
717 t:add( proto_foo.fields.u16, buf(1,2), 100, nil, "(", nil, "big", 999, nil, "endian", nil, ")" )
718
719 -- LITTLE ENDIAN: Adds a tree item that shows as: "Unsigned short: 0x0100"
720 t:add_le( proto_foo.fields.u16, buf(0,2) )
721
722 -- LITTLE ENDIAN: Adds a tree item that shows as: "Unsigned short: 0x6400"
723 t:add_le( proto_foo.fields.u16, buf(0,2), 100 )
724
725 -- LITTLE ENDIAN: Adds a tree item that shows as: "Unsigned short: 0x6400 ( little endian )"
726 t:add_le( proto_foo.fields.u16, buf(1,2), 100, nil, "(", nil, "little", 999, nil, "endian", nil, ")" )
727 end
728
729 udp_table = DissectorTable.get("udp.port")
730 udp_table:add(7777, proto_foo)
731 ----
732 */
733#define WSLUA_OPTARG_TreeItem_add_PROTOFIELD2 2 /* The <<lua_class_ProtoField,`ProtoField`>> field or <<lua_class_Proto,`Proto`>> protocol object to add to the tree. */
734#define WSLUA_OPTARG_TreeItem_add_TVBRANGE3 3 /* The <<lua_class_TvbRange,`TvbRange`>> of bytes in the packet this tree item covers/represents. */
735#define WSLUA_OPTARG_TreeItem_add_VALUE4 4 /* The field's value, instead of the ProtoField/Proto one. */
736#define WSLUA_OPTARG_TreeItem_add_LABEL5 5 /* One or more strings to use for the tree item label, instead of the ProtoField/Proto one. */
737
738 volatile int ret;
1
'ret' declared without an initial value
→
739 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) { ret = TreeItem_add_item_any(L,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); } }
2
←
Assuming the condition is true
→
3
←
Taking true branch
→
4
←
Taking false branch
→
5
←
Taking false branch
→
6
←
Assuming field 'except_code' is equal to 1
→
7
←
Taking true branch
→
8
←
Taking false branch
→
740 ret = TreeItem_add_item_any(L,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) { ret = TreeItem_add_item_any(L,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); } }
741 ){ 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) { ret = TreeItem_add_item_any(L,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); } }
742 WSLUA_RETURN(ret)return (ret); /* The new child TreeItem. */
9
←
Undefined or garbage value returned to caller
743}
744
745WSLUA_METHODstatic int TreeItem_add_le(lua_State *L) {
746 /*
747 Adds a child item to this tree item, returning the new child <<lua_class_TreeItem,`TreeItem`>>.
748
749 If the <<lua_class_ProtoField,`ProtoField`>> represents a numeric value (int, uint or float), then it's treated as a Little Endian value.
750
751 This function has a complicated form: 'treeitem:add_le([protofield,] [tvbrange,] [[value], label]])', such that if the first
752 argument is a <<lua_class_ProtoField,`ProtoField`>> or a <<lua_class_Proto,`Proto`>>, the second argument is a <<lua_class_TvbRange,`TvbRange`>>, and a third argument is given, it's a value;
753 but if the second argument is a non-<<lua_class_TvbRange,`TvbRange`>>, then it's the value (as opposed to filling that argument with 'nil',
754 which is invalid for this function). If the first argument is a non-<<lua_class_ProtoField,`ProtoField`>> and a non-<<lua_class_Proto,`Proto`>> then this argument can
755 be either a <<lua_class_TvbRange,`TvbRange`>> or a label, and the value is not in use.
756 */
757#define WSLUA_OPTARG_TreeItem_add_le_PROTOFIELD2 2 /* The ProtoField field or Proto protocol object to add to the tree. */
758#define WSLUA_OPTARG_TreeItem_add_le_TVBRANGE3 3 /* The TvbRange of bytes in the packet this tree item covers/represents. */
759#define WSLUA_OPTARG_TreeItem_add_le_VALUE4 4 /* The field's value, instead of the ProtoField/Proto one. */
760#define WSLUA_OPTARG_TreeItem_add_le_LABEL5 5 /* One or more strings to use for the tree item label, instead of the ProtoField/Proto one. */
761 volatile int ret;
762 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) { ret = TreeItem_add_item_any(L,1)
; } 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); } }
763 ret = TreeItem_add_item_any(L,true);{ 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) { ret = TreeItem_add_item_any(L,1)
; } 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); } }
764 ){ 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) { ret = TreeItem_add_item_any(L,1)
; } 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); } }
765 WSLUA_RETURN(ret)return (ret); /* The new child TreeItem. */
766}
767
768/* WSLUA_ATTRIBUTE TreeItem_text RW Set/get the <<lua_class_TreeItem,`TreeItem`>>'s display string (string).
769
770 For the getter, if the TreeItem has no display string, then nil is returned.
771 */
772static int TreeItem_get_text(lua_State* L) {
773 TreeItem ti = checkTreeItem(L,1);
774 char label_str[ITEM_LABEL_LENGTH240+1];
775 char *label_ptr;
776
777 if (ti->item && PITEM_FINFO(ti->item)((ti->item)->finfo)) {
778 field_info *fi = PITEM_FINFO(ti->item)((ti->item)->finfo);
779
780 if (!fi->rep) {
781 label_ptr = label_str;
782 proto_item_fill_label(fi, label_str, NULL((void*)0));
783 } else
784 label_ptr = fi->rep->representation;
785
786 if (label_ptr) {
787 lua_pushstring(L, label_ptr);
788 } else {
789 lua_pushnil(L);
790 }
791 } else {
792 lua_pushnil(L);
793 }
794
795 return 1;
796}
797
798/* the following is used as both a method and attribute */
799WSLUA_METHODstatic int TreeItem_set_text(lua_State *L) {
800 /* Sets the text of the label.
801
802 This used to return nothing, but as of 1.11.3 it returns the same tree item to allow chained calls.
803 */
804#define WSLUA_ARG_TreeItem_set_text_TEXT2 2 /* The text to be used. */
805 TreeItem ti = checkTreeItem(L,1);
806 const char* s = luaL_checkstring(L,WSLUA_ARG_TreeItem_set_text_TEXT)(luaL_checklstring(L, (2), ((void*)0)));
807
808 proto_item_set_text(ti->item,"%s",s);
809
810 /* copy the TreeItem userdata so we give it back */
811 lua_pushvalue(L, 1);
812
813 WSLUA_RETURN(1)return (1); /* The same TreeItem. */
814}
815
816WSLUA_METHODstatic int TreeItem_append_text(lua_State *L) {
817 /* Appends text to the label.
818
819 This used to return nothing, but as of 1.11.3 it returns the same tree item to allow chained calls.
820 */
821#define WSLUA_ARG_TreeItem_append_text_TEXT2 2 /* The text to be appended. */
822 TreeItem ti = checkTreeItem(L,1);
823 const char* s = luaL_checkstring(L,WSLUA_ARG_TreeItem_append_text_TEXT)(luaL_checklstring(L, (2), ((void*)0)));
824
825 proto_item_append_text(ti->item,"%s",s);
826
827 /* copy the TreeItem userdata so we give it back */
828 lua_pushvalue(L, 1);
829
830 WSLUA_RETURN(1)return (1); /* The same TreeItem. */
831}
832
833WSLUA_METHODstatic int TreeItem_prepend_text(lua_State *L) {
834 /* Prepends text to the label.
835
836 This used to return nothing, but as of 1.11.3 it returns the same tree item to allow chained calls.
837 */
838#define WSLUA_ARG_TreeItem_prepend_text_TEXT2 2 /* The text to be prepended. */
839 TreeItem ti = checkTreeItem(L,1);
840 const char* s = luaL_checkstring(L,WSLUA_ARG_TreeItem_prepend_text_TEXT)(luaL_checklstring(L, (2), ((void*)0)));
841
842 proto_item_prepend_text(ti->item,"%s",s);
843
844 /* copy the TreeItem userdata so we give it back */
845 lua_pushvalue(L, 1);
846
847 WSLUA_RETURN(1)return (1); /* The same TreeItem. */
848}
849
850WSLUA_METHODstatic int TreeItem_add_expert_info(lua_State *L) {
851 /* Sets the expert flags of the item and adds expert info to the packet.
852
853 This function does *not* create a truly filterable expert info for a protocol.
854 Instead you should use `TreeItem.add_proto_expert_info()`.
855
856 Note: This function is provided for backwards compatibility only, and should not
857 be used in new Lua code. It may be removed in the future. You should only
858 use `TreeItem.add_proto_expert_info()`.
859 */
860#define WSLUA_OPTARG_TreeItem_add_expert_info_GROUP2 2 /* One of:
861 `PI_CHECKSUM`,
862 `PI_SEQUENCE`,
863 `PI_RESPONSE_CODE`,
864 `PI_REQUEST_CODE`,
865 `PI_UNDECODED`,
866 `PI_REASSEMBLE`,
867 `PI_MALFORMED`,
868 `PI_DEBUG`,
869 `PI_PROTOCOL`,
870 `PI_SECURITY`,
871 `PI_COMMENTS_GROUP`,
872 `PI_DECRYPTION`,
873 `PI_ASSUMPTION`,
874 `PI_DEPRECATED`,
875 `PI_RECEIVE`,
876 `PI_INTERFACE`,
877 or `PI_DISSECTOR_BUG`. */
878#define WSLUA_OPTARG_TreeItem_add_expert_info_SEVERITY3 3 /* One of:
879 `PI_COMMENT`,
880 `PI_CHAT`,
881 `PI_NOTE`,
882 `PI_WARN`,
883 or `PI_ERROR`. */
884#define WSLUA_OPTARG_TreeItem_add_expert_info_TEXT4 4 /* The text for the expert info display. */
885 TreeItem ti = checkTreeItem(L,1);
886 int group = (int)luaL_optinteger(L,WSLUA_OPTARG_TreeItem_add_expert_info_GROUP2,PI_DEBUG0x08000000);
887 int severity = (int)luaL_optinteger(L,WSLUA_OPTARG_TreeItem_add_expert_info_SEVERITY3,PI_CHAT0x00200000);
888 expert_field* ei_info = wslua_get_expert_field(group, severity);
889 const char* str;
890
891 if (lua_gettop(L) >= WSLUA_OPTARG_TreeItem_add_expert_info_TEXT4) {
892 str = wslua_checkstring_only(L, WSLUA_OPTARG_TreeItem_add_expert_info_TEXT4);
893 expert_add_info_format(lua_pinfo, ti->item, ei_info, "%s", str);
894 } else {
895 expert_add_info(lua_pinfo, ti->item, ei_info);
896 }
897
898 /* copy the TreeItem userdata so we give it back */
899 lua_pushvalue(L, 1);
900
901 WSLUA_RETURN(1)return (1); /* The same TreeItem. */
902}
903
904WSLUA_METHODstatic int TreeItem_add_proto_expert_info(lua_State *L) {
905 /* Sets the expert flags of the tree item and adds expert info to the packet. */
906#define WSLUA_ARG_TreeItem_add_proto_expert_info_EXPERT2 2 /* The <<lua_class_ProtoExpert,`ProtoExpert`>> object to add to the tree. */
907#define WSLUA_OPTARG_TreeItem_add_proto_expert_info_TEXT3 3 /* Text for the expert info display
908 (default is to use the registered
909 text). */
910 TreeItem ti = checkTreeItem(L,1);
911 ProtoExpert expert = checkProtoExpert(L,WSLUA_ARG_TreeItem_add_proto_expert_info_EXPERT2);
912 const char* str;
913
914 if (expert->ids.ei == EI_INIT_EI0 || expert->ids.hf == EI_INIT_HF0) {
915 luaL_error(L, "ProtoExpert is not registered");
916 return 0;
917 }
918
919 if (lua_gettop(L) >= WSLUA_OPTARG_TreeItem_add_proto_expert_info_TEXT3) {
920 str = wslua_checkstring_only(L, WSLUA_OPTARG_TreeItem_add_proto_expert_info_TEXT3);
921 expert_add_info_format(lua_pinfo, ti->item, &expert->ids, "%s", str);
922 } else {
923 expert_add_info(lua_pinfo, ti->item, &expert->ids);
924 }
925
926 /* copy the TreeItem userdata so we give it back */
927 lua_pushvalue(L, 1);
928
929 WSLUA_RETURN(1)return (1); /* The same TreeItem. */
930}
931
932WSLUA_METHODstatic int TreeItem_add_tvb_expert_info(lua_State *L) {
933 /* Sets the expert flags of the tree item and adds expert info to the packet
934 associated with the <<lua_class_Tvb,`Tvb`>> or <<lua_class_TvbRange,`TvbRange`>> bytes in the packet. */
935#define WSLUA_ARG_TreeItem_add_tvb_expert_info_EXPERT2 2 /* The <<lua_class_ProtoExpert,`ProtoExpert`>> object to add to the tree. */
936#define WSLUA_ARG_TreeItem_add_tvb_expert_info_TVB3 3 /* The <<lua_class_Tvb,`Tvb`>> or <<lua_class_TvbRange,`TvbRange`>> object bytes to associate
937 the expert info with. */
938#define WSLUA_OPTARG_TreeItem_add_tvb_expert_info_TEXT4 4 /* Text for the expert info display
939 (default is to use the registered
940 text). */
941 TreeItem ti = checkTreeItem(L,1);
942 ProtoExpert expert = checkProtoExpert(L,WSLUA_ARG_TreeItem_add_proto_expert_info_EXPERT2);
943 TvbRange tvbr;
944 const char* str;
945
946 if (expert->ids.ei == EI_INIT_EI0 || expert->ids.hf == EI_INIT_HF0) {
947 luaL_error(L, "ProtoExpert is not registered");
948 return 0;
949 }
950
951 tvbr = shiftTvbRange(L,WSLUA_ARG_TreeItem_add_tvb_expert_info_TVB3);
952
953 if (!tvbr) {
954 tvbr = wmem_new(lua_pinfo->pool, struct _wslua_tvbrange)((struct _wslua_tvbrange*)wmem_alloc((lua_pinfo->pool), sizeof
(struct _wslua_tvbrange)));
955 tvbr->tvb = shiftTvb(L,WSLUA_ARG_TreeItem_add_tvb_expert_info_TVB3);
956 if (!tvbr->tvb) {
957 tvbr->tvb = wmem_new(lua_pinfo->pool, struct _wslua_tvb)((struct _wslua_tvb*)wmem_alloc((lua_pinfo->pool), sizeof(
struct _wslua_tvb)));
958 }
959 tvbr->tvb->ws_tvb = lua_tvb;
960 tvbr->offset = 0;
961 tvbr->len = 0;
962 }
963
964 if (lua_gettop(L) >= WSLUA_OPTARG_TreeItem_add_proto_expert_info_TEXT3) {
965 str = wslua_checkstring_only(L, WSLUA_OPTARG_TreeItem_add_proto_expert_info_TEXT3);
966 proto_tree_add_expert_format(ti->tree, lua_pinfo, &expert->ids,
967 tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len,
968 "%s", str);
969 } else {
970 proto_tree_add_expert(ti->tree, lua_pinfo, &expert->ids,
971 tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len);
972 }
973
974 /* copy the TreeItem userdata so we give it back */
975 lua_pushvalue(L, 1);
976
977 WSLUA_RETURN(1)return (1); /* The same TreeItem. */
978}
979
980
981/* WSLUA_ATTRIBUTE TreeItem_visible RO Get the <<lua_class_TreeItem,`TreeItem`>>'s subtree visibility status (boolean). */
982static int TreeItem_get_visible(lua_State* L) {
983 TreeItem ti = checkTreeItem(L,1);
984
985 if (ti->tree) {
986 lua_pushboolean(L, PTREE_DATA(ti->tree)((ti->tree)->tree_data)->visible);
987 }
988 else {
989 lua_pushboolean(L, false0);
990 }
991
992 return 1;
993}
994
995
996/* WSLUA_ATTRIBUTE TreeItem_generated RW Set/get the <<lua_class_TreeItem,`TreeItem`>>'s generated state (boolean). */
997static int TreeItem_get_generated(lua_State* L) {
998 TreeItem ti = checkTreeItem(L,1);
999
1000 lua_pushboolean(L, proto_item_is_generated(ti->item));
1001
1002 return 1;
1003}
1004
1005/* the following is used as both a method and attribute. As a method it defaults
1006 to setting the value, because that's what it used to do before. */
1007WSLUA_METHODstatic int TreeItem_set_generated(lua_State *L) {
1008 /* Marks the <<lua_class_TreeItem,`TreeItem`>> as a generated field (with data inferred but not contained in the packet).
1009
1010 This used to return nothing, but as of 1.11.3 it returns the same tree item to allow chained calls.
1011 */
1012#define WSLUA_OPTARG_TreeItem_set_generated_BOOL2 2 /* A Lua boolean, which if `true` sets the <<lua_class_TreeItem,`TreeItem`>>
1013 generated flag, else clears it (default=true) */
1014 TreeItem ti = checkTreeItem(L,1);
1015 bool_Bool set = wslua_optbool(L, WSLUA_OPTARG_TreeItem_set_generated_BOOL2, true1);
1016
1017 if (set) {
1018 proto_item_set_generated(ti->item);
1019 } else {
1020 if (ti->item)
1021 FI_RESET_FLAG(PITEM_FINFO(ti->item), FI_GENERATED)do { if (((ti->item)->finfo)) (((ti->item)->finfo
))->flags = (((ti->item)->finfo))->flags & ~(
0x00000002); } while(0);
1022 }
1023
1024 /* copy the TreeItem userdata so we give it back */
1025 lua_pushvalue(L, 1);
1026
1027 WSLUA_RETURN(1)return (1); /* The same TreeItem. */
1028}
1029
1030/* WSLUA_ATTRIBUTE TreeItem_hidden RW Set/get <<lua_class_TreeItem,`TreeItem`>>'s hidden state (boolean). */
1031static int TreeItem_get_hidden(lua_State* L) {
1032 TreeItem ti = checkTreeItem(L,1);
1033
1034 lua_pushboolean(L, proto_item_is_hidden(ti->item));
1035
1036 return 1;
1037}
1038
1039/* the following is used as both a method and attribute. As a method it defaults
1040 to setting the value, because that's what it used to do before. */
1041WSLUA_METHODstatic int TreeItem_set_hidden(lua_State *L) {
1042 /*
1043 Marks the <<lua_class_TreeItem,`TreeItem`>> as a hidden field (neither displayed nor used in filters).
1044 Deprecated
1045
1046 This used to return nothing, but as of 1.11.3 it returns the same tree item to allow chained calls.
1047 */
1048#define WSLUA_OPTARG_TreeItem_set_hidden_BOOL2 2 /* A Lua boolean, which if `true` sets the <<lua_class_TreeItem,`TreeItem`>>
1049 hidden flag, else clears it. Default is `true`. */
1050 TreeItem ti = checkTreeItem(L,1);
1051 bool_Bool set = wslua_optbool(L, WSLUA_OPTARG_TreeItem_set_hidden_BOOL2, true1);
1052
1053 if (set) {
1054 proto_item_set_hidden(ti->item);
1055 } else {
1056 proto_item_set_visible(ti->item);
1057 }
1058
1059 /* copy the TreeItem userdata so we give it back */
1060 lua_pushvalue(L, 1);
1061
1062 WSLUA_RETURN(1)return (1); /* The same TreeItem. */
1063}
1064
1065/* WSLUA_ATTRIBUTE TreeItem_len RW Set/get <<lua_class_TreeItem,`TreeItem`>>'s length inside tvb, after it has already been created. */
1066static int TreeItem_get_len(lua_State* L) {
1067 TreeItem ti = checkTreeItem(L,1);
1068 int len = 0;
1069
1070 /* XXX - this is *NOT* guaranteed to return a correct value! */
1071 len = proto_item_get_len(ti->item);
1072
1073 lua_pushinteger(L, len > 0 ? len : 0);
1074
1075 return 1;
1076}
1077
1078WSLUA_METHODstatic int TreeItem_set_len(lua_State *L) {
1079 /* Set <<lua_class_TreeItem,`TreeItem`>>'s length inside tvb, after it has already been created.
1080
1081 This used to return nothing, but as of 1.11.3 it returns the same tree item to allow chained calls.
1082 */
1083#define WSLUA_ARG_TreeItem_set_len_LEN2 2 /* The length to be used. */
1084 TreeItem ti = checkTreeItem(L,1);
1085 int len = (int)luaL_checkinteger(L,WSLUA_ARG_TreeItem_set_len_LEN2);
1086
1087 if (len < 0) {
1088 luaL_argerror(L,WSLUA_ARG_TreeItem_set_len_LEN2,"must be a positive value");
1089 return 0;
1090 }
1091
1092 proto_item_set_len(ti->item, len);
1093
1094 /* copy the TreeItem userdata so we give it back */
1095 lua_pushvalue(L, 1);
1096
1097 WSLUA_RETURN(1)return (1); /* The same TreeItem. */
1098}
1099
1100WSLUA_METHODstatic int TreeItem_referenced(lua_State *L) {
1101 /* Checks if a <<lua_class_ProtoField,`ProtoField`>> or <<lua_class_Dissector,`Dissector`>> is referenced by a filter/tap/UI.
1102
1103 If this function returns `false`, it means that the field (or dissector) does not need to be dissected
1104 and can be safely skipped. By skipping a field rather than dissecting it, the dissector will
1105 usually run faster since Wireshark will not do extra dissection work when it doesn't need the field.
1106
1107 You can use this in conjunction with the TreeItem.visible attribute. This function will always return
1108 true when the TreeItem is visible. When it is not visible and the field is not referenced, you can
1109 speed up the dissection by not dissecting the field as it is not needed for display or filtering.
1110
1111 This function takes one parameter that can be a <<lua_class_ProtoField,`ProtoField`>> or <<lua_class_Dissector,`Dissector`>>.
1112 The <<lua_class_Dissector,`Dissector`>> form is useful when you need to decide whether to call a sub-dissector.
1113 */
1114#define WSLUA_ARG_TreeItem_referenced_PROTOFIELD2 2 /* The <<lua_class_ProtoField,`ProtoField`>> or <<lua_class_Dissector,`Dissector`>> to check if referenced. */
1115 TreeItem ti = checkTreeItem(L, 1);
1116 if (!ti) return 0;
1117 ProtoField f = shiftProtoField(L, WSLUA_ARG_TreeItem_referenced_PROTOFIELD2);
1118 if (f) {
1119 lua_pushboolean(L, proto_field_is_referenced(ti->tree, f->hfid));
1120 }
1121 else {
1122 Dissector d = checkDissector(L, WSLUA_ARG_TreeItem_referenced_PROTOFIELD2);
1123 if (!d) return 0;
1124 lua_pushboolean(L, proto_field_is_referenced(ti->tree, dissector_handle_get_protocol_index(d)));
1125 }
1126 WSLUA_RETURN(1)return (1); /* A boolean indicating if the ProtoField/Dissector is referenced */
1127}
1128
1129WSLUA_METAMETHODstatic int TreeItem__tostring(lua_State* L) {
1130 /* Returns string debug information about the <<lua_class_TreeItem,`TreeItem`>>. */
1131 TreeItem ti = toTreeItem(L,1);
1132
1133 if (ti) {
1134 lua_pushfstring(L,
1135 "TreeItem: expired=%s, has item=%s, has subtree=%s, they are %sthe same",
1136 ti->expired ? "true" : "false",
1137 ti->item ? "true" : "false",
1138 ti->tree ? "true" : "false",
1139 (ti->tree == ti->item) ? "" : "not ");
1140 }
1141 else {
1142 lua_pushstring(L, "No TreeItem object!");
1143 }
1144
1145 return 1;
1146}
1147
1148/* Gets registered as metamethod automatically by WSLUA_REGISTER_CLASS/META */
1149static int TreeItem__gc(lua_State* L) {
1150 TreeItem ti = toTreeItem(L,1);
1151 if (!ti) return 0;
1152 if (!ti->expired)
1153 ti->expired = true1;
1154 else
1155 g_free(ti);
1156 return 0;
1157}
1158
1159WSLUA_ATTRIBUTESstatic const wslua_attribute_table TreeItem_attributes[] = {
1160 WSLUA_ATTRIBUTE_RWREG(TreeItem,generated){ "generated", TreeItem_get_generated, TreeItem_set_generated
},
1161 WSLUA_ATTRIBUTE_RWREG(TreeItem,hidden){ "hidden", TreeItem_get_hidden, TreeItem_set_hidden },
1162 WSLUA_ATTRIBUTE_RWREG(TreeItem,len){ "len", TreeItem_get_len, TreeItem_set_len },
1163 WSLUA_ATTRIBUTE_RWREG(TreeItem,text){ "text", TreeItem_get_text, TreeItem_set_text },
1164 WSLUA_ATTRIBUTE_ROREG(TreeItem,visible){ "visible", TreeItem_get_visible, ((void*)0) },
1165 { NULL((void*)0), NULL((void*)0), NULL((void*)0) }
1166};
1167
1168WSLUA_METHODSstatic const luaL_Reg TreeItem_methods[] = {
1169 WSLUA_CLASS_FNREG(TreeItem,add_packet_field){ "add_packet_field", TreeItem_add_packet_field },
1170 WSLUA_CLASS_FNREG(TreeItem,add){ "add", TreeItem_add },
1171 WSLUA_CLASS_FNREG(TreeItem,add_le){ "add_le", TreeItem_add_le },
1172 WSLUA_CLASS_FNREG(TreeItem,set_text){ "set_text", TreeItem_set_text },
1173 WSLUA_CLASS_FNREG(TreeItem,append_text){ "append_text", TreeItem_append_text },
1174 WSLUA_CLASS_FNREG(TreeItem,prepend_text){ "prepend_text", TreeItem_prepend_text },
1175 WSLUA_CLASS_FNREG(TreeItem,add_expert_info){ "add_expert_info", TreeItem_add_expert_info },
1176 WSLUA_CLASS_FNREG(TreeItem,add_proto_expert_info){ "add_proto_expert_info", TreeItem_add_proto_expert_info },
1177 WSLUA_CLASS_FNREG(TreeItem,add_tvb_expert_info){ "add_tvb_expert_info", TreeItem_add_tvb_expert_info },
1178 WSLUA_CLASS_FNREG(TreeItem,set_generated){ "set_generated", TreeItem_set_generated },
1179 WSLUA_CLASS_FNREG(TreeItem,set_hidden){ "set_hidden", TreeItem_set_hidden },
1180 WSLUA_CLASS_FNREG(TreeItem,set_len){ "set_len", TreeItem_set_len },
1181 WSLUA_CLASS_FNREG(TreeItem,referenced){ "referenced", TreeItem_referenced },
1182 { NULL((void*)0), NULL((void*)0) }
1183};
1184
1185WSLUA_METAstatic const luaL_Reg TreeItem_meta[] = {
1186 WSLUA_CLASS_MTREG(TreeItem,tostring){ "__" "tostring", TreeItem__tostring },
1187 { NULL((void*)0), NULL((void*)0) }
1188};
1189
1190int TreeItem_register(lua_State *L) {
1191 int* etts[] = { &wslua_ett };
1192 wslua_ett = -1; /* Reset to support reload Lua plugins */
1193 WSLUA_REGISTER_CLASS_WITH_ATTRS(TreeItem){ const wslua_class TreeItem_class = { .name = "TreeItem", .class_methods
= TreeItem_methods, .class_meta = TreeItem_meta, .instance_methods
= TreeItem_methods, .instance_meta = TreeItem_meta, .attrs =
TreeItem_attributes }; wslua_register_class(L, &TreeItem_class
); (lua_getfield(L, (-1000000 - 1000), ("TreeItem"))); lua_pushcclosure
(L, (TreeItem__gc), 0); lua_setfield(L, -2, "__gc"); lua_settop
(L, -(1)-1); };
1194 if (outstanding_TreeItem != NULL((void*)0)) {
1195 g_ptr_array_unref(outstanding_TreeItem);
1196 }
1197 outstanding_TreeItem = g_ptr_array_new();
1198 proto_register_subtree_array(etts,1);
1199 return 0;
1200}
1201
1202/*
1203 * Editor modelines - https://www.wireshark.org/tools/modelines.html
1204 *
1205 * Local variables:
1206 * c-basic-offset: 4
1207 * tab-width: 8
1208 * indent-tabs-mode: nil
1209 * End:
1210 *
1211 * vi: set shiftwidth=4 tabstop=8 expandtab:
1212 * :indentSize=4:tabSize=8:noTabs=true:
1213 */