/* * wslua_proto_field.c * * Wireshark's interface to the Lua Programming Language * * (c) 2006, Luis E. Garcia Ontanon * (c) 2008, Balint Reczey * (c) 2011, Stig Bjorlykke * (c) 2014, Hadriel Kaplan * * Wireshark - Network traffic analyzer * By Gerald Combs * Copyright 1998 Gerald Combs * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #include "config.h" #include "wslua.h" /* WSLUA_CONTINUE_MODULE Proto */ WSLUA_CLASS_DEFINE(ProtoField,FAIL_ON_NULL("null ProtoField")); /* A Protocol field (to be used when adding items to the dissection tree). */ static const wslua_ft_types_t ftenums[] = { {"ftypes.NONE", FT_NONE}, {"ftypes.BOOLEAN", FT_BOOLEAN}, {"ftypes.UINT8", FT_UINT8}, {"ftypes.UINT16", FT_UINT16}, {"ftypes.UINT24", FT_UINT24}, {"ftypes.UINT32", FT_UINT32}, {"ftypes.UINT64", FT_UINT64}, {"ftypes.INT8", FT_INT8}, {"ftypes.INT16", FT_INT16}, {"ftypes.INT24", FT_INT24}, {"ftypes.INT32", FT_INT32}, {"ftypes.INT64", FT_INT64}, {"ftypes.FLOAT", FT_FLOAT}, {"ftypes.DOUBLE", FT_DOUBLE}, {"ftypes.ABSOLUTE_TIME", FT_ABSOLUTE_TIME}, {"ftypes.RELATIVE_TIME", FT_RELATIVE_TIME}, {"ftypes.STRING", FT_STRING}, {"ftypes.STRINGZ", FT_STRINGZ}, {"ftypes.ETHER", FT_ETHER}, {"ftypes.BYTES", FT_BYTES}, {"ftypes.UINT_BYTES", FT_UINT_BYTES}, {"ftypes.IPv4", FT_IPv4}, {"ftypes.IPv6", FT_IPv6}, {"ftypes.IPXNET", FT_IPXNET}, {"ftypes.FRAMENUM", FT_FRAMENUM}, {"ftypes.GUID", FT_GUID}, {"ftypes.OID", FT_OID}, {"ftypes.SYSTEM_ID", FT_SYSTEM_ID}, {"ftypes.REL_OID", FT_REL_OID}, {"ftypes.EUI64", FT_EUI64}, {"ftypes.FCWWN", FT_FCWWN}, {NULL, FT_NONE} }; static enum ftenum get_ftenum(const gchar* type) { const wslua_ft_types_t* ts; for (ts = ftenums; ts->str; ts++) { if ( g_str_equal(ts->str,type) ) { return ts->id; } } return FT_NONE; } static const gchar* ftenum_to_string(enum ftenum ft) { const wslua_ft_types_t* ts; for (ts = ftenums; ts->str; ts++) { if ( ts->id == ft ) { return ts->str; } } return NULL; } struct field_display_string_t { const gchar* str; unsigned base; }; /* * This table is primarily used to convert from string representation * to int representation in string_to_base(). * Some string values are added for backward compatibility. */ static const struct field_display_string_t base_displays[] = { {"base.NONE", BASE_NONE}, {"base.DEC", BASE_DEC}, {"base.HEX", BASE_HEX}, {"base.OCT", BASE_OCT}, {"base.DEC_HEX", BASE_DEC_HEX}, {"base.HEX_DEC", BASE_HEX_DEC}, {"base.UNIT_STRING", BASE_UNIT_STRING}, /* String types */ {"base.ASCII", STR_ASCII}, {"base.UNICODE", STR_UNICODE}, /* Byte separators */ {"base.DOT", SEP_DOT}, {"base.DASH", SEP_DASH}, {"base.COLON", SEP_COLON}, {"base.SPACE", SEP_SPACE}, /* for FT_BOOLEAN, how wide the parent bitfield is */ {"8",8}, {"16",16}, {"24",24}, {"32",32}, /* for FT_ABSOLUTE_TIME use values in absolute_time_display_e */ {"base.LOCAL", ABSOLUTE_TIME_LOCAL}, {"base.UTC", ABSOLUTE_TIME_UTC}, {"base.DOY_UTC", ABSOLUTE_TIME_DOY_UTC}, {"LOCAL", ABSOLUTE_TIME_LOCAL}, /* for backward compatibility */ {"UTC", ABSOLUTE_TIME_UTC}, /* for backward compatibility */ {"DOY_UTC", ABSOLUTE_TIME_DOY_UTC}, /* for backward compatibility */ {NULL,0} }; static const gchar* base_to_string(unsigned base) { const struct field_display_string_t* b; for (b=base_displays;b->str;b++) { if ( base == b->base) return b->str; } return NULL; } static unsigned string_to_base(const gchar* str) { const struct field_display_string_t* b; for (b=base_displays;b->str;b++) { if ( g_str_equal(str,b->str)) return b->base; } return BASE_NONE; } static value_string* value_string_from_table(lua_State* L, int idx) { GArray* vs; value_string* vs32; if (lua_isnil(L,idx)) { return NULL; } else if (!lua_istable(L,idx)) { luaL_argerror(L,idx,"must be a table"); return NULL; } vs = g_array_new(TRUE,TRUE,sizeof(value_string)); lua_pushnil(L); while (lua_next(L, idx) != 0) { value_string v = {0,NULL}; if (! lua_isnumber(L,-2)) { vs32 = (value_string *)(void *)vs->data; while (vs32->strptr) { g_free((gchar *)vs32->strptr); vs32++; } g_array_free(vs,TRUE); luaL_argerror(L,idx,"All keys of a table used as value_string must be integers"); return NULL; } if (! lua_isstring(L,-1)) { vs32 = (value_string *)(void *)vs->data; while (vs32->strptr) { g_free((gchar *)vs32->strptr); vs32++; } g_array_free(vs,TRUE); luaL_argerror(L,idx,"All values of a table used as value_string must be strings"); return NULL; } v.value = wslua_toguint32(L,-2); v.strptr = g_strdup(lua_tostring(L,-1)); g_array_append_val(vs,v); lua_pop(L, 1); } vs32 = (value_string*)(void*)vs->data; g_array_free(vs,FALSE); return vs32; } static val64_string* val64_string_from_table(lua_State* L, int idx) { GArray* vs; val64_string* vs64; if (lua_isnil(L,idx)) { return NULL; } else if (!lua_istable(L,idx)) { luaL_argerror(L,idx,"must be a table"); return NULL; } vs = g_array_new(TRUE,TRUE,sizeof(val64_string)); lua_pushnil(L); while (lua_next(L, idx) != 0) { val64_string v = {0,NULL}; if (! lua_isnumber(L,-2)) { vs64 = (val64_string *)(void *)vs->data; while (vs64->strptr) { g_free((gchar *)vs64->strptr); vs64++; } g_array_free(vs,TRUE); luaL_argerror(L,idx,"All keys of a table used as value string must be integers"); return NULL; } if (! lua_isstring(L,-1)) { vs64 = (val64_string *)(void *)vs->data; while (vs64->strptr) { g_free((gchar *)vs64->strptr); vs64++; } g_array_free(vs,TRUE); luaL_argerror(L,idx,"All values of a table used as value string must be strings"); return NULL; } v.value = wslua_toguint64(L, -2); v.strptr = g_strdup(lua_tostring(L,-1)); g_array_append_val(vs,v); lua_pop(L, 1); } vs64 = (val64_string*)(void*)vs->data; g_array_free(vs,FALSE); return vs64; } static true_false_string* true_false_string_from_table(lua_State* L, int idx) { true_false_string* tfs; if (lua_isnil(L,idx)) { return NULL; } else if (!lua_istable(L,idx)) { luaL_argerror(L,idx,"must be a table"); return NULL; } tfs = (true_false_string *) g_malloc(sizeof(true_false_string)); tfs->true_string = g_strdup("True"); tfs->false_string = g_strdup("False"); lua_pushnil(L); while (lua_next(L, idx)) { if (! lua_isnumber(L,-2)) { g_free ((gchar *)tfs->true_string); g_free ((gchar *)tfs->false_string); g_free (tfs); luaL_argerror(L,idx,"All keys of a table used as true_false_string must be integers"); return NULL; } if (! lua_isstring(L,-1)) { g_free ((gchar *)tfs->true_string); g_free ((gchar *)tfs->false_string); g_free (tfs); luaL_argerror(L,idx,"All values of a table used as true_false_string must be strings"); return NULL; } /* Arrays in LUA start with index number 1 */ switch (lua_tointeger(L,-2)) { case 1: g_free((gchar *)tfs->true_string); tfs->true_string = g_strdup(lua_tostring(L,-1)); break; case 2: g_free((gchar *)tfs->false_string); tfs->false_string = g_strdup(lua_tostring(L,-1)); break; default: g_free ((gchar *)tfs->true_string); g_free ((gchar *)tfs->false_string); g_free (tfs); luaL_argerror(L,idx,"The true_false_string table can have maximum two strings with key value 1 and 2"); return NULL; } lua_pop(L, 1); } return tfs; } static unit_name_string* unit_name_string_from_table(lua_State* L, int idx) { unit_name_string* units; if (lua_isnil(L,idx)) { return NULL; } else if (!lua_istable(L,idx)) { luaL_argerror(L,idx,"must be a table"); return NULL; } units = (unit_name_string *) g_malloc0(sizeof(unit_name_string)); lua_pushnil(L); while (lua_next(L, idx)) { if (! lua_isnumber(L,-2)) { g_free(units->singular); g_free(units->plural); g_free(units); luaL_argerror(L,idx,"All keys of a table used as unit name must be integers"); return NULL; } if (! lua_isstring(L,-1)) { g_free(units->singular); g_free(units->plural); g_free(units); luaL_argerror(L,idx,"All values of a table used as unit name must be strings"); return NULL; } /* Arrays in LUA start with index number 1 */ switch (lua_tointeger(L,-2)) { case 1: g_free((gchar *)units->singular); units->singular = g_strdup(lua_tostring(L,-1)); break; case 2: g_free((gchar *)units->plural); units->plural = g_strdup(lua_tostring(L,-1)); break; default: g_free(units->singular); g_free(units->plural); g_free(units); luaL_argerror(L,idx,"The unit name table can have maximum two strings with key value 1 and 2"); return NULL; } lua_pop(L, 1); } if (!units->singular) { g_free(units->plural); g_free(units); luaL_argerror(L,idx,"The unit name table must have a singular entry (key value 1)"); return NULL; } return units; } static const gchar* check_field_name(lua_State* L, const int abbr_idx, const enum ftenum type) { const gchar* abbr = luaL_checkstring(L,abbr_idx); const header_field_info* hfinfo = NULL; if (!abbr[0]) { luaL_argerror(L, abbr_idx, "Empty field name abbreviation"); return NULL; } if (proto_check_field_name(abbr)) { luaL_argerror(L, abbr_idx, "Invalid char in abbrev"); return NULL; } hfinfo = proto_registrar_get_byname(abbr); if (hfinfo && !ftype_similar_types(type, hfinfo->type)) { luaL_argerror(L, abbr_idx, "A field of an incompatible ftype with this abbrev already exists"); return NULL; } return abbr; } WSLUA_CONSTRUCTOR ProtoField_new(lua_State* L) { /* Creates a new `ProtoField` object to be used for a protocol field. */ #define WSLUA_ARG_ProtoField_new_NAME 1 /* Actual name of the field (the string that appears in the tree). */ #define WSLUA_ARG_ProtoField_new_ABBR 2 /* Filter name of the field (the string that is used in filters). */ #define WSLUA_ARG_ProtoField_new_TYPE 3 /* Field Type: one of: `ftypes.BOOLEAN`, `ftypes.UINT8`, `ftypes.UINT16`, `ftypes.UINT24`, `ftypes.UINT32`, `ftypes.UINT64`, `ftypes.INT8`, `ftypes.INT16`, `ftypes.INT24`, `ftypes.INT32`, `ftypes.INT64`, `ftypes.FLOAT`, `ftypes.DOUBLE` , `ftypes.ABSOLUTE_TIME`, `ftypes.RELATIVE_TIME`, `ftypes.STRING`, `ftypes.STRINGZ`, `ftypes.UINT_STRING`, `ftypes.ETHER`, `ftypes.BYTES`, `ftypes.UINT_BYTES`, `ftypes.IPv4`, `ftypes.IPv6`, `ftypes.IPXNET`, `ftypes.FRAMENUM`, `ftypes.PCRE`, `ftypes.GUID`, `ftypes.OID`, `ftypes.PROTOCOL`, `ftypes.REL_OID`, `ftypes.SYSTEM_ID`, `ftypes.EUI64` or `ftypes.NONE`. */ #define WSLUA_OPTARG_ProtoField_new_VALUESTRING 4 /* A table containing the text that corresponds to the values, or a table containing unit name for the values if base is `base.UNIT_STRING`, or one of `frametype.NONE`, `frametype.REQUEST`, `frametype.RESPONSE`, `frametype.ACK` or `frametype.DUP_ACK` if field type is ftypes.FRAMENUM. */ #define WSLUA_OPTARG_ProtoField_new_BASE 5 /* The representation, one of: `base.NONE`, `base.DEC`, `base.HEX`, `base.OCT`, `base.DEC_HEX`, `base.HEX_DEC` or `base.UNIT_STRING`. */ #define WSLUA_OPTARG_ProtoField_new_MASK 6 /* The bitmask to be used. */ #define WSLUA_OPTARG_ProtoField_new_DESCR 7 /* The description of the field. */ ProtoField f; int nargs = lua_gettop(L); const gchar* name = luaL_checkstring(L,WSLUA_ARG_ProtoField_new_NAME); const gchar* abbr = NULL; enum ftenum type; enum ft_framenum_type framenum_type = FT_FRAMENUM_NONE; value_string *vs32 = NULL; val64_string *vs64 = NULL; true_false_string *tfs = NULL; unit_name_string *uns = NULL; unsigned base; guint32 mask = wslua_optguint32(L, WSLUA_OPTARG_ProtoField_new_MASK, 0x0); const gchar *blob = luaL_optstring(L,WSLUA_OPTARG_ProtoField_new_DESCR,NULL); gboolean unit_string = FALSE; if (!name[0]) { WSLUA_ARG_ERROR(ProtoField_new,NAME,"cannot be an empty string"); return 0; } if (lua_isnumber(L,WSLUA_ARG_ProtoField_new_TYPE)) { type = (enum ftenum)luaL_checkinteger(L,WSLUA_ARG_ProtoField_new_TYPE); } else { type = get_ftenum(luaL_checkstring(L,WSLUA_ARG_ProtoField_new_TYPE)); } abbr = check_field_name(L,WSLUA_ARG_ProtoField_new_ABBR,type); if (lua_isnumber(L, WSLUA_OPTARG_ProtoField_new_BASE)) { base = (unsigned)luaL_optinteger(L, WSLUA_OPTARG_ProtoField_new_BASE, BASE_NONE); } else { base = string_to_base(luaL_optstring(L, WSLUA_OPTARG_ProtoField_new_BASE, "BASE_NONE")); } switch (type) { case FT_FRAMENUM: if (base != BASE_NONE) { WSLUA_OPTARG_ERROR(ProtoField_new,BASE,"FRAMENUM must use base.NONE"); return 0; } if (mask) { WSLUA_OPTARG_ERROR(ProtoField_new,MASK,"FRAMENUM can not have a bitmask"); return 0; } if (nargs >= WSLUA_OPTARG_ProtoField_new_VALUESTRING && !lua_isnil(L,WSLUA_OPTARG_ProtoField_new_VALUESTRING)) { framenum_type = (enum ft_framenum_type) luaL_checkinteger(L, 4); if (framenum_type >= FT_FRAMENUM_NUM_TYPES) { WSLUA_OPTARG_ERROR(ProtoField_new,VALUESTRING,"Invalid frametype"); return 0; } } break; case FT_CHAR: case FT_UINT8: case FT_UINT16: case FT_UINT24: case FT_UINT32: case FT_UINT64: case FT_INT8: case FT_INT16: case FT_INT24: case FT_INT32: case FT_INT64: if (type != FT_CHAR && base & BASE_UNIT_STRING) { unit_string = TRUE; base &= ~BASE_UNIT_STRING; } if (base == BASE_NONE) { if (type == FT_CHAR) base = BASE_OCT; /* default base for characters (BASE_HEX instead?) */ else base = BASE_DEC; /* Default base for integer */ } if ((base != BASE_DEC) && (type == FT_INT8 || type == FT_INT16 || type == FT_INT24 || type == FT_INT32 || type == FT_INT64)) { WSLUA_OPTARG_ERROR(ProtoField_new,BASE,"Base must be either base.DEC or base.UNIT_STRING"); return 0; } else if (base < BASE_DEC || base > BASE_HEX_DEC) { WSLUA_OPTARG_ERROR(ProtoField_new,BASE,"Base must be either base.DEC, base.HEX, base.OCT," " base.DEC_HEX, base.HEX_DEC or base.UNIT_STRING"); return 0; } if (nargs >= WSLUA_OPTARG_ProtoField_new_VALUESTRING) { if (unit_string) { uns = unit_name_string_from_table(L,WSLUA_OPTARG_ProtoField_new_VALUESTRING); } else if (type == FT_UINT64 || type == FT_INT64) { vs64 = val64_string_from_table(L,WSLUA_OPTARG_ProtoField_new_VALUESTRING); } else { vs32 = value_string_from_table(L,WSLUA_OPTARG_ProtoField_new_VALUESTRING); } } break; case FT_BOOLEAN: if (mask == 0x0 && base != BASE_NONE) { WSLUA_OPTARG_ERROR(ProtoField_new,BASE,"Base must be base.NONE if bitmask is zero."); return 0; } if (mask != 0x0 && (base < 1 || base > 64)) { WSLUA_OPTARG_ERROR(ProtoField_new,BASE,"Base must be between 1 and 64 if bitmask is non-zero."); return 0; } if (nargs >= WSLUA_OPTARG_ProtoField_new_VALUESTRING && !lua_isnil(L,WSLUA_OPTARG_ProtoField_new_VALUESTRING)) { tfs = true_false_string_from_table(L,WSLUA_OPTARG_ProtoField_new_VALUESTRING); } break; case FT_ABSOLUTE_TIME: if (base == BASE_NONE) { base = ABSOLUTE_TIME_LOCAL; /* Default base for FT_ABSOLUTE_TIME */ } else if (base < ABSOLUTE_TIME_LOCAL || base > ABSOLUTE_TIME_DOY_UTC) { WSLUA_OPTARG_ERROR(ProtoField_new,BASE,"Base must be either base.LOCAL, base.UTC, or base.DOY_UTC"); return 0; } if (mask) { WSLUA_OPTARG_ERROR(ProtoField_new,MASK,"ABSOLUTE_TIME can not have a bitmask"); return 0; } break; case FT_STRING: case FT_STRINGZ: if (base != STR_ASCII && base != STR_UNICODE) { WSLUA_OPTARG_ERROR(ProtoField_new,BASE,"Display must be either base.ASCII or base.UNICODE"); return 0; } if (mask) { WSLUA_OPTARG_ERROR(ProtoField_new,MASK,"This type can not have a bitmask"); return 0; } break; case FT_BYTES: case FT_UINT_BYTES: if (base != BASE_NONE && (base < SEP_DOT || base > SEP_SPACE)) { WSLUA_OPTARG_ERROR(ProtoField_new,BASE,"Display must be either base.NONE, base.DOT, base.DASH, base.COLON or base.SPACE"); return 0; } if (mask) { WSLUA_OPTARG_ERROR(ProtoField_new,MASK,"This type can not have a bitmask"); return 0; } break; case FT_FLOAT: case FT_DOUBLE: if (base & BASE_UNIT_STRING) { unit_string = TRUE; base &= ~BASE_UNIT_STRING; } if (nargs >= WSLUA_OPTARG_ProtoField_new_VALUESTRING) { uns = unit_name_string_from_table(L,WSLUA_OPTARG_ProtoField_new_VALUESTRING); } /* FALLTHRU */ case FT_NONE: case FT_IPv4: case FT_IPv6: case FT_IPXNET: case FT_ETHER: case FT_RELATIVE_TIME: case FT_GUID: case FT_OID: case FT_PROTOCOL: case FT_SYSTEM_ID: case FT_REL_OID: case FT_EUI64: case FT_VINES: case FT_FCWWN: if (base != BASE_NONE) { WSLUA_OPTARG_ERROR(ProtoField_new,BASE,"Base must be base.NONE"); return 0; } if (mask) { WSLUA_OPTARG_ERROR(ProtoField_new,MASK,"This type can not have a bitmask"); return 0; } break; /* TODO: not handled yet */ case FT_UINT40: case FT_UINT48: case FT_UINT56: case FT_INT40: case FT_INT48: case FT_INT56: case FT_IEEE_11073_SFLOAT: case FT_IEEE_11073_FLOAT: case FT_UINT_STRING: case FT_AX25: case FT_STRINGZPAD: WSLUA_ARG_ERROR(ProtoField_new,TYPE,"Unsupported ProtoField field type"); break; /* FT_PCRE isn't a valid field type. */ case FT_PCRE: default: WSLUA_ARG_ERROR(ProtoField_new,TYPE,"Invalid ProtoField field type"); break; } if (unit_string && !uns) { WSLUA_OPTARG_ERROR(ProtoField_new,VALUESTRING, "Base is base.UNIT_STRING but no table is given"); return 0; } f = g_new(wslua_field_t,1); f->hfid = -2; f->ett = -1; f->name = g_strdup(name); f->abbrev = g_strdup(abbr); f->type = type; f->base = base; if (tfs) { f->vs = TFS(tfs); } else if (vs32) { f->vs = VALS(vs32); } else if (vs64) { /* Indicate that we are using val64_string */ f->base |= BASE_VAL64_STRING; f->vs = VALS(vs64); } else if (uns) { f->base |= BASE_UNIT_STRING; f->vs = uns; } else if (framenum_type) { f->vs = FRAMENUM_TYPE(framenum_type); } else { f->vs = NULL; } f->mask = mask; if (blob && strcmp(blob, f->name) != 0) { f->blob = g_strdup(blob); } else { f->blob = NULL; } pushProtoField(L,f); WSLUA_RETURN(1); /* The newly created `ProtoField` object. */ } static int ProtoField_integer(lua_State* L, enum ftenum type) { ProtoField f; const gchar* abbr = check_field_name(L,1,type); const gchar* name = luaL_optstring(L,2,abbr); unsigned default_base = (type == FT_FRAMENUM) ? BASE_NONE : BASE_DEC; unsigned base = (unsigned)luaL_optinteger(L, 3, default_base); enum ft_framenum_type framenum_type = FT_FRAMENUM_NONE; value_string* vs32 = NULL; val64_string* vs64 = NULL; unit_name_string* uns = NULL; guint32 mask = wslua_optguint32(L,5,0); const gchar* blob = luaL_optstring(L,6,NULL); gboolean unit_string = FALSE; if (!name[0]) { luaL_argerror(L, 2, "cannot be an empty string"); return 0; } if (base & BASE_UNIT_STRING) { unit_string = TRUE; base &= ~BASE_UNIT_STRING; if (base == BASE_NONE) { base = BASE_DEC; } } if (lua_gettop(L) > 3 && !lua_isnil(L, 4)) { if (type == FT_FRAMENUM) { framenum_type = (enum ft_framenum_type) luaL_checkinteger(L, 4); if (framenum_type >= FT_FRAMENUM_NUM_TYPES) { luaL_argerror(L, 4, "Invalid frametype"); return 0; } } else if (unit_string) { uns = unit_name_string_from_table(L,4); } else if (type == FT_UINT64 || type == FT_INT64) { vs64 = val64_string_from_table(L,4); } else { vs32 = value_string_from_table(L,4); } } if (type == FT_FRAMENUM) { if (base != BASE_NONE) luaL_argerror(L, 3, "FRAMENUM must use base.NONE"); else if (mask) luaL_argerror(L, 5, "FRAMENUM can not have a bitmask"); } else if ((base != BASE_DEC) && (type == FT_INT8 || type == FT_INT16 || type == FT_INT24 || type == FT_INT32 || type == FT_INT64)) { luaL_argerror(L, 3, "Base must be either base.DEC or base.UNIT_STRING"); return 0; } else if (base < BASE_DEC || base > BASE_HEX_DEC) { luaL_argerror(L, 3, "Base must be either base.DEC, base.HEX, base.OCT," " base.DEC_HEX, base.HEX_DEC or base.UNIT_STRING"); return 0; } if (unit_string && !uns) { luaL_argerror(L, 4, "Base is base.UNIT_STRING but no table is given"); return 0; } f = g_new(wslua_field_t,1); f->hfid = -2; f->ett = -1; f->name = g_strdup(name); f->abbrev = g_strdup(abbr); f->type = type; f->base = base; if (vs64) { /* Indicate that we are using val64_string */ f->base |= BASE_VAL64_STRING; f->vs = VALS(vs64); } else if (vs32) { f->vs = VALS(vs32); } else if (uns) { f->base |= BASE_UNIT_STRING; f->vs = uns; } else if (framenum_type) { f->vs = FRAMENUM_TYPE(framenum_type); } else { f->vs = NULL; } f->mask = mask; if (blob && strcmp(blob, f->name) != 0) { f->blob = g_strdup(blob); } else { f->blob = NULL; } pushProtoField(L,f); return 1; } #define PROTOFIELD_INTEGER(lower,FT) static int ProtoField_##lower(lua_State* L) { return ProtoField_integer(L,FT); } /* _WSLUA_CONSTRUCTOR_ ProtoField_uint8 Creates a `ProtoField` of an unsigned 8-bit integer (i.e., a byte). */ /* WSLUA_ARG_Protofield_uint8_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_uint8_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_uint8_BASE One of `base.DEC`, `base.HEX` or `base.OCT`, `base.DEC_HEX`, `base.HEX_DEC` or `base.UNIT_STRING`. */ /* WSLUA_OPTARG_Protofield_uint8_VALUESTRING A table containing the text that corresponds to the values, or a table containing unit name for the values if base is `base.UNIT_STRING`. */ /* WSLUA_OPTARG_Protofield_uint8_MASK Integer mask of this field. */ /* WSLUA_OPTARG_Protofield_uint8_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_uint16 Creates a `ProtoField` of an unsigned 16-bit integer. */ /* WSLUA_ARG_Protofield_uint16_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_uint16_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_uint16_BASE One of `base.DEC`, `base.HEX`, `base.OCT`, `base.DEC_HEX`, `base.HEX_DEC` or `base.UNIT_STRING`. */ /* WSLUA_OPTARG_Protofield_uint16_VALUESTRING A table containing the text that corresponds to the values, or a table containing unit name for the values if base is `base.UNIT_STRING`. */ /* WSLUA_OPTARG_Protofield_uint16_MASK Integer mask of this field. */ /* WSLUA_OPTARG_Protofield_uint16_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_uint24 Creates a `ProtoField` of an unsigned 24-bit integer. */ /* WSLUA_ARG_Protofield_uint24_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_uint24_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_uint24_BASE One of `base.DEC`, `base.HEX`, `base.OCT`, `base.DEC_HEX`, `base.HEX_DEC` or `base.UNIT_STRING`. */ /* WSLUA_OPTARG_Protofield_uint24_VALUESTRING A table containing the text that corresponds to the values, or a table containing unit name for the values if base is `base.UNIT_STRING`. */ /* WSLUA_OPTARG_Protofield_uint24_MASK Integer mask of this field. */ /* WSLUA_OPTARG_Protofield_uint24_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_uint32 Creates a `ProtoField` of an unsigned 32-bit integer. */ /* WSLUA_ARG_Protofield_uint32_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_uint32_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_uint32_BASE One of `base.DEC`, `base.HEX`, `base.OCT`, `base.DEC_HEX`, `base.HEX_DEC` or `base.UNIT_STRING`. */ /* WSLUA_OPTARG_Protofield_uint32_VALUESTRING A table containing the text that corresponds to the values, or a table containing unit name for the values if base is `base.UNIT_STRING`. */ /* WSLUA_OPTARG_Protofield_uint32_MASK Integer mask of this field. */ /* WSLUA_OPTARG_Protofield_uint32_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_uint64 Creates a `ProtoField` of an unsigned 64-bit integer. */ /* WSLUA_ARG_Protofield_uint64_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_uint64_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_uint64_BASE One of `base.DEC`, `base.HEX`, `base.OCT`, `base.DEC_HEX`, `base.HEX_DEC` or `base.UNIT_STRING`. */ /* WSLUA_OPTARG_Protofield_uint64_VALUESTRING A table containing the text that corresponds to the values, or a table containing unit name for the values if base is `base.UNIT_STRING`. */ /* WSLUA_OPTARG_Protofield_uint64_MASK Integer mask of this field. */ /* WSLUA_OPTARG_Protofield_uint64_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_int8 Creates a `ProtoField` of a signed 8-bit integer (i.e., a byte). */ /* WSLUA_ARG_Protofield_int8_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_int8_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_int8_BASE One of `base.DEC` or `base.UNIT_STRING`. */ /* WSLUA_OPTARG_Protofield_int8_VALUESTRING A table containing the text that corresponds to the values, or a table containing unit name for the values if base is `base.UNIT_STRING`. */ /* WSLUA_OPTARG_Protofield_int8_MASK Integer mask of this field. */ /* WSLUA_OPTARG_Protofield_int8_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_int16 Creates a `ProtoField` of a signed 16-bit integer. */ /* WSLUA_ARG_Protofield_int16_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_int16_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_int16_BASE One of `base.DEC` or `base.UNIT_STRING`. */ /* WSLUA_OPTARG_Protofield_int16_VALUESTRING A table containing the text that corresponds to the values, or a table containing unit name for the values if base is `base.UNIT_STRING`. */ /* WSLUA_OPTARG_Protofield_int16_MASK Integer mask of this field. */ /* WSLUA_OPTARG_Protofield_int16_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_int24 Creates a `ProtoField` of a signed 24-bit integer. */ /* WSLUA_ARG_Protofield_int24_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_int24_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_int24_BASE One of `base.DEC` or `base.UNIT_STRING`. */ /* WSLUA_OPTARG_Protofield_int24_VALUESTRING A table containing the text that corresponds to the values, or a table containing unit name for the values if base is `base.UNIT_STRING`. */ /* WSLUA_OPTARG_Protofield_int24_MASK Integer mask of this field. */ /* WSLUA_OPTARG_Protofield_int24_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_int32 Creates a `ProtoField` of a signed 32-bit integer. */ /* WSLUA_ARG_Protofield_int32_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_int32_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_int32_BASE One of `base.DEC` or `base.UNIT_STRING`. */ /* WSLUA_OPTARG_Protofield_int32_VALUESTRING A table containing the text that corresponds to the values, or a table containing unit name for the values if base is `base.UNIT_STRING`. */ /* WSLUA_OPTARG_Protofield_int32_MASK Integer mask of this field. */ /* WSLUA_OPTARG_Protofield_int32_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_int64 Creates a `ProtoField` of a signed 64-bit integer. */ /* WSLUA_ARG_Protofield_int64_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_int64_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_int64_BASE One of `base.DEC` or `base.UNIT_STRING`. */ /* WSLUA_OPTARG_Protofield_int64_VALUESTRING A table containing the text that corresponds to the values, or a table containing unit name for the values if base is `base.UNIT_STRING`. */ /* WSLUA_OPTARG_Protofield_int64_MASK Integer mask of this field. */ /* WSLUA_OPTARG_Protofield_int64_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_framenum Creates a `ProtoField` for a frame number (for hyperlinks between frames). */ /* WSLUA_ARG_Protofield_framenum_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_framenum_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_framenum_BASE Only `base.NONE` is supported for framenum. */ /* WSLUA_OPTARG_Protofield_framenum_FRAMETYPE One of `frametype.NONE`, `frametype.REQUEST`, `frametype.RESPONSE`, `frametype.ACK` or `frametype.DUP_ACK`. */ /* WSLUA_OPTARG_Protofield_framenum_MASK Integer mask of this field, which must be 0 for framenum. */ /* WSLUA_OPTARG_Protofield_framenum_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ PROTOFIELD_INTEGER(uint8,FT_UINT8) PROTOFIELD_INTEGER(uint16,FT_UINT16) PROTOFIELD_INTEGER(uint24,FT_UINT24) PROTOFIELD_INTEGER(uint32,FT_UINT32) PROTOFIELD_INTEGER(uint64,FT_UINT64) PROTOFIELD_INTEGER(int8,FT_INT8) PROTOFIELD_INTEGER(int16,FT_INT16) PROTOFIELD_INTEGER(int24,FT_INT24) PROTOFIELD_INTEGER(int32,FT_INT32) PROTOFIELD_INTEGER(int64,FT_INT64) PROTOFIELD_INTEGER(framenum,FT_FRAMENUM) static int ProtoField_boolean(lua_State* L, enum ftenum type) { ProtoField f; const gchar* abbr = check_field_name(L,1,type); const gchar* name = luaL_optstring(L,2,abbr); unsigned base = (unsigned)luaL_optinteger(L, 3, BASE_NONE); true_false_string* tfs = NULL; guint32 mask = wslua_optguint32(L,5,0); const gchar* blob = luaL_optstring(L,6,NULL); if (!name[0]) { luaL_argerror(L, 2, "cannot be an empty string"); return 0; } if (mask == 0x0 && base != BASE_NONE) { luaL_argerror(L,3,"Fieldbase (fielddisplay) must be base.NONE" " if bitmask is zero."); return 0; } if (mask != 0x0 && (base < 1 || base > 64)) { luaL_argerror(L,3,"Fieldbase (fielddisplay) must be between 1 and 64" " if bitmask is non-zero."); return 0; } if (lua_gettop(L) > 3 && !lua_isnil(L,4)) { tfs = true_false_string_from_table(L,4); } f = g_new(wslua_field_t,1); f->hfid = -2; f->ett = -1; f->name = g_strdup(name); f->abbrev = g_strdup(abbr); f->type = type; f->vs = TFS(tfs); f->base = base; f->mask = mask; if (blob && strcmp(blob, f->name) != 0) { f->blob = g_strdup(blob); } else { f->blob = NULL; } pushProtoField(L,f); return 1; } #define PROTOFIELD_BOOL(lower,FT) static int ProtoField_##lower(lua_State* L) { return ProtoField_boolean(L,FT); } /* _WSLUA_CONSTRUCTOR_ ProtoField_bool Creates a `ProtoField` for a boolean true/false value. */ /* WSLUA_ARG_Protofield_bool_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_bool_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_bool_DISPLAY how wide the parent bitfield is (`base.NONE` is used for NULL-value). */ /* WSLUA_OPTARG_Protofield_bool_VALUESTRING A table containing the text that corresponds to the values. */ /* WSLUA_OPTARG_Protofield_bool_MASK Integer mask of this field. */ /* WSLUA_OPTARG_Protofield_bool_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ PROTOFIELD_BOOL(bool,FT_BOOLEAN) static int ProtoField_time(lua_State* L,enum ftenum type) { ProtoField f; const gchar* abbr = check_field_name(L,1,type); const gchar* name = luaL_optstring(L,2,abbr); unsigned base = (unsigned)luaL_optinteger(L,3,ABSOLUTE_TIME_LOCAL); const gchar* blob = luaL_optstring(L,4,NULL); if (!name[0]) { luaL_argerror(L, 2, "cannot be an empty string"); return 0; } if (type == FT_ABSOLUTE_TIME) { if (base < ABSOLUTE_TIME_LOCAL || base > ABSOLUTE_TIME_DOY_UTC) { luaL_argerror(L, 3, "Base must be either base.LOCAL, base.UTC, or base.DOY_UTC"); return 0; } } f = g_new(wslua_field_t,1); f->hfid = -2; f->ett = -1; f->name = g_strdup(name); f->abbrev = g_strdup(abbr); f->type = type; f->vs = NULL; f->base = base; f->mask = 0; if (blob && strcmp(blob, f->name) != 0) { f->blob = g_strdup(blob); } else { f->blob = NULL; } pushProtoField(L,f); return 1; } #define PROTOFIELD_TIME(lower,FT) static int ProtoField_##lower(lua_State* L) { return ProtoField_time(L,FT); } /* _WSLUA_CONSTRUCTOR_ ProtoField_absolute_time Creates a `ProtoField` of a time_t structure value. */ /* WSLUA_ARG_Protofield_absolute_time_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_absolute_time_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_absolute_time_BASE One of `base.LOCAL`, `base.UTC` or `base.DOY_UTC`. */ /* WSLUA_OPTARG_Protofield_absolute_time_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_relative_time Creates a `ProtoField` of a time_t structure value. */ /* WSLUA_ARG_Protofield_relative_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_relative_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_relative_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ PROTOFIELD_TIME(absolute_time,FT_ABSOLUTE_TIME) static int ProtoField_floating(lua_State* L,enum ftenum type) { ProtoField f; const gchar* abbr = check_field_name(L,1,type); const gchar* name = luaL_optstring(L,2,abbr); unit_name_string* uns = NULL; const gchar* blob; if (!name[0]) { luaL_argerror(L, 2, "cannot be an empty string"); return 0; } if (lua_istable(L, 3)) { uns = unit_name_string_from_table(L,3); blob = luaL_optstring(L,4,NULL); } else { blob = luaL_optstring(L,3,NULL); } f = g_new(wslua_field_t,1); f->hfid = -2; f->ett = -1; f->name = g_strdup(name); f->abbrev = g_strdup(abbr); f->type = type; if (uns) { f->vs = uns; f->base = BASE_NONE | BASE_UNIT_STRING; } else { f->vs = NULL; f->base = BASE_NONE; } f->mask = 0; if (blob && strcmp(blob, f->name) != 0) { f->blob = g_strdup(blob); } else { f->blob = NULL; } pushProtoField(L,f); return 1; } #define PROTOFIELD_FLOATING(lower,FT) static int ProtoField_##lower(lua_State* L) { return ProtoField_floating(L,FT); } /* _WSLUA_CONSTRUCTOR_ ProtoField_float Creates a `ProtoField` of a floating point number (4 bytes). */ /* WSLUA_ARG_Protofield_float_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_float_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_float_VALUESTRING A table containing unit name for the values. */ /* WSLUA_OPTARG_Protofield_float_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_double Creates a `ProtoField` of a double-precision floating point (8 bytes). */ /* WSLUA_ARG_Protofield_double_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_double_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_double_VALUESTRING A table containing unit name for the values. */ /* WSLUA_OPTARG_Protofield_double_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ PROTOFIELD_FLOATING(float,FT_FLOAT) PROTOFIELD_FLOATING(double,FT_DOUBLE) static int ProtoField_other_display(lua_State* L,enum ftenum type) { ProtoField f; const gchar* abbr = check_field_name(L,1,type); const gchar* name = luaL_optstring(L,2,abbr); unsigned base = BASE_NONE; const gchar* blob; if (!name[0]) { luaL_argerror(L, 2, "cannot be an empty string"); return 0; } if (lua_isnumber(L, 3)) { base = (unsigned)luaL_optinteger(L,3,BASE_NONE); if (type == FT_STRING || type == FT_STRINGZ) { if (base != STR_ASCII && base != STR_UNICODE) { luaL_argerror(L, 3, "Display must be either base.ASCII or base.UNICODE"); return 0; } } else if (type == FT_BYTES || type == FT_UINT_BYTES) { if (base != BASE_NONE && (base < SEP_DOT || base > SEP_SPACE)) { luaL_argerror(L, 3, "Display must be either base.NONE, base.DOT, base.DASH, base.COLON or base.SPACE"); return 0; } } blob = luaL_optstring(L,4,NULL); } else { blob = luaL_optstring(L,3,NULL); } f = g_new(wslua_field_t,1); f->hfid = -2; f->ett = -1; f->name = g_strdup(name); f->abbrev = g_strdup(abbr); f->type = type; f->vs = NULL; f->base = base; f->mask = 0; if (blob && strcmp(blob, f->name) != 0) { f->blob = g_strdup(blob); } else { f->blob = NULL; } pushProtoField(L,f); return 1; } #define PROTOFIELD_OTHER_DISPLAY(lower,FT) static int ProtoField_##lower(lua_State* L) { return ProtoField_other_display(L,FT); } /* _WSLUA_CONSTRUCTOR_ ProtoField_string Creates a `ProtoField` of a string value. */ /* WSLUA_ARG_Protofield_string_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_string_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_string_DISPLAY One of `base.ASCII` or `base.UNICODE`. */ /* WSLUA_OPTARG_Protofield_string_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_stringz Creates a `ProtoField` of a zero-terminated string value. */ /* WSLUA_ARG_Protofield_stringz_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_stringz_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_stringz_DISPLAY One of `base.ASCII` or `base.UNICODE`. */ /* WSLUA_OPTARG_Protofield_stringz_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_bytes Creates a `ProtoField` for an arbitrary number of bytes. */ /* WSLUA_ARG_Protofield_bytes_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_bytes_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_bytes_DISPLAY One of `base.NONE`, `base.DOT`, `base.DASH`, `base.COLON` or `base.SPACE`. */ /* WSLUA_OPTARG_Protofield_bytes_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_ubytes Creates a `ProtoField` for an arbitrary number of unsigned bytes. */ /* WSLUA_ARG_Protofield_ubytes_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_ubytes_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_ubytes_DISPLAY One of `base.NONE`, `base.DOT`, `base.DASH`, `base.COLON` or `base.SPACE`. */ /* WSLUA_OPTARG_Protofield_ubytes_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ PROTOFIELD_OTHER_DISPLAY(string,FT_STRING) PROTOFIELD_OTHER_DISPLAY(stringz,FT_STRINGZ) PROTOFIELD_OTHER_DISPLAY(bytes,FT_BYTES) PROTOFIELD_OTHER_DISPLAY(ubytes,FT_UINT_BYTES) static int ProtoField_other(lua_State* L,enum ftenum type) { ProtoField f; const gchar* abbr = check_field_name(L,1,type); const gchar* name = luaL_optstring(L,2,abbr); const gchar* blob = luaL_optstring(L,3,NULL); if (!name[0]) { luaL_argerror(L, 2, "cannot be an empty string"); return 0; } f = g_new(wslua_field_t,1); f->hfid = -2; f->ett = -1; f->name = g_strdup(name); f->abbrev = g_strdup(abbr); f->type = type; f->vs = NULL; f->base = BASE_NONE; f->mask = 0; if (blob && strcmp(blob, f->name) != 0) { f->blob = g_strdup(blob); } else { f->blob = NULL; } pushProtoField(L,f); return 1; } #define PROTOFIELD_OTHER(lower,FT) static int ProtoField_##lower(lua_State* L) { return ProtoField_other(L,FT); } /* _WSLUA_CONSTRUCTOR_ ProtoField_none Creates a `ProtoField` of an unstructured type. */ /* WSLUA_ARG_Protofield_none_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_none_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_none_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_ipv4 Creates a `ProtoField` of an IPv4 address (4 bytes). */ /* WSLUA_ARG_Protofield_ipv4_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_ipv4_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_ipv4_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_ipv6 Creates a `ProtoField` of an IPv6 address (16 bytes). */ /* WSLUA_ARG_Protofield_ipv6_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_ipv6_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_ipv6_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_ether Creates a `ProtoField` of an Ethernet address (6 bytes). */ /* WSLUA_ARG_Protofield_ether_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_ether_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_ether_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_guid Creates a `ProtoField` for a Globally Unique IDentifier (GUID). */ /* WSLUA_ARG_Protofield_guid_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_guid_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_guid_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_oid Creates a `ProtoField` for an ASN.1 Organizational IDentified (OID). */ /* WSLUA_ARG_Protofield_oid_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_oid_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_oid_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_protocol Creates a `ProtoField` for a sub-protocol. Since 1.99.9. */ /* WSLUA_ARG_Protofield_protocol_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_protocol_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_protocol_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_rel_oid Creates a `ProtoField` for an ASN.1 Relative-OID. */ /* WSLUA_ARG_Protofield_rel_oid_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_rel_oid_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_rel_oid_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_systemid Creates a `ProtoField` for an OSI System ID. */ /* WSLUA_ARG_Protofield_systemid_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_systemid_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_systemid_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ /* _WSLUA_CONSTRUCTOR_ ProtoField_eui64 Creates a `ProtoField` for an EUI64. */ /* WSLUA_ARG_Protofield_eui64_ABBR Abbreviated name of the field (the string used in filters). */ /* WSLUA_OPTARG_Protofield_eui64_NAME Actual name of the field (the string that appears in the tree). */ /* WSLUA_OPTARG_Protofield_eui64_DESC Description of the field. */ /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */ PROTOFIELD_OTHER(none,FT_NONE) PROTOFIELD_OTHER(ipv4,FT_IPv4) PROTOFIELD_OTHER(ipv6,FT_IPv6) PROTOFIELD_OTHER(ipx,FT_IPXNET) PROTOFIELD_OTHER(ether,FT_ETHER) PROTOFIELD_OTHER(relative_time,FT_RELATIVE_TIME) PROTOFIELD_OTHER(guid,FT_GUID) PROTOFIELD_OTHER(oid,FT_OID) PROTOFIELD_OTHER(protocol,FT_PROTOCOL) PROTOFIELD_OTHER(rel_oid,FT_REL_OID) PROTOFIELD_OTHER(systemid,FT_SYSTEM_ID) PROTOFIELD_OTHER(eui64,FT_EUI64) WSLUA_METAMETHOD ProtoField__tostring(lua_State* L) { /* Returns a string with info about a protofield (for debugging purposes). */ ProtoField f = checkProtoField(L,1); gchar* s = g_strdup_printf("ProtoField(%i): %s %s %s %s %p %.8x %s", f->hfid,f->name,f->abbrev, ftenum_to_string(f->type), base_to_string(f->base), f->vs,f->mask,f->blob); lua_pushstring(L,s); g_free(s); return 1; } static int ProtoField__gc(lua_State* L) { ProtoField f = toProtoField(L,1); if (f->hfid == -2) { /* Only free unregistered and deregistered ProtoField */ g_free(f); } return 0; } WSLUA_METHODS ProtoField_methods[] = { WSLUA_CLASS_FNREG(ProtoField,new), WSLUA_CLASS_FNREG(ProtoField,none), WSLUA_CLASS_FNREG(ProtoField,uint8), WSLUA_CLASS_FNREG(ProtoField,uint16), WSLUA_CLASS_FNREG(ProtoField,uint24), WSLUA_CLASS_FNREG(ProtoField,uint32), WSLUA_CLASS_FNREG(ProtoField,uint64), WSLUA_CLASS_FNREG(ProtoField,int8), WSLUA_CLASS_FNREG(ProtoField,int16), WSLUA_CLASS_FNREG(ProtoField,int24), WSLUA_CLASS_FNREG(ProtoField,int32), WSLUA_CLASS_FNREG(ProtoField,int64), WSLUA_CLASS_FNREG(ProtoField,framenum), WSLUA_CLASS_FNREG(ProtoField,ipv4), WSLUA_CLASS_FNREG(ProtoField,ipv6), WSLUA_CLASS_FNREG(ProtoField,ipx), WSLUA_CLASS_FNREG(ProtoField,ether), WSLUA_CLASS_FNREG(ProtoField,bool), WSLUA_CLASS_FNREG(ProtoField,float), WSLUA_CLASS_FNREG(ProtoField,double), WSLUA_CLASS_FNREG(ProtoField,absolute_time), WSLUA_CLASS_FNREG(ProtoField,relative_time), WSLUA_CLASS_FNREG(ProtoField,string), WSLUA_CLASS_FNREG(ProtoField,stringz), WSLUA_CLASS_FNREG(ProtoField,bytes), WSLUA_CLASS_FNREG(ProtoField,ubytes), WSLUA_CLASS_FNREG(ProtoField,guid), WSLUA_CLASS_FNREG(ProtoField,oid), WSLUA_CLASS_FNREG(ProtoField,protocol), WSLUA_CLASS_FNREG(ProtoField,rel_oid), WSLUA_CLASS_FNREG(ProtoField,systemid), WSLUA_CLASS_FNREG(ProtoField,eui64), { NULL, NULL } }; WSLUA_META ProtoField_meta[] = { WSLUA_CLASS_MTREG(ProtoField,tostring), { NULL, NULL } }; int ProtoField_register(lua_State* L) { WSLUA_REGISTER_CLASS(ProtoField); return 0; } /* * Editor modelines - http://www.wireshark.org/tools/modelines.html * * Local variables: * c-basic-offset: 4 * tab-width: 8 * indent-tabs-mode: nil * End: * * vi: set shiftwidth=4 tabstop=8 expandtab: * :indentSize=4:tabSize=8:noTabs=true: */