Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

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