### Bug Summary

File: | 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

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-01-10-100353-3604-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 | 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 |
672 | WSLUA_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 |
745 | WSLUA_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 | */
772 | static 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 */
799 | WSLUA_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 |
816 | WSLUA_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 |
833 | WSLUA_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 |
850 | WSLUA_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 |
904 | WSLUA_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 |
932 | WSLUA_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). */
982 | static 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). */
997 | static 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. */
1007 | WSLUA_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). */
1031 | static 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. */
1041 | WSLUA_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. */
1066 | static 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 |
1078 | WSLUA_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 |
1100 | WSLUA_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 |
1129 | WSLUA_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 */
1149 | static 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 |
1159 | WSLUA_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 |
1168 | WSLUA_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 |
1185 | WSLUA_METAstatic const luaL_Reg TreeItem_meta[] = {
1186 | WSLUA_CLASS_MTREG(TreeItem,tostring){ "__" "tostring", TreeItem__tostring },
1187 | { NULL((void*)0), NULL((void*)0) }
1188 | };
1189 |
1190 | int 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 | */