### Bug Summary

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

### 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_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-05-08-100338-3641-1 -x c /builds/wireshark/wireshark/epan/wslua/wslua_tree.c

Keyboard shortcuts:

- Use 'j/k' keys for keyboard navigation
- Use 'Shift+S' to show/hide relevant lines
- Use '?' to toggle this window

Close
Show only relevant lines Show control flow arrows

1 | /*
2 | * wslua_tree.c
3 | *
4 | * Wireshark's interface to the Lua Programming Language
5 | *
6 | * (c) 2006, Luis E. Garcia Ontanon <luis@ontanon.org>
7 | * (c) 2008, Balint Reczey <balint.reczey@ericsson.com>
8 | *
9 | * Wireshark - Network traffic analyzer
10 | * By Gerald Combs <gerald@wireshark.org>
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 |
24 | static int wslua_ett = -1;
25 |
26 | static GPtrArray* outstanding_TreeItem;
27 |
28 |
29 | /* pushing a TreeItem with a NULL item or subtree is completely valid for this function */
30 | TreeItem 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 */
43 | TreeItem 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 |
53 | CLEAR_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 |
55 | WSLUA_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 */
74 | static proto_item *
75 | try_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 |
276 | WSLUA_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 | */
445 | static 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 | if (!lua_isnumber(L,1)) {
538 | THROW_LUA_ERROR("Expected number for unsigned integer field")except_throwf(1, (6), "Expected number for unsigned integer field" );
539 | return 0;
540 | }
541 | 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) ));
542 | break;
543 | case FT_INT8:
544 | case FT_INT16:
545 | case FT_INT24:
546 | case FT_INT32:
547 | if (!lua_isnumber(L,1)) {
548 | THROW_LUA_ERROR("Expected number for integer field")except_throwf(1, (6), "Expected number for integer field");
549 | return 0;
550 | }
551 | 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) ));
552 | break;
553 | case FT_FLOAT:
554 | if (!lua_isnumber(L,1)) {
555 | THROW_LUA_ERROR("Expected number for FT_FLOAT field")except_throwf(1, (6), "Expected number for FT_FLOAT field");
556 | return 0;
557 | }
558 | item = proto_tree_add_float(tree_item->tree,hfid,tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len,(float)luaL_checknumber(L,1));
559 | break;
560 | case FT_DOUBLE:
561 | if (!lua_isnumber(L,1)) {
562 | THROW_LUA_ERROR("Expected number for FT_DOUBLE field")except_throwf(1, (6), "Expected number for FT_DOUBLE field");
563 | return 0;
564 | }
565 | item = proto_tree_add_double(tree_item->tree,hfid,tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len,(double)luaL_checknumber(L,1));
566 | break;
567 | case FT_ABSOLUTE_TIME:
568 | case FT_RELATIVE_TIME:
569 | if (!isNSTime(L,1)) {
570 | THROW_LUA_ERROR("Expected NSTime for %s field", (type==FT_ABSOLUTE_TIME ? "FT_ABSOLUTE_TIME" : "FT_RELATIVE_TIME"))except_throwf(1, (6), "Expected NSTime for %s field", (type== FT_ABSOLUTE_TIME ? "FT_ABSOLUTE_TIME" : "FT_RELATIVE_TIME"));
571 | return 0;
572 | }
573 | item = proto_tree_add_time(tree_item->tree,hfid,tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len,checkNSTime(L,1));
574 | break;
575 | case FT_STRING:
576 | case FT_STRINGZ:
577 | {
578 | const char *value = lua_tostring(L, 1)lua_tolstring(L, (1), ((void*)0));
579 | if (value == NULL((void*)0)) {
580 | THROW_LUA_ERROR("Expected string for %s field", (type==FT_STRING ? "FT_STRING" : "FT_STRINGZ") )except_throwf(1, (6), "Expected string for %s field", (type== FT_STRING ? "FT_STRING" : "FT_STRINGZ"));
581 | return 0;
582 | }
583 | item = proto_tree_add_string(tree_item->tree,hfid,tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len,value);
584 | }
585 | break;
586 | case FT_BYTES:
587 | {
588 | const char *value = lua_tostring(L, 1)lua_tolstring(L, (1), ((void*)0));
589 | if (value == NULL((void*)0)) {
590 | THROW_LUA_ERROR("Expected bytes for FT_BYTES field")except_throwf(1, (6), "Expected bytes for FT_BYTES field");
591 | return 0;
592 | }
593 | item = proto_tree_add_bytes(tree_item->tree,hfid,tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len, (const uint8_t*)value);
594 | }
595 | break;
596 | case FT_UINT64:
597 | if (!isUInt64(L,1)) {
598 | THROW_LUA_ERROR("Expected UInt64 for FT_UINT64 field")except_throwf(1, (6), "Expected UInt64 for FT_UINT64 field");
599 | return 0;
600 | }
601 | item = proto_tree_add_uint64(tree_item->tree,hfid,tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len,checkUInt64(L,1));
602 | break;
603 | case FT_INT64:
604 | if (!isInt64(L,1)) {
605 | THROW_LUA_ERROR("Expected Int64 for FT_INT64 field")except_throwf(1, (6), "Expected Int64 for FT_INT64 field");
606 | return 0;
607 | }
608 | item = proto_tree_add_int64(tree_item->tree,hfid,tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len,checkInt64(L,1));
609 | break;
610 | case FT_IPv4:
611 | {
612 | Address addr = isAddress(L,1) ? checkAddress(L,1) : NULL((void*)0);
613 | uint32_t addr_value;
614 |
615 | if (addr == NULL((void*)0) || addr->type != AT_IPv4) {
616 | THROW_LUA_ERROR("Expected IPv4 address for FT_IPv4 field")except_throwf(1, (6), "Expected IPv4 address for FT_IPv4 field" );
617 | return 0;
618 | }
619 |
620 | /*
621 | * The address is not guaranteed to be aligned on a
622 | * 32-bit boundary, so we can't safely dereference
623 | * the pointer as if it were so aligned.
624 | */
625 | memcpy(&addr_value, addr->data, sizeof addr_value);
626 | item = proto_tree_add_ipv4(tree_item->tree,hfid,tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len,addr_value);
627 | }
628 | break;
629 | case FT_IPv6:
630 | {
631 | Address addr = isAddress(L,1) ? checkAddress(L,1) : NULL((void*)0);
632 | if (addr == NULL((void*)0) || addr->type != AT_IPv6) {
633 | THROW_LUA_ERROR("Expected IPv6 address for FT_IPv6 field")except_throwf(1, (6), "Expected IPv6 address for FT_IPv6 field" );
634 | return 0;
635 | }
636 |
637 | item = proto_tree_add_ipv6(tree_item->tree, hfid, tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len, (const ws_in6_addr *)addr->data);
638 | }
639 | break;
640 | case FT_ETHER:
641 | {
642 | Address addr = isAddress(L,1) ? checkAddress(L,1) : NULL((void*)0);
643 | if (addr == NULL((void*)0) || addr->type != AT_ETHER) {
644 | THROW_LUA_ERROR("Expected MAC address for FT_ETHER field")except_throwf(1, (6), "Expected MAC address for FT_ETHER field" );
645 | return 0;
646 | }
647 |
648 | item = proto_tree_add_ether(tree_item->tree, hfid, tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len, (const uint8_t *)addr->data);
649 | }
650 | break;
651 | case FT_UINT_BYTES:
652 | case FT_IPXNET:
653 | case FT_GUID:
654 | case FT_OID:
655 | case FT_REL_OID:
656 | case FT_SYSTEM_ID:
657 | case FT_VINES:
658 | case FT_FCWWN:
659 | default:
660 | THROW_LUA_ERROR("%s not yet supported", ftype_name(type))except_throwf(1, (6), "%s not yet supported", ftype_name(type ));
661 | return 0;
662 | }
663 |
664 | lua_remove(L,1)(lua_rotate(L, (1), -1), lua_settop(L, -(1)-1));
665 |
666 | } else {
667 | if (type == FT_FRAMENUM) {
668 | THROW_LUA_ERROR("ProtoField FRAMENUM cannot fetch value from Tvb")except_throwf(1, (6), "ProtoField FRAMENUM cannot fetch value from Tvb" );
669 | return 0;
670 | }
671 | /* the Lua stack is empty - no value was given - so decode the value from the tvb */
672 | 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);
673 | }
674 |
675 | if ( lua_gettop(L) ) {
676 | /* if there was a value, it was removed earlier, so what's left is the display string to set */
677 | const char* s = lua_tostring(L,1)lua_tolstring(L, (1), ((void*)0));
678 | if (s) proto_item_set_text(item,"%s",s);
679 | lua_remove(L,1)(lua_rotate(L, (1), -1), lua_settop(L, -(1)-1));
680 | }
681 |
682 | } else {
683 | /* no ProtoField or Proto was given - we're adding a text-only field,
684 | * any remaining parameters are parts of the text label. */
685 | if (lua_gettop(L)) {
686 | const char* s = lua_tostring(L,1)lua_tolstring(L, (1), ((void*)0));
687 | const int hf = get_hf_wslua_text();
688 | if (hf > -1) {
689 | /* use proto_tree_add_none_format() instead? */
690 | item = proto_tree_add_item(tree_item->tree, hf, tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len, ENC_NA0x00000000);
691 | proto_item_set_text(item, "%s", s);
692 | } else {
693 | THROW_LUA_ERROR("Internal error: hf_wslua_text not registered")except_throwf(1, (6), "Internal error: hf_wslua_text not registered" );
694 | }
695 | lua_remove(L,1)(lua_rotate(L, (1), -1), lua_settop(L, -(1)-1));
696 | } else {
697 | 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?)" );
698 | }
699 | }
700 |
701 | while(lua_gettop(L)) {
702 | /* keep appending more text */
703 | const char* s = lua_tostring(L,1)lua_tolstring(L, (1), ((void*)0));
704 | if (s) proto_item_append_text(item, " %s", s);
705 | lua_remove(L,1)(lua_rotate(L, (1), -1), lua_settop(L, -(1)-1));
706 | }
707 |
708 | push_TreeItem(L, proto_item_add_subtree(item,ett > 0 ? ett : wslua_ett), item);
709 |
710 | return 1;
711 | }
712 |
713 |
714 | WSLUA_METHODstatic int TreeItem_add(lua_State *L) {
715 | /*
716 | Adds a child item to this tree item, returning the new child <<lua_class_TreeItem,`TreeItem`>>.
717 |
718 | 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.
719 |
720 | This function has a complicated form: 'treeitem:add([protofield,] [tvbrange,] [[value], label]])', such that if the first
721 | 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;
722 | 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',
723 | 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
724 | be either a <<lua_class_TvbRange,`TvbRange`>> or a label, and the value is not in use.
725 |
726 | [discrete]
727 | ====== Example
728 |
729 | [source,lua]
730 | ----
731 | local proto_foo = Proto("foo", "Foo Protocol")
732 | proto_foo.fields.bytes = ProtoField.bytes("foo.bytes", "Byte array")
733 | proto_foo.fields.u16 = ProtoField.uint16("foo.u16", "Unsigned short", base.HEX)
734 |
735 | function proto_foo.dissector(buf, pinfo, tree)
736 | -- ignore packets less than 4 bytes long
737 | if buf:len() < 4 then return end
738 |
739 | -- ##############################################
740 | -- # Assume buf(0,4) == {0x00, 0x01, 0x00, 0x02}
741 | -- ##############################################
742 |
743 | local t = tree:add( proto_foo, buf() )
744 |
745 | -- Adds a byte array that shows as: "Byte array: 00010002"
746 | t:add( proto_foo.fields.bytes, buf(0,4) )
747 |
748 | -- Adds a byte array that shows as "Byte array: 313233"
749 | -- (the ASCII char code of each character in "123")
750 | t:add( proto_foo.fields.bytes, buf(0,4), "123" )
751 |
752 | -- Adds a tree item that shows as: "Unsigned short: 0x0001"
753 | t:add( proto_foo.fields.u16, buf(0,2) )
754 |
755 | -- Adds a tree item that shows as: "Unsigned short: 0x0064"
756 | t:add( proto_foo.fields.u16, buf(0,2), 100 )
757 |
758 | -- Adds a tree item that shows as: "Unsigned short: 0x0064 ( big endian )"
759 | t:add( proto_foo.fields.u16, buf(1,2), 100, nil, "(", nil, "big", 999, nil, "endian", nil, ")" )
760 |
761 | -- LITTLE ENDIAN: Adds a tree item that shows as: "Unsigned short: 0x0100"
762 | t:add_le( proto_foo.fields.u16, buf(0,2) )
763 |
764 | -- LITTLE ENDIAN: Adds a tree item that shows as: "Unsigned short: 0x6400"
765 | t:add_le( proto_foo.fields.u16, buf(0,2), 100 )
766 |
767 | -- LITTLE ENDIAN: Adds a tree item that shows as: "Unsigned short: 0x6400 ( little endian )"
768 | t:add_le( proto_foo.fields.u16, buf(1,2), 100, nil, "(", nil, "little", 999, nil, "endian", nil, ")" )
769 | end
770 |
771 | udp_table = DissectorTable.get("udp.port")
772 | udp_table:add(7777, proto_foo)
773 | ----
774 | */
775 | #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. */
776 | #define WSLUA_OPTARG_TreeItem_add_TVBRANGE3 3 /* The <<lua_class_TvbRange,`TvbRange`>> of bytes in the packet this tree item covers/represents. */
777 | #define WSLUA_OPTARG_TreeItem_add_VALUE4 4 /* The field's value, instead of the ProtoField/Proto one. */
778 | #define WSLUA_OPTARG_TreeItem_add_LABEL5 5 /* One or more strings to use for the tree item label, instead of the ProtoField/Proto one. */
779 |
780 | volatile int ret;
781 | 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); } }
782 | 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); } }
783 | ){ 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); } }
784 | WSLUA_RETURN(ret)return (ret); /* The new child TreeItem. */
785 | }
786 |
787 | WSLUA_METHODstatic int TreeItem_add_le(lua_State *L) {
788 | /*
789 | Adds a child item to this tree item, returning the new child <<lua_class_TreeItem,`TreeItem`>>.
790 |
791 | If the <<lua_class_ProtoField,`ProtoField`>> represents a numeric value (int, uint or float), then it's treated as a Little Endian value.
792 |
793 | This function has a complicated form: 'treeitem:add_le([protofield,] [tvbrange,] [[value], label]])', such that if the first
794 | 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;
795 | 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',
796 | 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
797 | be either a <<lua_class_TvbRange,`TvbRange`>> or a label, and the value is not in use.
798 | */
799 | #define WSLUA_OPTARG_TreeItem_add_le_PROTOFIELD2 2 /* The ProtoField field or Proto protocol object to add to the tree. */
800 | #define WSLUA_OPTARG_TreeItem_add_le_TVBRANGE3 3 /* The TvbRange of bytes in the packet this tree item covers/represents. */
801 | #define WSLUA_OPTARG_TreeItem_add_le_VALUE4 4 /* The field's value, instead of the ProtoField/Proto one. */
802 | #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. */
803 | volatile int ret;
1 | 'ret' declared without an initial value | →
804 | 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); } }
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 | →
805 | 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); } }
806 | ){ 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); } }
807 | WSLUA_RETURN(ret)return (ret); /* The new child TreeItem. */
9 | ← | Undefined or garbage value returned to caller
808 | }
809 |
810 | /* WSLUA_ATTRIBUTE TreeItem_text RW Set/get the <<lua_class_TreeItem,`TreeItem`>>'s display string (string).
811 |
812 | For the getter, if the TreeItem has no display string, then nil is returned.
813 | */
814 | static int TreeItem_get_text(lua_State* L) {
815 | TreeItem ti = checkTreeItem(L,1);
816 | char label_str[ITEM_LABEL_LENGTH240+1];
817 | char *label_ptr;
818 |
819 | if (ti->item && PITEM_FINFO(ti->item)((ti->item)->finfo)) {
820 | field_info *fi = PITEM_FINFO(ti->item)((ti->item)->finfo);
821 |
822 | if (!fi->rep) {
823 | label_ptr = label_str;
824 | proto_item_fill_label(fi, label_str, NULL((void*)0));
825 | } else
826 | label_ptr = fi->rep->representation;
827 |
828 | if (label_ptr) {
829 | lua_pushstring(L, label_ptr);
830 | } else {
831 | lua_pushnil(L);
832 | }
833 | } else {
834 | lua_pushnil(L);
835 | }
836 |
837 | return 1;
838 | }
839 |
840 | /* the following is used as both a method and attribute */
841 | WSLUA_METHODstatic int TreeItem_set_text(lua_State *L) {
842 | /* Sets the text of the label.
843 |
844 | This used to return nothing, but as of 1.11.3 it returns the same tree item to allow chained calls.
845 | */
846 | #define WSLUA_ARG_TreeItem_set_text_TEXT2 2 /* The text to be used. */
847 | TreeItem ti = checkTreeItem(L,1);
848 | const char* s = luaL_checkstring(L,WSLUA_ARG_TreeItem_set_text_TEXT)(luaL_checklstring(L, (2), ((void*)0)));
849 |
850 | proto_item_set_text(ti->item,"%s",s);
851 |
852 | /* copy the TreeItem userdata so we give it back */
853 | lua_pushvalue(L, 1);
854 |
855 | WSLUA_RETURN(1)return (1); /* The same TreeItem. */
856 | }
857 |
858 | WSLUA_METHODstatic int TreeItem_append_text(lua_State *L) {
859 | /* Appends text to the label.
860 |
861 | This used to return nothing, but as of 1.11.3 it returns the same tree item to allow chained calls.
862 | */
863 | #define WSLUA_ARG_TreeItem_append_text_TEXT2 2 /* The text to be appended. */
864 | TreeItem ti = checkTreeItem(L,1);
865 | const char* s = luaL_checkstring(L,WSLUA_ARG_TreeItem_append_text_TEXT)(luaL_checklstring(L, (2), ((void*)0)));
866 |
867 | proto_item_append_text(ti->item,"%s",s);
868 |
869 | /* copy the TreeItem userdata so we give it back */
870 | lua_pushvalue(L, 1);
871 |
872 | WSLUA_RETURN(1)return (1); /* The same TreeItem. */
873 | }
874 |
875 | WSLUA_METHODstatic int TreeItem_prepend_text(lua_State *L) {
876 | /* Prepends text to the label.
877 |
878 | This used to return nothing, but as of 1.11.3 it returns the same tree item to allow chained calls.
879 | */
880 | #define WSLUA_ARG_TreeItem_prepend_text_TEXT2 2 /* The text to be prepended. */
881 | TreeItem ti = checkTreeItem(L,1);
882 | const char* s = luaL_checkstring(L,WSLUA_ARG_TreeItem_prepend_text_TEXT)(luaL_checklstring(L, (2), ((void*)0)));
883 |
884 | proto_item_prepend_text(ti->item,"%s",s);
885 |
886 | /* copy the TreeItem userdata so we give it back */
887 | lua_pushvalue(L, 1);
888 |
889 | WSLUA_RETURN(1)return (1); /* The same TreeItem. */
890 | }
891 |
892 | WSLUA_METHODstatic int TreeItem_add_expert_info(lua_State *L) {
893 | /* Sets the expert flags of the item and adds expert info to the packet.
894 |
895 | This function does *not* create a truly filterable expert info for a protocol.
896 | Instead you should use `TreeItem.add_proto_expert_info()`.
897 |
898 | Note: This function is provided for backwards compatibility only, and should not
899 | be used in new Lua code. It may be removed in the future. You should only
900 | use `TreeItem.add_proto_expert_info()`.
901 | */
902 | #define WSLUA_OPTARG_TreeItem_add_expert_info_GROUP2 2 /* One of:
903 | `PI_CHECKSUM`,
904 | `PI_SEQUENCE`,
905 | `PI_RESPONSE_CODE`,
906 | `PI_REQUEST_CODE`,
907 | `PI_UNDECODED`,
908 | `PI_REASSEMBLE`,
909 | `PI_MALFORMED`,
910 | `PI_DEBUG`,
911 | `PI_PROTOCOL`,
912 | `PI_SECURITY`,
913 | `PI_COMMENTS_GROUP`,
914 | `PI_DECRYPTION`,
915 | `PI_ASSUMPTION`,
916 | `PI_DEPRECATED`,
917 | `PI_RECEIVE`,
918 | `PI_INTERFACE`,
919 | or `PI_DISSECTOR_BUG`. */
920 | #define WSLUA_OPTARG_TreeItem_add_expert_info_SEVERITY3 3 /* One of:
921 | `PI_COMMENT`,
922 | `PI_CHAT`,
923 | `PI_NOTE`,
924 | `PI_WARN`,
925 | or `PI_ERROR`. */
926 | #define WSLUA_OPTARG_TreeItem_add_expert_info_TEXT4 4 /* The text for the expert info display. */
927 | TreeItem ti = checkTreeItem(L,1);
928 | int group = (int)luaL_optinteger(L,WSLUA_OPTARG_TreeItem_add_expert_info_GROUP2,PI_DEBUG0x08000000);
929 | int severity = (int)luaL_optinteger(L,WSLUA_OPTARG_TreeItem_add_expert_info_SEVERITY3,PI_CHAT0x00200000);
930 | expert_field* ei_info = wslua_get_expert_field(group, severity);
931 | const char* str;
932 |
933 | if (lua_gettop(L) >= WSLUA_OPTARG_TreeItem_add_expert_info_TEXT4) {
934 | str = wslua_checkstring_only(L, WSLUA_OPTARG_TreeItem_add_expert_info_TEXT4);
935 | expert_add_info_format(lua_pinfo, ti->item, ei_info, "%s", str);
936 | } else {
937 | expert_add_info(lua_pinfo, ti->item, ei_info);
938 | }
939 |
940 | /* copy the TreeItem userdata so we give it back */
941 | lua_pushvalue(L, 1);
942 |
943 | WSLUA_RETURN(1)return (1); /* The same TreeItem. */
944 | }
945 |
946 | WSLUA_METHODstatic int TreeItem_add_proto_expert_info(lua_State *L) {
947 | /* Sets the expert flags of the tree item and adds expert info to the packet. */
948 | #define WSLUA_ARG_TreeItem_add_proto_expert_info_EXPERT2 2 /* The <<lua_class_ProtoExpert,`ProtoExpert`>> object to add to the tree. */
949 | #define WSLUA_OPTARG_TreeItem_add_proto_expert_info_TEXT3 3 /* Text for the expert info display
950 | (default is to use the registered
951 | text). */
952 | TreeItem ti = checkTreeItem(L,1);
953 | ProtoExpert expert = checkProtoExpert(L,WSLUA_ARG_TreeItem_add_proto_expert_info_EXPERT2);
954 | const char* str;
955 |
956 | if (expert->ids.ei == EI_INIT_EI0 || expert->ids.hf == EI_INIT_HF0) {
957 | luaL_error(L, "ProtoExpert is not registered");
958 | return 0;
959 | }
960 |
961 | if (lua_gettop(L) >= WSLUA_OPTARG_TreeItem_add_proto_expert_info_TEXT3) {
962 | str = wslua_checkstring_only(L, WSLUA_OPTARG_TreeItem_add_proto_expert_info_TEXT3);
963 | expert_add_info_format(lua_pinfo, ti->item, &expert->ids, "%s", str);
964 | } else {
965 | expert_add_info(lua_pinfo, ti->item, &expert->ids);
966 | }
967 |
968 | /* copy the TreeItem userdata so we give it back */
969 | lua_pushvalue(L, 1);
970 |
971 | WSLUA_RETURN(1)return (1); /* The same TreeItem. */
972 | }
973 |
974 | WSLUA_METHODstatic int TreeItem_add_tvb_expert_info(lua_State *L) {
975 | /* Sets the expert flags of the tree item and adds expert info to the packet
976 | associated with the <<lua_class_Tvb,`Tvb`>> or <<lua_class_TvbRange,`TvbRange`>> bytes in the packet. */
977 | #define WSLUA_ARG_TreeItem_add_tvb_expert_info_EXPERT2 2 /* The <<lua_class_ProtoExpert,`ProtoExpert`>> object to add to the tree. */
978 | #define WSLUA_ARG_TreeItem_add_tvb_expert_info_TVB3 3 /* The <<lua_class_Tvb,`Tvb`>> or <<lua_class_TvbRange,`TvbRange`>> object bytes to associate
979 | the expert info with. */
980 | #define WSLUA_OPTARG_TreeItem_add_tvb_expert_info_TEXT4 4 /* Text for the expert info display
981 | (default is to use the registered
982 | text). */
983 | TreeItem ti = checkTreeItem(L,1);
984 | ProtoExpert expert = checkProtoExpert(L,WSLUA_ARG_TreeItem_add_proto_expert_info_EXPERT2);
985 | TvbRange tvbr;
986 | const char* str;
987 |
988 | if (expert->ids.ei == EI_INIT_EI0 || expert->ids.hf == EI_INIT_HF0) {
989 | luaL_error(L, "ProtoExpert is not registered");
990 | return 0;
991 | }
992 |
993 | tvbr = shiftTvbRange(L,WSLUA_ARG_TreeItem_add_tvb_expert_info_TVB3);
994 |
995 | if (!tvbr) {
996 | tvbr = wmem_new(lua_pinfo->pool, struct _wslua_tvbrange)((struct _wslua_tvbrange*)wmem_alloc((lua_pinfo->pool), sizeof (struct _wslua_tvbrange)));
997 | tvbr->tvb = shiftTvb(L,WSLUA_ARG_TreeItem_add_tvb_expert_info_TVB3);
998 | if (!tvbr->tvb) {
999 | tvbr->tvb = wmem_new(lua_pinfo->pool, struct _wslua_tvb)((struct _wslua_tvb*)wmem_alloc((lua_pinfo->pool), sizeof( struct _wslua_tvb)));
1000 | }
1001 | tvbr->tvb->ws_tvb = lua_tvb;
1002 | tvbr->offset = 0;
1003 | tvbr->len = 0;
1004 | }
1005 |
1006 | if (lua_gettop(L) >= WSLUA_OPTARG_TreeItem_add_proto_expert_info_TEXT3) {
1007 | str = wslua_checkstring_only(L, WSLUA_OPTARG_TreeItem_add_proto_expert_info_TEXT3);
1008 | proto_tree_add_expert_format(ti->tree, lua_pinfo, &expert->ids,
1009 | tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len,
1010 | "%s", str);
1011 | } else {
1012 | proto_tree_add_expert(ti->tree, lua_pinfo, &expert->ids,
1013 | tvbr->tvb->ws_tvb, tvbr->offset, tvbr->len);
1014 | }
1015 |
1016 | /* copy the TreeItem userdata so we give it back */
1017 | lua_pushvalue(L, 1);
1018 |
1019 | WSLUA_RETURN(1)return (1); /* The same TreeItem. */
1020 | }
1021 |
1022 |
1023 | /* WSLUA_ATTRIBUTE TreeItem_visible RO Get the <<lua_class_TreeItem,`TreeItem`>>'s subtree visibility status (boolean). */
1024 | static int TreeItem_get_visible(lua_State* L) {
1025 | TreeItem ti = checkTreeItem(L,1);
1026 |
1027 | if (ti->tree) {
1028 | lua_pushboolean(L, PTREE_DATA(ti->tree)((ti->tree)->tree_data)->visible);
1029 | }
1030 | else {
1031 | lua_pushboolean(L, false0);
1032 | }
1033 |
1034 | return 1;
1035 | }
1036 |
1037 |
1038 | /* WSLUA_ATTRIBUTE TreeItem_generated RW Set/get the <<lua_class_TreeItem,`TreeItem`>>'s generated state (boolean). */
1039 | static int TreeItem_get_generated(lua_State* L) {
1040 | TreeItem ti = checkTreeItem(L,1);
1041 |
1042 | lua_pushboolean(L, proto_item_is_generated(ti->item));
1043 |
1044 | return 1;
1045 | }
1046 |
1047 | /* the following is used as both a method and attribute. As a method it defaults
1048 | to setting the value, because that's what it used to do before. */
1049 | WSLUA_METHODstatic int TreeItem_set_generated(lua_State *L) {
1050 | /* Marks the <<lua_class_TreeItem,`TreeItem`>> as a generated field (with data inferred but not contained in the packet).
1051 |
1052 | This used to return nothing, but as of 1.11.3 it returns the same tree item to allow chained calls.
1053 | */
1054 | #define WSLUA_OPTARG_TreeItem_set_generated_BOOL2 2 /* A Lua boolean, which if `true` sets the <<lua_class_TreeItem,`TreeItem`>>
1055 | generated flag, else clears it (default=true) */
1056 | TreeItem ti = checkTreeItem(L,1);
1057 | bool_Bool set = wslua_optbool(L, WSLUA_OPTARG_TreeItem_set_generated_BOOL2, true1);
1058 |
1059 | if (set) {
1060 | proto_item_set_generated(ti->item);
1061 | } else {
1062 | if (ti->item)
1063 | 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);
1064 | }
1065 |
1066 | /* copy the TreeItem userdata so we give it back */
1067 | lua_pushvalue(L, 1);
1068 |
1069 | WSLUA_RETURN(1)return (1); /* The same TreeItem. */
1070 | }
1071 |
1072 | /* WSLUA_ATTRIBUTE TreeItem_hidden RW Set/get <<lua_class_TreeItem,`TreeItem`>>'s hidden state (boolean). */
1073 | static int TreeItem_get_hidden(lua_State* L) {
1074 | TreeItem ti = checkTreeItem(L,1);
1075 |
1076 | lua_pushboolean(L, proto_item_is_hidden(ti->item));
1077 |
1078 | return 1;
1079 | }
1080 |
1081 | /* the following is used as both a method and attribute. As a method it defaults
1082 | to setting the value, because that's what it used to do before. */
1083 | WSLUA_METHODstatic int TreeItem_set_hidden(lua_State *L) {
1084 | /*
1085 | Marks the <<lua_class_TreeItem,`TreeItem`>> as a hidden field (neither displayed nor used in filters).
1086 | Deprecated
1087 |
1088 | This used to return nothing, but as of 1.11.3 it returns the same tree item to allow chained calls.
1089 | */
1090 | #define WSLUA_OPTARG_TreeItem_set_hidden_BOOL2 2 /* A Lua boolean, which if `true` sets the <<lua_class_TreeItem,`TreeItem`>>
1091 | hidden flag, else clears it. Default is `true`. */
1092 | TreeItem ti = checkTreeItem(L,1);
1093 | bool_Bool set = wslua_optbool(L, WSLUA_OPTARG_TreeItem_set_hidden_BOOL2, true1);
1094 |
1095 | if (set) {
1096 | proto_item_set_hidden(ti->item);
1097 | } else {
1098 | proto_item_set_visible(ti->item);
1099 | }
1100 |
1101 | /* copy the TreeItem userdata so we give it back */
1102 | lua_pushvalue(L, 1);
1103 |
1104 | WSLUA_RETURN(1)return (1); /* The same TreeItem. */
1105 | }
1106 |
1107 | /* WSLUA_ATTRIBUTE TreeItem_len RW Set/get <<lua_class_TreeItem,`TreeItem`>>'s length inside tvb, after it has already been created. */
1108 | static int TreeItem_get_len(lua_State* L) {
1109 | TreeItem ti = checkTreeItem(L,1);
1110 | int len = 0;
1111 |
1112 | /* XXX - this is *NOT* guaranteed to return a correct value! */
1113 | len = proto_item_get_len(ti->item);
1114 |
1115 | lua_pushinteger(L, len > 0 ? len : 0);
1116 |
1117 | return 1;
1118 | }
1119 |
1120 | WSLUA_METHODstatic int TreeItem_set_len(lua_State *L) {
1121 | /* Set <<lua_class_TreeItem,`TreeItem`>>'s length inside tvb, after it has already been created.
1122 |
1123 | This used to return nothing, but as of 1.11.3 it returns the same tree item to allow chained calls.
1124 | */
1125 | #define WSLUA_ARG_TreeItem_set_len_LEN2 2 /* The length to be used. */
1126 | TreeItem ti = checkTreeItem(L,1);
1127 | int len = (int)luaL_checkinteger(L,WSLUA_ARG_TreeItem_set_len_LEN2);
1128 |
1129 | if (len < 0) {
1130 | luaL_argerror(L,WSLUA_ARG_TreeItem_set_len_LEN2,"must be a positive value");
1131 | return 0;
1132 | }
1133 |
1134 | proto_item_set_len(ti->item, len);
1135 |
1136 | /* copy the TreeItem userdata so we give it back */
1137 | lua_pushvalue(L, 1);
1138 |
1139 | WSLUA_RETURN(1)return (1); /* The same TreeItem. */
1140 | }
1141 |
1142 | WSLUA_METHODstatic int TreeItem_referenced(lua_State *L) {
1143 | /* Checks if a <<lua_class_ProtoField,`ProtoField`>> or <<lua_class_Dissector,`Dissector`>> is referenced by a filter/tap/UI.
1144 |
1145 | If this function returns `false`, it means that the field (or dissector) does not need to be dissected
1146 | and can be safely skipped. By skipping a field rather than dissecting it, the dissector will
1147 | usually run faster since Wireshark will not do extra dissection work when it doesn't need the field.
1148 |
1149 | You can use this in conjunction with the TreeItem.visible attribute. This function will always return
1150 | true when the TreeItem is visible. When it is not visible and the field is not referenced, you can
1151 | speed up the dissection by not dissecting the field as it is not needed for display or filtering.
1152 |
1153 | This function takes one parameter that can be a <<lua_class_ProtoField,`ProtoField`>> or <<lua_class_Dissector,`Dissector`>>.
1154 | The <<lua_class_Dissector,`Dissector`>> form is useful when you need to decide whether to call a sub-dissector.
1155 | */
1156 | #define WSLUA_ARG_TreeItem_referenced_PROTOFIELD2 2 /* The <<lua_class_ProtoField,`ProtoField`>> or <<lua_class_Dissector,`Dissector`>> to check if referenced. */
1157 | TreeItem ti = checkTreeItem(L, 1);
1158 | if (!ti) return 0;
1159 | ProtoField f = shiftProtoField(L, WSLUA_ARG_TreeItem_referenced_PROTOFIELD2);
1160 | if (f) {
1161 | lua_pushboolean(L, proto_field_is_referenced(ti->tree, f->hfid));
1162 | }
1163 | else {
1164 | Dissector d = checkDissector(L, WSLUA_ARG_TreeItem_referenced_PROTOFIELD2);
1165 | if (!d) return 0;
1166 | lua_pushboolean(L, proto_field_is_referenced(ti->tree, dissector_handle_get_protocol_index(d)));
1167 | }
1168 | WSLUA_RETURN(1)return (1); /* A boolean indicating if the ProtoField/Dissector is referenced */
1169 | }
1170 |
1171 | WSLUA_METHODstatic int TreeItem_get_child_count(lua_State *L) {
1172 | /* Returns the number of direct child tree items.
1173 |
1174 | This method counts and returns the number of direct children of this tree item.
1175 | Only immediate children are counted; grandchildren and deeper descendants are not included.
1176 |
1177 | [source,lua]
1178 | ----
1179 | local tree = root:add(myproto, tvbuf())
1180 | tree:add("Child 1")
1181 | tree:add("Child 2")
1182 |
1183 | local count = tree:get_child_count()
1184 | -- count is now 2
1185 | ----
1186 |
1187 | @since 4.7.0
1188 | */
1189 |
1190 | /* Retrieve and validate the TreeItem from Lua stack position 1 */
1191 | TreeItem ti = checkTreeItem(L, 1);
1192 | if (!ti) {
1193 | return 0;
1194 | }
1195 |
1196 | int count = 0;
1197 | proto_tree *tree = ti->tree;
1198 |
1199 | if (tree) {
1200 | /* Get the first child node from the proto_tree structure */
1201 | proto_node *current = ((proto_node *)tree)->first_child;
1202 |
1203 | /* Iterate through the linked list of children using the 'next' pointer */
1204 | while (current) {
1205 | count++;
1206 | current = current->next; /* Move to next sibling */
1207 | }
1208 | }
1209 |
1210 | /* Push the count as an integer onto the Lua stack */
1211 | lua_pushinteger(L, count);
1212 | WSLUA_RETURN(1)return (1); /* The number of child tree items. */
1213 | }
1214 |
1215 | WSLUA_METHODstatic int TreeItem_get_parent(lua_State *L) {
1216 | /* Returns the parent tree item.
1217 |
1218 | Returns the parent tree item of this item, or nil if this is a root item
1219 | (i.e., a top-level tree item added directly to the protocol tree).
1220 |
1221 | [source,lua]
1222 | ----
1223 | local parent_tree = root:add(myproto, tvbuf())
1224 | local child_tree = parent_tree:add("Child")
1225 |
1226 | local parent = child_tree:get_parent()
1227 | -- parent is the same as parent_tree
1228 |
1229 | local root_parent = parent_tree:get_parent()
1230 | -- root_parent is nil (assuming parent_tree is a root item)
1231 | ----
1232 | @since 4.7.0
1233 | */
1234 |
1235 | /* Retrieve and validate the TreeItem from Lua stack */
1236 | TreeItem ti = checkTreeItem(L, 1);
1237 | if (!ti) {
1238 | return 0;
1239 | }
1240 |
1241 | proto_item *parent = NULL((void*)0);
1242 |
1243 | if (ti->item) {
1244 | /* Use Wireshark's built-in function to get the parent proto_item */
1245 | parent = proto_item_get_parent(ti->item);
1246 | }
1247 |
1248 | if (parent) {
1249 | /* Parent exists - get its subtree (may be NULL if parent has no children) */
1250 | proto_tree *parent_tree = proto_item_get_subtree(parent);
1251 |
1252 | /* Create a new Lua TreeItem object wrapping the parent and push it to Lua */
1253 | push_TreeItem(L, parent_tree, parent);
1254 | } else {
1255 | /* No parent exists - this is a root item, return nil */
1256 | lua_pushnil(L);
1257 | }
1258 |
1259 | WSLUA_RETURN(1)return (1); /* The parent TreeItem, or nil if this is a root item. */
1260 | }
1261 |
1262 | WSLUA_METHODstatic int TreeItem_get_child(lua_State *L) {
1263 | /* Returns the child tree item at the specified index.
1264 |
1265 | Returns the direct child TreeItem at the given index using 0-based indexing.
1266 | This provides random access to child items by their position.
1267 |
1268 | [source,lua]
1269 | ----
1270 | local tree = root:add(myproto, tvbuf())
1271 | tree:add("First child") -- index 0
1272 | tree:add("Second child") -- index 1
1273 | tree:add("Third child") -- index 2
1274 |
1275 | local first = tree:get_child(0) -- Returns first child
1276 | local second = tree:get_child(1) -- Returns second child
1277 | local invalid = tree:get_child(5) -- Returns nil (out of range)
1278 | ----
1279 | @since 4.7.0
1280 | */
1281 |
1282 | #define WSLUA_ARG_TreeItem_get_child_INDEX2 2 /* The index of the child (0-based). */
1283 | /* Retrieve and validate the TreeItem */
1284 | TreeItem ti = checkTreeItem(L, 1);
1285 | if (!ti)
1286 | return 0;
1287 |
1288 | /* Get the index parameter from Lua (must be an integer) */
1289 | lua_Integer index = luaL_checkinteger(L, WSLUA_ARG_TreeItem_get_child_INDEX2);
1290 |
1291 | /* Validate index - must be non-negative for 0-based indexing */
1292 | if (index < 0) {
1293 | WSLUA_ARG_ERROR(TreeItem_get_child, INDEX, "index must be non-negative"){ luaL_argerror(L,2, "TreeItem_get_child" ": " "index must be non-negative" ); };
1294 | }
1295 |
1296 | proto_node *current = NULL((void*)0);
1297 |
1298 | if (ti->tree) {
1299 | /* Get the first child in the linked list */
1300 | current = ((proto_node *)ti->tree)->first_child;
1301 | }
1302 |
1303 | /* Navigate to the index-th child by following the 'next' pointers */
1304 | lua_Integer current_index = 0;
1305 | while (current && current_index < index) {
1306 | current = current->next; /* Move to next sibling */
1307 | current_index++;
1308 | }
1309 |
1310 | if (current) {
1311 | /* Child found at the specified index */
1312 | /* Get the subtree (may be NULL if this node has no children) */
1313 | proto_tree *child_tree = proto_item_get_subtree((proto_item *)current);
1314 |
1315 | /* Create and push the TreeItem to Lua */
1316 | push_TreeItem(L, child_tree, (proto_item *)current);
1317 | } else {
1318 | /* Index out of range - no child exists at this position */
1319 | lua_pushnil(L);
1320 | }
1321 |
1322 | WSLUA_RETURN(1)return (1); /* The child TreeItem at the specified index, or nil if out of range. */
1323 | }
1324 |
1325 | /* Structure to hold iterator state with optional field name filters and recursion */
1326 | typedef struct
1327 | {
1328 | proto_node *current_node; /* Current node being processed in iteration */
1329 | char **field_filters; /* Array of field name strings to match (e.g., "tcp.port") */
1330 | int num_filters; /* Number of filter strings in the array */
1331 | bool_Bool recursive; /* If true, iterate through entire subtree depth-first */
1332 | proto_node **stack; /* Stack for recursive depth-first traversal */
1333 | int stack_size; /* Number of nodes currently on the stack */
1334 | int stack_capacity; /* Maximum capacity of stack (grows dynamically) */
1335 | } TreeItem_iterator_state;
1336 |
1337 | /* Helper function to push a node onto the stack for recursive iteration */
1338 | static void push_node_to_stack(TreeItem_iterator_state *state, proto_node *node) {
1339 | if (!node)
1340 | return;
1341 |
1342 | /* Dynamically expand stack capacity if needed */
1343 | if (state->stack_size >= state->stack_capacity) {
1344 | /* Double capacity plus initial buffer to reduce reallocation frequency */
1345 | state->stack_capacity = state->stack_capacity * 2 + 10;
1346 | state->stack = (proto_node **)g_realloc(state->stack,
1347 | state->stack_capacity * sizeof(proto_node *));
1348 | }
1349 |
1350 | /* Add node to top of stack and increment size */
1351 | state->stack[state->stack_size++] = node;
1352 | }
1353 |
1354 | /* Helper function to pop a node from the stack */
1355 | static proto_node *pop_node_from_stack(TreeItem_iterator_state *state) {
1356 | /* Check if stack is empty */
1357 | if (state->stack_size <= 0)
1358 | return NULL((void*)0);
1359 |
1360 | /* Return top element and decrement stack size */
1361 | return state->stack[--state->stack_size];
1362 | }
1363 |
1364 | /* Helper function for the children iterator with optional filtering and recursion */
1365 | static int TreeItem_children_iterator(lua_State *L) {
1366 | /* Retrieve the iterator state from the closure's upvalue */
1367 | TreeItem_iterator_state *state = (TreeItem_iterator_state *)lua_touserdata(L, lua_upvalueindex(1)((-1000000 - 1000) - (1)));
1368 |
1369 | /* Continue iterating while we have nodes to process */
1370 | /* Either from current sibling chain OR from recursive stack */
1371 | while (state->current_node || (state->recursive && state->stack_size > 0)) {
1372 | proto_node *node = NULL((void*)0);
1373 |
1374 | if (state->current_node) {
1375 | /* Process next node in current sibling chain */
1376 | node = state->current_node;
1377 | state->current_node = node->next; /* Advance to next sibling for next iteration */
1378 | } else if (state->recursive && state->stack_size > 0) {
1379 | /* No more siblings - pop from stack for recursive traversal */
1380 | node = pop_node_from_stack(state);
1381 | if (!node)
1382 | continue; /* Stack had invalid entry, skip */
1383 |
1384 | /* Set current_node to first child of popped node */
1385 | /* This allows iteration through all siblings before going deeper */
1386 | proto_tree *subtree = proto_item_get_subtree((proto_item *)node);
1387 | if (subtree) {
1388 | state->current_node = ((proto_node *)subtree)->first_child;
1389 | }
1390 | }
1391 |
1392 | if (!node)
1393 | continue; /* Safety check - should not happen */
1394 |
1395 | /* IMPORTANT: For recursive mode, always add children to stack regardless of filter match
1396 | * This ensures that even if the current node doesn't match the filter,
1397 | * its children are still searched recursively (depth-first traversal)
1398 | *
1399 | * Example: If we filter for "tcp.port" but current node is "tcp.flags",
1400 | * we still need to check if "tcp.flags" has "tcp.port" children
1401 | */
1402 | if (state->recursive) {
1403 | proto_tree *subtree = proto_item_get_subtree((proto_item *)node);
1404 | if (subtree) {
1405 | /* Collect all children first (needed for reverse-order pushing) */
1406 | proto_node *child = ((proto_node *)subtree)->first_child;
1407 | proto_node **children = NULL((void*)0);
1408 | int child_count = 0;
1409 |
1410 | /* Count and collect all children in forward order */
1411 | while (child) {
1412 | child_count++;
1413 | children = (proto_node **)g_realloc(children, child_count * sizeof(proto_node *));
1414 | children[child_count - 1] = child;
1415 | child = child->next;
1416 | }
1417 |
1418 | /* Push children in REVERSE order to stack */
1419 | /* This ensures depth-first left-to-right traversal */
1420 | /* (first child is on top of stack, gets popped first) */
1421 | for (int i = child_count - 1; i >= 0; i--) {
1422 | push_node_to_stack(state, children[i]);
1423 | }
1424 |
1425 | /* Free temporary children array */
1426 | if (children)
1427 | g_free(children);
1428 | }
1429 | }
1430 |
1431 | /* Check if this node matches the filter criteria */
1432 | bool_Bool matches = false0;
1433 | if (state->num_filters > 0) {
1434 | /* Filters are specified - check if node's field name matches any filter */
1435 | field_info *finfo = node->finfo;
1436 |
1437 | /* Ensure node has valid field_info with abbreviated name */
1438 | if (finfo && finfo->hfinfo && finfo->hfinfo->abbrev) {
1439 | /* Check against all filter strings (OR logic) */
1440 | for (int i = 0; i < state->num_filters; i++) {
1441 | if (strcmp(finfo->hfinfo->abbrev, state->field_filters[i]) == 0) {
1442 | matches = true1;
1443 | break; /* Found match, no need to check remaining filters */
1444 | }
1445 | }
1446 | }
1447 | /* If finfo is NULL or has no abbrev, matches remains false */
1448 | } else {
1449 | /* No filters specified - return all children/descendants */
1450 | matches = true1;
1451 | }
1452 |
1453 | /* Only return matching nodes to Lua, but continue processing regardless
1454 | * (children were already added to stack above for recursive mode) */
1455 | if (matches) {
1456 | /* Get the subtree for this matching node (may be NULL) */
1457 | proto_tree *child_tree = proto_item_get_subtree((proto_item *)node);
1458 |
1459 | /* Push matching TreeItem to Lua stack */
1460 | push_TreeItem(L, child_tree, (proto_item *)node);
1461 | return 1; /* Return 1 value to Lua iterator */
1462 | }
1463 |
1464 | /* If no match, continue to next node
1465 | * Children are already on stack for recursive mode,
1466 | * ensuring we don't miss matching descendants */
1467 | }
1468 |
1469 | /* No more nodes to process - iteration complete */
1470 | return 0; /* Return no values - signals end of iteration to Lua */
1471 | }
1472 |
1473 | /* Garbage collector for the iterator state */
1474 | static int TreeItem_iterator_state_gc(lua_State *L) {
1475 | /* Retrieve the iterator state userdata */
1476 | TreeItem_iterator_state *state = (TreeItem_iterator_state *)lua_touserdata(L, 1);
1477 |
1478 | /* Free the filter strings array */
1479 | if (state->field_filters) {
1480 | /* Free each individual filter string */
1481 | for (int i = 0; i < state->num_filters; i++) {
1482 | g_free(state->field_filters[i]);
1483 | }
1484 | /* Free the array itself */
1485 | g_free(state->field_filters);
1486 | }
1487 |
1488 | /* Free the recursion stack */
1489 | if (state->stack) {
1490 | g_free(state->stack);
1491 | }
1492 |
1493 | /* Note: The state struct itself is freed by Lua's GC */
1494 | return 0;
1495 | }
1496 |
1497 | WSLUA_METHODstatic int TreeItem_children(lua_State *L) {
1498 | /* Returns an iterator function to iterate over child tree items.
1499 |
1500 | Returns an iterator function that can be used in a Lua for loop to iterate
1501 | over children of this tree item. Supports optional filtering and recursive traversal.
1502 |
1503 | The basic usage iterates over direct children only:
1504 | [source,lua]
1505 | ----
1506 | for child in tree:children() do
1507 | print("Child: " .. tostring(child))
1508 | end
1509 | ----
1510 |
1511 | You can filter by field names to only get children with specific fields:
1512 | [source,lua]
1513 | ----
1514 | -- Single field filter
1515 | for child in tree:children("tcp.flags") do
1516 | print("TCP flags child: " .. tostring(child))
1517 | end
1518 |
1519 | -- Multiple field filters
1520 | for child in tree:children({"tcp.port", "tcp.srcport", "tcp.dstport"}) do
1521 | print("TCP port child: " .. tostring(child))
1522 | end
1523 | ----
1524 |
1525 | Enable recursive iteration to traverse the entire subtree in depth-first order:
1526 | [source,lua]
1527 | ----
1528 | -- Recursive iteration without filter
1529 | for child in tree:children(nil, true) do
1530 | print("Descendant: " .. tostring(child))
1531 | end
1532 |
1533 | -- Recursive iteration with field filter
1534 | for child in tree:children("tcp.flags", true) do
1535 | print("TCP flags anywhere in subtree: " .. tostring(child))
1536 | end
1537 | ----
1538 |
1539 | When using recursive mode with filters, the iterator searches through all descendants
1540 | even if parent nodes don't match the filter, ensuring no matching children are missed.
1541 |
1542 | IMPORTANT: Field extractors must still be created for the fields you want to iterate over.
1543 | Wireshark optimizes dissection by only creating tree items for fields that are explicitly
1544 | requested through field extractors, display filters, or taps. Without proper field extractors,
1545 | the fields may not exist in the dissection tree and will not be found by this iterator.
1546 |
1547 | Example of proper field extractor setup:
1548 | [source,lua]
1549 | ----
1550 | -- Define field extractors first
1551 | local tcp_flags_extractor = Field.new("tcp.flags")
1552 | local tcp_port_extractor = Field.new("tcp.port")
1553 |
1554 | -- Then use tree navigation (extractors ensure fields exist in tree)
1555 | for child in tree:children("tcp.flags") do
1556 | local field_info = child:get_field_info()
1557 | print("TCP Flags:", field_info.value)
1558 | end
1559 | ----
1560 | @since 4.7.0
1561 | */
1562 |
1563 | #define WSLUA_OPTARG_TreeItem_children_FIELD_FILTER2 2 /* Optional field name(s) to filter by (string or table of strings). */
1564 | #define WSLUA_OPTARG_TreeItem_children_RECURSIVE3 3 /* Optional boolean to enable recursive (depth-first) iteration. Default is false. */
1565 |
1566 | /* Retrieve and validate the TreeItem */
1567 | TreeItem ti = checkTreeItem(L, 1);
1568 | if (!ti)
1569 | return 0;
1570 |
1571 | if (lua_gettop(L) >= WSLUA_OPTARG_TreeItem_children_RECURSIVE3 &&
1572 | !lua_isnil(L, WSLUA_OPTARG_TreeItem_children_RECURSIVE)(lua_type(L, (3)) == 0) &&
1573 | !lua_isboolean(L, WSLUA_OPTARG_TreeItem_children_RECURSIVE)(lua_type(L, (3)) == 1)) {
1574 | luaL_error(L, "TreeItem:children() recursive argument must be a boolean");
1575 | return 0;
1576 | }
1577 |
1578 | if (lua_gettop(L) >= WSLUA_OPTARG_TreeItem_children_FIELD_FILTER2 &&
1579 | !lua_isnil(L, WSLUA_OPTARG_TreeItem_children_FIELD_FILTER)(lua_type(L, (2)) == 0)) {
1580 | int filter_arg = WSLUA_OPTARG_TreeItem_children_FIELD_FILTER2;
1581 |
1582 | if (lua_type(L, filter_arg) != LUA_TSTRING4 && !lua_istable(L, filter_arg)(lua_type(L, (filter_arg)) == 5)) {
1583 | luaL_error(L, "TreeItem:children() field filter must be a string or table of strings");
1584 | return 0;
1585 | }
1586 |
1587 | if (lua_istable(L, filter_arg)(lua_type(L, (filter_arg)) == 5)) {
1588 | int table_len = (int)lua_rawlen(L, filter_arg);
1589 | for (int i = 0; i < table_len; i++) {
1590 | lua_rawgeti(L, filter_arg, i + 1);
1591 | if (lua_type(L, -1) != LUA_TSTRING4) {
1592 | luaL_error(L, "TreeItem:children() field filter table entries must be strings");
1593 | return 0;
1594 | }
1595 | lua_pop(L, 1)lua_settop(L, -(1)-1);
1596 | }
1597 | }
1598 | }
1599 |
1600 | proto_node *first_child = NULL((void*)0);
1601 |
1602 | if (ti->tree) {
1603 | /* Get the first child from the tree's linked list */
1604 | first_child = ((proto_node *)ti->tree)->first_child;
1605 | }
1606 |
1607 | /* Create the iterator state userdata that will be used by the iterator closure */
1608 | /* This userdata will be garbage collected when the iterator is no longer referenced */
1609 | TreeItem_iterator_state *state = (TreeItem_iterator_state *)lua_newuserdata(L, sizeof(TreeItem_iterator_state))lua_newuserdatauv(L,sizeof(TreeItem_iterator_state),1);
1610 |
1611 | /* Initialize all state fields to safe defaults */
1612 | state->current_node = first_child; /* Start with first child */
1613 | state->field_filters = NULL((void*)0); /* No filters by default */
1614 | state->num_filters = 0;
1615 | state->recursive = false0; /* Non-recursive by default */
1616 | state->stack = NULL((void*)0); /* Stack only allocated if recursive */
1617 | state->stack_size = 0;
1618 | state->stack_capacity = 0;
1619 |
1620 | /* Set up garbage collection metatable for the state userdata */
1621 | /* This ensures proper cleanup when iterator is no longer referenced */
1622 | lua_newtable(L)lua_createtable(L, 0, 0); /* Create metatable */
1623 | lua_pushcfunction(L, TreeItem_iterator_state_gc)lua_pushcclosure(L, (TreeItem_iterator_state_gc), 0);
1624 | lua_setfield(L, -2, "__gc"); /* Set __gc metamethod */
1625 | lua_setmetatable(L, -2); /* Apply metatable to userdata */
1626 |
1627 | /* Check for recursive parameter (argument 3) */
1628 | if (lua_gettop(L) >= WSLUA_OPTARG_TreeItem_children_RECURSIVE3 &&
1629 | !lua_isnil(L, WSLUA_OPTARG_TreeItem_children_RECURSIVE)(lua_type(L, (3)) == 0)) {
1630 | /* Convert Lua boolean to C bool */
1631 | state->recursive = lua_toboolean(L, WSLUA_OPTARG_TreeItem_children_RECURSIVE3);
1632 | }
1633 |
1634 | /* Check if filter argument (argument 2) is provided */
1635 | if (lua_gettop(L) >= WSLUA_OPTARG_TreeItem_children_FIELD_FILTER2 &&
1636 | !lua_isnil(L, WSLUA_OPTARG_TreeItem_children_FIELD_FILTER)(lua_type(L, (2)) == 0)) {
1637 | int filter_arg = WSLUA_OPTARG_TreeItem_children_FIELD_FILTER2;
1638 |
1639 | if (lua_type(L, filter_arg) == LUA_TSTRING4) {
1640 | /* Single filter string - allocate array of size 1 */
1641 | state->num_filters = 1;
1642 | state->field_filters = (char **)g_malloc(sizeof(char *));
1643 | /* Duplicate the string (Lua string becomes C string copy) */
1644 | state->field_filters[0] = g_strdup(lua_tostring(L, filter_arg))g_strdup_inline (lua_tolstring(L, (filter_arg), ((void*)0)));
1645 | } else if (lua_istable(L, filter_arg)(lua_type(L, (filter_arg)) == 5)) {
1646 | /* Table of filter strings - extract all strings from table */
1647 | int table_len = (int)lua_rawlen(L, filter_arg);
1648 | state->num_filters = table_len;
1649 | state->field_filters = (char **)g_malloc(sizeof(char *) * table_len);
1650 |
1651 | /* Iterate through Lua table (1-based indexing) */
1652 | for (int i = 0; i < table_len; i++) {
1653 | lua_rawgeti(L, filter_arg, i + 1); /* Get table[i+1] */
1654 | /* Valid string entry - duplicate it */
1655 | state->field_filters[i] = g_strdup(lua_tostring(L, -1))g_strdup_inline (lua_tolstring(L, (-1), ((void*)0)));
1656 | lua_pop(L, 1)lua_settop(L, -(1)-1); /* Remove the value from stack */
1657 | }
1658 | }
1659 | /* If neither string nor table, filters remain NULL (no filtering) */
1660 | }
1661 |
1662 | /* Push the iterator function as a closure with state as upvalue */
1663 | /* The state userdata is kept alive as long as the closure exists */
1664 | lua_pushcclosure(L, TreeItem_children_iterator, 1);
1665 |
1666 | WSLUA_RETURN(1)return (1); /* An iterator function for use in Lua for loops. */
1667 | }
1668 |
1669 | WSLUA_METHODstatic int TreeItem_get_field_info(lua_State *L) {
1670 | /* Returns the FieldInfo object associated with this tree item.
1671 |
1672 | Returns a FieldInfo object that provides access to the underlying field
1673 | information including name, abbreviated name, type, value, data offset,
1674 | length, and other protocol field properties.
1675 |
1676 | This is particularly useful for extracting actual field values and
1677 | metadata from tree items during packet analysis.
1678 |
1679 | [source,lua]
1680 | ----
1681 | for child in tree:children() do
1682 | local field_info = child:get_field_info()
1683 | if field_info then
1684 | print("Field name: " .. field_info.name)
1685 | print("Field abbrev: " .. field_info.abbrev)
1686 | print("Field type: " .. field_info.type)
1687 | print("Field value: " .. tostring(field_info.value))
1688 | print("Field offset: " .. field_info.offset)
1689 | print("Field len: " .. field_info.len)
1690 | else
1691 | print("No field info (text-only or generated item)")
1692 | end
1693 | end
1694 | ----
1695 |
1696 | NOTE: Field extractors are still required to ensure fields exist in the dissection tree.
1697 | This method only provides access to field information for tree items that already exist.
1698 |
1699 | @since 4.7.0
1700 | */
1701 |
1702 | /* Retrieve and validate the TreeItem */
1703 | TreeItem ti = checkTreeItem(L, 1);
1704 | if (!ti)
1705 | return 0;
1706 |
1707 | field_info *finfo = NULL((void*)0);
1708 |
1709 | /* Get field_info from the proto_item */
1710 | if (ti->item) {
1711 | /* Cast proto_item to proto_node to access finfo member */
1712 | proto_node *node = (proto_node *)ti->item;
1713 | finfo = node->finfo; /* May be NULL for text-only tree items */
1714 | }
1715 |
1716 | if (finfo) {
1717 | /* Valid field_info exists - create and push FieldInfo Lua object */
1718 | /* This makes all field properties accessible from Lua */
1719 | push_FieldInfo(L, finfo);
1720 | } else {
1721 | /* No field_info - this is a text-only tree item or generated content */
1722 | lua_pushnil(L);
1723 | }
1724 |
1725 | WSLUA_RETURN(1)return (1); /* The FieldInfo object, or nil if not available. */
1726 | }
1727 |
1728 | WSLUA_METAMETHODstatic int TreeItem__tostring(lua_State* L) {
1729 | /* Returns a short label of the form `TreeItem: <abbrev>` for an
1730 | attached field, `TreeItem: (root)` for a text-only/root tree,
1731 | or `TreeItem: (no item)` / `TreeItem: (expired)` /
1732 | `TreeItem: (null)` for the degenerate cases. The previous
1733 | form dumped only boolean flags (expired/item/tree/same),
1734 | which were not very useful for identifying which TreeItem
1735 | the debugger is looking at. */
1736 | TreeItem ti = toTreeItem(L,1);
1737 |
1738 | if (!ti) {
1739 | lua_pushstring(L, "TreeItem: (null)");
1740 | } else if (ti->expired) {
1741 | lua_pushstring(L, "TreeItem: (expired)");
1742 | } else if (!ti->item) {
1743 | lua_pushstring(L, "TreeItem: (no item)");
1744 | } else {
1745 | proto_node *node = (proto_node *)ti->item;
1746 | field_info *finfo = node ? node->finfo : NULL((void*)0);
1747 | if (finfo && finfo->hfinfo && finfo->hfinfo->abbrev) {
1748 | lua_pushfstring(L, "TreeItem: %s", finfo->hfinfo->abbrev);
1749 | } else {
1750 | lua_pushstring(L, "TreeItem: (root)");
1751 | }
1752 | }
1753 |
1754 | return 1;
1755 | }
1756 |
1757 | /* Gets registered as metamethod automatically by WSLUA_REGISTER_CLASS/META */
1758 | static int TreeItem__gc(lua_State* L) {
1759 | TreeItem ti = toTreeItem(L,1);
1760 | if (!ti) return 0;
1761 | if (!ti->expired)
1762 | ti->expired = true1;
1763 | else
1764 | g_free(ti);
1765 | return 0;
1766 | }
1767 |
1768 | WSLUA_ATTRIBUTESstatic const wslua_attribute_table TreeItem_attributes[] = {
1769 | WSLUA_ATTRIBUTE_RWREG(TreeItem,generated){ "generated", TreeItem_get_generated, TreeItem_set_generated },
1770 | WSLUA_ATTRIBUTE_RWREG(TreeItem,hidden){ "hidden", TreeItem_get_hidden, TreeItem_set_hidden },
1771 | WSLUA_ATTRIBUTE_RWREG(TreeItem,len){ "len", TreeItem_get_len, TreeItem_set_len },
1772 | WSLUA_ATTRIBUTE_RWREG(TreeItem,text){ "text", TreeItem_get_text, TreeItem_set_text },
1773 | WSLUA_ATTRIBUTE_ROREG(TreeItem,visible){ "visible", TreeItem_get_visible, ((void*)0) },
1774 | { NULL((void*)0), NULL((void*)0), NULL((void*)0) }
1775 | };
1776 |
1777 | WSLUA_METHODSstatic const luaL_Reg TreeItem_methods[] = {
1778 | WSLUA_CLASS_FNREG(TreeItem, add_packet_field){ "add_packet_field", TreeItem_add_packet_field },
1779 | WSLUA_CLASS_FNREG(TreeItem, add){ "add", TreeItem_add },
1780 | WSLUA_CLASS_FNREG(TreeItem, add_le){ "add_le", TreeItem_add_le },
1781 | WSLUA_CLASS_FNREG(TreeItem, set_text){ "set_text", TreeItem_set_text },
1782 | WSLUA_CLASS_FNREG(TreeItem, append_text){ "append_text", TreeItem_append_text },
1783 | WSLUA_CLASS_FNREG(TreeItem, prepend_text){ "prepend_text", TreeItem_prepend_text },
1784 | WSLUA_CLASS_FNREG(TreeItem, add_expert_info){ "add_expert_info", TreeItem_add_expert_info },
1785 | WSLUA_CLASS_FNREG(TreeItem, add_proto_expert_info){ "add_proto_expert_info", TreeItem_add_proto_expert_info },
1786 | WSLUA_CLASS_FNREG(TreeItem, add_tvb_expert_info){ "add_tvb_expert_info", TreeItem_add_tvb_expert_info },
1787 | WSLUA_CLASS_FNREG(TreeItem, set_generated){ "set_generated", TreeItem_set_generated },
1788 | WSLUA_CLASS_FNREG(TreeItem, set_hidden){ "set_hidden", TreeItem_set_hidden },
1789 | WSLUA_CLASS_FNREG(TreeItem, set_len){ "set_len", TreeItem_set_len },
1790 | WSLUA_CLASS_FNREG(TreeItem, referenced){ "referenced", TreeItem_referenced },
1791 | WSLUA_CLASS_FNREG(TreeItem, get_child_count){ "get_child_count", TreeItem_get_child_count },
1792 | WSLUA_CLASS_FNREG(TreeItem, get_parent){ "get_parent", TreeItem_get_parent },
1793 | WSLUA_CLASS_FNREG(TreeItem, get_child){ "get_child", TreeItem_get_child },
1794 | WSLUA_CLASS_FNREG(TreeItem, children){ "children", TreeItem_children },
1795 | WSLUA_CLASS_FNREG(TreeItem, get_field_info){ "get_field_info", TreeItem_get_field_info },
1796 | {NULL((void*)0), NULL((void*)0)}};
1797 |
1798 | WSLUA_METAstatic const luaL_Reg TreeItem_meta[] = {
1799 | WSLUA_CLASS_MTREG(TreeItem,tostring){ "__" "tostring", TreeItem__tostring },
1800 | { NULL((void*)0), NULL((void*)0) }
1801 | };
1802 |
1803 | int TreeItem_register(lua_State *L) {
1804 | int* etts[] = { &wslua_ett };
1805 | wslua_ett = -1; /* Reset to support reload Lua plugins */
1806 | 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); };
1807 | if (outstanding_TreeItem != NULL((void*)0)) {
1808 | g_ptr_array_unref(outstanding_TreeItem);
1809 | }
1810 | outstanding_TreeItem = g_ptr_array_new();
1811 | proto_register_subtree_array(etts,1);
1812 | return 0;
1813 | }
1814 |
1815 | /*
1816 | * Editor modelines - https://www.wireshark.org/tools/modelines.html
1817 | *
1818 | * Local variables:
1819 | * c-basic-offset: 4
1820 | * tab-width: 8
1821 | * indent-tabs-mode: nil
1822 | * End:
1823 | *
1824 | * vi: set shiftwidth=4 tabstop=8 expandtab:
1825 | * :indentSize=4:tabSize=8:noTabs=true:
1826 | */