2006-09-25 01:09:00 +00:00
/*
* wslua_tvb . c
*
* Wireshark ' s interface to the Lua Programming Language
*
2008-08-05 21:03:46 +00:00
* ( c ) 2006 , Luis E . Garcia Ontanon < luis @ ontanon . org >
2008-07-26 23:41:31 +00:00
* ( c ) 2008 , Balint Reczey < balint . reczey @ ericsson . com >
2009-06-08 08:14:36 +00:00
* ( c ) 2009 , Stig Bjorlykke < stig @ bjorlykke . org >
2006-09-25 01:09:00 +00:00
*
* Wireshark - Network traffic analyzer
* By Gerald Combs < gerald @ wireshark . org >
* 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
2012-06-28 22:56:06 +00:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA .
2006-09-25 01:09:00 +00:00
*/
2011-04-21 13:13:39 +00:00
# include "config.h"
2013-09-13 08:49:38 +00:00
# include <epan/emem.h>
2008-04-12 13:56:28 +00:00
/* WSLUA_MODULE Tvb Functions for handling packet data */
2006-10-18 18:45:24 +00:00
2006-09-25 01:09:00 +00:00
# include "wslua.h"
2013-12-21 14:38:51 +00:00
# include "wsutil/base64.h"
2006-09-25 01:09:00 +00:00
2014-02-19 08:22:55 +00:00
WSLUA_CLASS_DEFINE ( ByteArray , FAIL_ON_NULL ( " ByteArray " ) , NOP ) ;
2006-09-25 01:09:00 +00:00
2010-10-21 12:41:15 +00:00
WSLUA_CONSTRUCTOR ByteArray_new ( lua_State * L ) { /* Creates a ByteArray Object */
2006-09-25 01:09:00 +00:00
# define WSLUA_OPTARG_ByteArray_new_HEXBYTES 1 /* A string consisting of hexadecimal bytes like "00 B1 A2" or "1a2b3c4d" */
2014-02-18 15:03:04 +00:00
# define WSLUA_OPTARG_ByteArray_new_SEPARATOR 2 /* A string separator between hex bytes/words (default=" "); or if the boolean value 'true' is used, then the first arg is treated as raw binary data */
2006-09-25 01:09:00 +00:00
GByteArray * ba = g_byte_array_new ( ) ;
const gchar * s ;
2014-02-18 15:03:04 +00:00
size_t len = 0 ;
const gchar * sep = " " ;
gboolean ishex = TRUE ;
2006-09-25 01:09:00 +00:00
2014-02-18 15:03:04 +00:00
if ( lua_gettop ( L ) > = 1 ) {
s = luaL_checklstring ( L , WSLUA_OPTARG_ByteArray_new_HEXBYTES , & len ) ;
2007-01-24 01:06:24 +00:00
2014-02-27 04:42:15 +00:00
if ( ! s ) {
2006-09-25 01:09:00 +00:00
WSLUA_OPTARG_ERROR ( ByteArray_new , HEXBYTES , " must be a string " ) ;
2014-02-27 04:42:15 +00:00
return 0 ;
}
2007-01-24 01:06:24 +00:00
2014-02-18 15:03:04 +00:00
if ( lua_gettop ( L ) > = 2 ) {
if ( lua_type ( L , 2 ) = = LUA_TBOOLEAN & & lua_toboolean ( L , 2 ) ) {
ishex = FALSE ;
} else {
sep = luaL_optstring ( L , WSLUA_OPTARG_ByteArray_new_SEPARATOR , " " ) ;
2006-09-25 01:09:00 +00:00
}
2014-02-18 15:03:04 +00:00
}
2006-09-25 01:09:00 +00:00
2014-02-18 15:03:04 +00:00
if ( ishex ) {
wslua_hex2bin ( L , s , ( guint ) len , sep ) ; /* this pushes a new string on top of stack */
s = luaL_checklstring ( L , - 1 , & len ) ; /* get the new binary string */
g_byte_array_append ( ba , s , ( guint ) len ) ; /* copy it into ByteArray */
lua_pop ( L , 1 ) ; /* pop the newly created string */
} else {
g_byte_array_append ( ba , s , ( guint ) len ) ;
2006-09-25 01:09:00 +00:00
}
2007-01-24 01:06:24 +00:00
}
2006-09-25 01:09:00 +00:00
pushByteArray ( L , ba ) ;
WSLUA_RETURN ( 1 ) ; /* The new ByteArray object. */
}
2013-02-25 22:05:28 +00:00
/* Gets registered as metamethod automatically by WSLUA_REGISTER_CLASS/META */
static int ByteArray__gc ( lua_State * L ) {
2014-02-19 08:22:55 +00:00
ByteArray ba = toByteArray ( L , 1 ) ;
2006-09-25 01:09:00 +00:00
if ( ! ba ) return 0 ;
2007-01-24 01:06:24 +00:00
2006-09-25 01:09:00 +00:00
g_byte_array_free ( ba , TRUE ) ;
return 0 ;
}
2010-10-21 12:41:15 +00:00
WSLUA_METAMETHOD ByteArray__concat ( lua_State * L ) {
/* Concatenate two ByteArrays */
2009-05-08 16:40:38 +00:00
# define WSLUA_ARG_ByteArray__cat_FIRST 1 /* First array */
# define WSLUA_ARG_ByteArray__cat_SECOND 2 /* Second array */
2007-01-24 01:06:24 +00:00
2013-09-09 17:49:22 +00:00
ByteArray ba1 = checkByteArray ( L , WSLUA_ARG_ByteArray__cat_FIRST ) ;
2009-01-27 14:36:46 +00:00
ByteArray ba2 = checkByteArray ( L , WSLUA_ARG_ByteArray__cat_SECOND ) ;
2013-09-09 17:49:22 +00:00
ByteArray ba ;
2006-09-25 01:09:00 +00:00
2013-09-09 17:49:22 +00:00
ba = g_byte_array_new ( ) ;
g_byte_array_append ( ba , ba1 - > data , ba1 - > len ) ;
2006-09-25 01:09:00 +00:00
g_byte_array_append ( ba , ba2 - > data , ba2 - > len ) ;
pushByteArray ( L , ba ) ;
WSLUA_RETURN ( 1 ) ; /* The new composite ByteArray. */
}
2010-10-21 12:41:15 +00:00
WSLUA_METHOD ByteArray_prepend ( lua_State * L ) {
/* Prepend a ByteArray to this ByteArray */
2009-05-08 16:40:38 +00:00
# define WSLUA_ARG_ByteArray_prepend_PREPENDED 2 /* Array to be prepended */
2006-09-25 01:09:00 +00:00
ByteArray ba = checkByteArray ( L , 1 ) ;
2009-01-27 14:36:46 +00:00
ByteArray ba2 = checkByteArray ( L , WSLUA_ARG_ByteArray_prepend_PREPENDED ) ;
2007-01-24 01:06:24 +00:00
2006-09-25 01:09:00 +00:00
g_byte_array_prepend ( ba , ba2 - > data , ba2 - > len ) ;
2007-01-24 01:06:24 +00:00
2013-09-09 17:49:22 +00:00
return 0 ;
2006-09-25 01:09:00 +00:00
}
2010-10-21 12:41:15 +00:00
WSLUA_METHOD ByteArray_append ( lua_State * L ) {
/* Append a ByteArray to this ByteArray */
2009-05-08 16:40:38 +00:00
# define WSLUA_ARG_ByteArray_append_APPENDED 2 /* Array to be appended */
2006-09-25 01:09:00 +00:00
ByteArray ba = checkByteArray ( L , 1 ) ;
2009-01-27 14:36:46 +00:00
ByteArray ba2 = checkByteArray ( L , WSLUA_ARG_ByteArray_append_APPENDED ) ;
2007-01-24 01:06:24 +00:00
2008-09-16 14:00:48 +00:00
g_byte_array_append ( ba , ba2 - > data , ba2 - > len ) ;
2007-01-24 01:06:24 +00:00
2013-09-09 17:49:22 +00:00
return 0 ;
2006-09-25 01:09:00 +00:00
}
2010-10-21 12:41:15 +00:00
WSLUA_METHOD ByteArray_set_size ( lua_State * L ) {
/* Sets the size of a ByteArray, either truncating it or filling it with zeros. */
2009-05-08 16:40:38 +00:00
# define WSLUA_ARG_ByteArray_set_size_SIZE 2 /* New size of the array*/
2006-10-24 13:16:57 +00:00
2006-09-25 01:09:00 +00:00
ByteArray ba = checkByteArray ( L , 1 ) ;
2009-01-27 14:36:46 +00:00
int siz = luaL_checkint ( L , WSLUA_ARG_ByteArray_set_size_SIZE ) ;
2008-09-16 14:00:48 +00:00
guint8 * padding ;
2006-09-25 01:09:00 +00:00
2014-02-27 04:42:15 +00:00
if ( siz < 0 ) {
2008-09-16 14:00:48 +00:00
WSLUA_ERROR ( ByteArray_set_size , " ByteArray size must be non-negative " ) ;
2014-02-27 04:42:15 +00:00
return 0 ;
}
2006-09-25 01:09:00 +00:00
2008-09-16 18:26:43 +00:00
if ( ba - > len > = ( guint ) siz ) { /* truncate */
2008-09-16 14:00:48 +00:00
g_byte_array_set_size ( ba , siz ) ;
} else { /* fill */
2013-03-16 08:12:29 +00:00
padding = ( guint8 * ) g_malloc0 ( sizeof ( guint8 ) * ( siz - ba - > len ) ) ;
2008-09-16 14:00:48 +00:00
g_byte_array_append ( ba , padding , siz - ba - > len ) ;
g_free ( padding ) ;
}
2006-09-25 01:09:00 +00:00
return 0 ;
}
2010-10-21 12:41:15 +00:00
WSLUA_METHOD ByteArray_set_index ( lua_State * L ) {
/* Sets the value of an index of a ByteArray. */
2009-05-08 16:40:38 +00:00
# define WSLUA_ARG_ByteArray_set_index_INDEX 2 /* The position of the byte to be set */
# define WSLUA_ARG_ByteArray_set_index_VALUE 3 /* The char value to set [0-255] */
2006-09-25 01:09:00 +00:00
ByteArray ba = checkByteArray ( L , 1 ) ;
2009-01-27 14:36:46 +00:00
int idx = luaL_checkint ( L , WSLUA_ARG_ByteArray_set_index_INDEX ) ;
int v = luaL_checkint ( L , WSLUA_ARG_ByteArray_set_index_VALUE ) ;
2007-01-24 01:06:24 +00:00
2006-09-25 01:09:00 +00:00
if ( idx = = 0 & & ! g_str_equal ( luaL_optstring ( L , 2 , " " ) , " 0 " ) ) {
luaL_argerror ( L , 2 , " bad index " ) ;
return 0 ;
}
2007-01-24 01:06:24 +00:00
2006-09-25 01:09:00 +00:00
if ( idx < 0 | | ( guint ) idx > = ba - > len ) {
luaL_argerror ( L , 2 , " index out of range " ) ;
return 0 ;
}
if ( v < 0 | | v > 255 ) {
luaL_argerror ( L , 3 , " Byte out of range " ) ;
return 0 ;
}
2007-01-24 01:06:24 +00:00
2006-09-25 01:09:00 +00:00
ba - > data [ idx ] = ( guint8 ) v ;
2007-01-24 01:06:24 +00:00
2006-09-25 01:09:00 +00:00
return 0 ;
}
2010-10-21 12:41:15 +00:00
WSLUA_METHOD ByteArray_get_index ( lua_State * L ) {
/* Get the value of a byte in a ByteArray */
2009-07-08 14:20:59 +00:00
# define WSLUA_ARG_ByteArray_get_index_INDEX 2 /* The position of the byte to get */
2006-09-25 01:09:00 +00:00
ByteArray ba = checkByteArray ( L , 1 ) ;
2009-07-08 14:20:59 +00:00
int idx = luaL_checkint ( L , WSLUA_ARG_ByteArray_get_index_INDEX ) ;
2007-01-24 01:06:24 +00:00
2006-09-25 01:09:00 +00:00
if ( idx = = 0 & & ! g_str_equal ( luaL_optstring ( L , 2 , " " ) , " 0 " ) ) {
luaL_argerror ( L , 2 , " bad index " ) ;
return 0 ;
}
2007-01-24 01:06:24 +00:00
2006-09-25 01:09:00 +00:00
if ( idx < 0 | | ( guint ) idx > = ba - > len ) {
luaL_argerror ( L , 2 , " index out of range " ) ;
return 0 ;
}
lua_pushnumber ( L , ba - > data [ idx ] ) ;
2007-01-24 01:06:24 +00:00
2006-10-24 13:16:57 +00:00
WSLUA_RETURN ( 1 ) ; /* The value [0-255] of the byte. */
2006-09-25 01:09:00 +00:00
}
2010-10-21 12:41:15 +00:00
WSLUA_METHOD ByteArray_len ( lua_State * L ) {
/* Obtain the length of a ByteArray */
2006-09-25 01:09:00 +00:00
ByteArray ba = checkByteArray ( L , 1 ) ;
2007-01-24 01:06:24 +00:00
2006-09-25 01:09:00 +00:00
lua_pushnumber ( L , ( lua_Number ) ba - > len ) ;
2006-10-24 13:16:57 +00:00
WSLUA_RETURN ( 1 ) ; /* The length of the ByteArray. */
2006-09-25 01:09:00 +00:00
}
2010-10-21 12:41:15 +00:00
WSLUA_METHOD ByteArray_subset ( lua_State * L ) {
2014-02-18 15:03:04 +00:00
/* Obtain a segment of a ByteArray, as a new ByteArray. */
# define WSLUA_ARG_ByteArray_set_index_OFFSET 2 /* The position of the first byte (0=first) */
2009-05-08 16:40:38 +00:00
# define WSLUA_ARG_ByteArray_set_index_LENGTH 3 /* The length of the segment */
2006-09-25 01:09:00 +00:00
ByteArray ba = checkByteArray ( L , 1 ) ;
2009-01-27 14:36:46 +00:00
int offset = luaL_checkint ( L , WSLUA_ARG_ByteArray_set_index_OFFSET ) ;
int len = luaL_checkint ( L , WSLUA_ARG_ByteArray_set_index_LENGTH ) ;
2006-09-25 01:09:00 +00:00
ByteArray sub ;
if ( ( offset + len ) > ( int ) ba - > len | | offset < 0 | | len < 1 ) {
luaL_error ( L , " Out Of Bounds " ) ;
return 0 ;
}
sub = g_byte_array_new ( ) ;
g_byte_array_append ( sub , ba - > data + offset , len ) ;
2007-01-24 01:06:24 +00:00
2006-09-25 01:09:00 +00:00
pushByteArray ( L , sub ) ;
2007-01-24 01:06:24 +00:00
2009-05-08 16:40:38 +00:00
WSLUA_RETURN ( 1 ) ; /* A ByteArray contaning the requested segment. */
2006-09-25 01:09:00 +00:00
}
2014-02-06 06:33:12 +00:00
WSLUA_METHOD ByteArray_base64_decode ( lua_State * L ) {
2013-12-18 12:55:43 +00:00
/* Obtain a base64 decoded ByteArray */
ByteArray ba = checkByteArray ( L , 1 ) ;
ByteArray ba2 ;
gchar * data ;
size_t len ;
ba2 = g_byte_array_new ( ) ;
2013-12-18 13:37:20 +00:00
data = ( gchar * ) g_malloc ( ba - > len + 1 ) ;
2013-12-18 12:55:43 +00:00
memcpy ( data , ba - > data , ba - > len ) ;
data [ ba - > len ] = ' \0 ' ;
2014-02-25 20:42:35 +00:00
2013-12-21 14:38:51 +00:00
len = ws_base64_decode_inplace ( data ) ;
2013-12-18 12:55:43 +00:00
g_byte_array_append ( ba2 , data , ( int ) len ) ;
g_free ( data ) ;
pushByteArray ( L , ba2 ) ;
WSLUA_RETURN ( 1 ) ; /* The created ByteArray. */
}
2014-02-18 15:03:04 +00:00
WSLUA_METHOD ByteArray_raw ( lua_State * L ) {
/* Obtain a Lua string of the binary bytes in a ByteArray. */
# define WSLUA_OPTARG_ByteArray_raw_OFFSET 2 /* The position of the first byte (default=0/first). */
# define WSLUA_OPTARG_ByteArray_raw_LENGTH 3 /* The length of the segment to get (default=all). */
2006-09-25 01:09:00 +00:00
ByteArray ba = checkByteArray ( L , 1 ) ;
2014-02-18 15:03:04 +00:00
guint offset = ( guint ) luaL_optint ( L , WSLUA_OPTARG_ByteArray_raw_OFFSET , 0 ) ;
int len ;
2007-01-24 01:06:24 +00:00
2006-09-25 01:09:00 +00:00
if ( ! ba ) return 0 ;
2014-02-27 04:42:15 +00:00
if ( offset > ba - > len ) {
2014-02-18 15:03:04 +00:00
WSLUA_OPTARG_ERROR ( ByteArray_raw , OFFSET , " offset beyond end of byte array " ) ;
2014-02-27 04:42:15 +00:00
return 0 ;
}
2007-01-24 01:06:24 +00:00
2014-02-18 15:03:04 +00:00
len = luaL_optint ( L , WSLUA_OPTARG_ByteArray_raw_LENGTH , ba - > len - offset ) ;
if ( ( len < 0 ) | | ( ( guint ) len > ( ba - > len - offset ) ) )
len = ba - > len - offset ;
2007-01-24 01:06:24 +00:00
2014-02-18 15:03:04 +00:00
lua_pushlstring ( L , & ( ba - > data [ offset ] ) , len ) ;
WSLUA_RETURN ( 1 ) ; /* A Lua string of the binary bytes in the ByteArray. */
}
WSLUA_METHOD ByteArray_tohex ( lua_State * L ) {
/* Obtain a Lua string of the bytes in a ByteArray as hex-ascii, with given separator */
# define WSLUA_OPTARG_ByteArray_tohex_LOWERCASE 2 /* True to use lower-case hex characters (default=false). */
# define WSLUA_OPTARG_ByteArray_tohex_SEPARATOR 3 /* A string separator to insert between hex bytes (default=nil). */
ByteArray ba = checkByteArray ( L , 1 ) ;
gboolean lowercase = FALSE ;
const gchar * sep = NULL ;
if ( ! ba ) return 0 ;
lowercase = wslua_optbool ( L , WSLUA_OPTARG_ByteArray_tohex_LOWERCASE , FALSE ) ;
sep = luaL_optstring ( L , WSLUA_OPTARG_ByteArray_tohex_SEPARATOR , NULL ) ;
wslua_bin2hex ( L , ba - > data , ba - > len , lowercase , sep ) ;
WSLUA_RETURN ( 1 ) ; /* A hex-ascii string representation of the ByteArray. */
}
2007-01-24 01:06:24 +00:00
2014-02-18 15:03:04 +00:00
WSLUA_METAMETHOD ByteArray__tostring ( lua_State * L ) {
/* Obtain a Lua string containing the bytes in a ByteArray so that it can be used in display filters (e.g. "01FE456789AB") */
ByteArray ba = checkByteArray ( L , 1 ) ;
if ( ! ba ) return 0 ;
2007-01-24 01:06:24 +00:00
2014-02-18 15:03:04 +00:00
wslua_bin2hex ( L , ba - > data , ba - > len , FALSE , NULL ) ;
WSLUA_RETURN ( 1 ) ; /* A hex-ascii string representation of the ByteArray. */
2006-09-25 01:09:00 +00:00
}
2011-06-23 10:43:49 +00:00
static int ByteArray_tvb ( lua_State * L ) ;
2006-09-25 01:09:00 +00:00
2014-02-19 08:22:55 +00:00
WSLUA_METHODS ByteArray_methods [ ] = {
WSLUA_CLASS_FNREG ( ByteArray , new ) ,
WSLUA_CLASS_FNREG ( ByteArray , len ) ,
WSLUA_CLASS_FNREG ( ByteArray , prepend ) ,
WSLUA_CLASS_FNREG ( ByteArray , append ) ,
WSLUA_CLASS_FNREG ( ByteArray , subset ) ,
WSLUA_CLASS_FNREG ( ByteArray , set_size ) ,
WSLUA_CLASS_FNREG ( ByteArray , tvb ) ,
WSLUA_CLASS_FNREG ( ByteArray , base64_decode ) ,
WSLUA_CLASS_FNREG ( ByteArray , get_index ) ,
WSLUA_CLASS_FNREG ( ByteArray , set_index ) ,
2014-02-18 15:03:04 +00:00
WSLUA_CLASS_FNREG ( ByteArray , tohex ) ,
WSLUA_CLASS_FNREG ( ByteArray , raw ) ,
2008-04-25 18:59:20 +00:00
{ NULL , NULL }
2006-09-25 01:09:00 +00:00
} ;
2014-02-19 08:22:55 +00:00
WSLUA_META ByteArray_meta [ ] = {
WSLUA_CLASS_MTREG ( ByteArray , tostring ) ,
WSLUA_CLASS_MTREG ( ByteArray , concat ) ,
2006-09-25 01:09:00 +00:00
{ " __call " , ByteArray_subset } ,
2008-04-25 18:59:20 +00:00
{ NULL , NULL }
2006-09-25 01:09:00 +00:00
} ;
2010-10-21 12:41:15 +00:00
int ByteArray_register ( lua_State * L ) {
2009-06-08 08:02:15 +00:00
WSLUA_REGISTER_CLASS ( ByteArray ) ;
2014-01-31 07:25:42 +00:00
return 0 ;
2006-09-25 01:09:00 +00:00
}
/*
* Tvb & TvbRange
*
2007-01-24 01:06:24 +00:00
* a Tvb represents a tvbuff_t in Lua .
2013-02-26 02:38:52 +00:00
* a TvbRange represents a range in a tvb ( tvb , offset , length ) its main purpose is to do bounds checking ,
2013-02-26 15:10:28 +00:00
* It helps , too , simplifying argument passing to Tree . In wireshark terms this is worthless nothing
* not already done by the TVB itself . In lua ' s terms it ' s necessary to avoid abusing TRY { } CATCH ( ) { }
2007-01-24 01:06:24 +00:00
* via preemptive bounds checking .
2006-09-25 01:09:00 +00:00
*
2013-02-26 15:10:28 +00:00
* These lua objects refer to structures in wireshark that are freed independently from Lua ' s garbage collector .
* To avoid using pointers from Lua to Wireshark structures that are already freed , we maintain a list of the
* pointers each with a marker that tracks its expiry .
2006-09-25 01:09:00 +00:00
*
2009-01-27 12:41:33 +00:00
* All pointers are marked as expired when the dissection of the current frame is finished or when the garbage
2008-07-26 23:41:31 +00:00
* collector tries to free the object referring to the pointer , whichever comes first .
2008-09-16 18:26:43 +00:00
*
2008-07-26 23:41:31 +00:00
* All allocated memory chunks used for tracking the pointers ' state are freed after marking the pointer as expired
* by the garbage collector or by the end of the dissection of the current frame , whichever comes second .
*
2009-05-10 16:02:57 +00:00
* We check the expiry state of the pointer before each access .
2006-09-25 01:09:00 +00:00
*
*/
2014-02-19 08:22:55 +00:00
WSLUA_CLASS_DEFINE ( Tvb , FAIL_ON_NULL_OR_EXPIRED ( " Tvb " ) , NOP ) ;
2010-10-21 12:41:15 +00:00
/* A Tvb represents the packet's buffer. It is passed as an argument to listeners and dissectors,
and can be used to extract information ( via TvbRange ) from the packet ' s data . Beware that Tvbs are usable only by the current
listener or dissector call and are destroyed as soon as the listener / dissector returns , so references
to them are unusable once the function has returned .
To create a tvbrange the tvb must be called with offset and length as optional arguments ( the offset defaults to 0 and the length to tvb : len ( ) ) */
2006-09-25 01:09:00 +00:00
2008-07-26 23:41:31 +00:00
static GPtrArray * outstanding_Tvb = NULL ;
static GPtrArray * outstanding_TvbRange = NULL ;
2006-09-25 01:09:00 +00:00
2008-07-26 23:41:31 +00:00
# define PUSH_TVB(L,t) {g_ptr_array_add(outstanding_Tvb,t);pushTvb(L,t);}
# define PUSH_TVBRANGE(L,t) {g_ptr_array_add(outstanding_TvbRange,t);pushTvbRange(L,t);}
2006-09-25 01:09:00 +00:00
2011-11-06 17:39:13 +00:00
static void free_Tvb ( Tvb tvb ) {
if ( ! tvb ) return ;
if ( ! tvb - > expired ) {
tvb - > expired = TRUE ;
} else {
if ( tvb - > need_free )
tvb_free ( tvb - > ws_tvb ) ;
g_free ( tvb ) ;
}
}
void clear_outstanding_Tvb ( void ) {
while ( outstanding_Tvb - > len ) {
Tvb tvb = ( Tvb ) g_ptr_array_remove_index_fast ( outstanding_Tvb , 0 ) ;
free_Tvb ( tvb ) ;
}
}
static void free_TvbRange ( TvbRange tvbr ) {
if ( ! ( tvbr & & tvbr - > tvb ) ) return ;
if ( ! tvbr - > tvb - > expired ) {
tvbr - > tvb - > expired = TRUE ;
} else {
free_Tvb ( tvbr - > tvb ) ;
g_free ( tvbr ) ;
}
}
void clear_outstanding_TvbRange ( void ) {
while ( outstanding_TvbRange - > len ) {
TvbRange tvbr = ( TvbRange ) g_ptr_array_remove_index_fast ( outstanding_TvbRange , 0 ) ;
free_TvbRange ( tvbr ) ;
}
}
2006-09-25 01:09:00 +00:00
2008-07-26 23:41:31 +00:00
2010-10-21 12:41:15 +00:00
Tvb * push_Tvb ( lua_State * L , tvbuff_t * ws_tvb ) {
2013-03-16 08:12:29 +00:00
Tvb tvb = ( Tvb ) g_malloc ( sizeof ( struct _wslua_tvb ) ) ;
2008-07-26 23:41:31 +00:00
tvb - > ws_tvb = ws_tvb ;
tvb - > expired = FALSE ;
2011-11-06 17:39:13 +00:00
tvb - > need_free = FALSE ;
2008-07-26 23:41:31 +00:00
g_ptr_array_add ( outstanding_Tvb , tvb ) ;
return pushTvb ( L , tvb ) ;
2006-09-25 01:09:00 +00:00
}
/*
2011-06-23 10:43:49 +00:00
* ByteArray_tvb ( name )
2006-09-25 01:09:00 +00:00
*/
2011-06-23 10:43:49 +00:00
WSLUA_CONSTRUCTOR ByteArray_tvb ( lua_State * L ) {
2010-10-21 12:41:15 +00:00
/* Creates a new Tvb from a bytearray (it gets added to the current frame too) */
2011-06-23 10:43:49 +00:00
# define WSLUA_ARG_ByteArray_tvb_NAME 2 /* The name to be given to the new data-source. */
2006-09-25 01:09:00 +00:00
ByteArray ba = checkByteArray ( L , 1 ) ;
2011-06-23 10:43:49 +00:00
const gchar * name = luaL_optstring ( L , WSLUA_ARG_ByteArray_tvb_NAME , " Unnamed " ) ;
2006-09-25 01:09:00 +00:00
guint8 * data ;
Tvb tvb ;
2007-01-24 01:06:24 +00:00
2006-09-25 01:09:00 +00:00
if ( ! lua_tvb ) {
luaL_error ( L , " Tvbs can only be created and used in dissectors " ) ;
return 0 ;
}
2007-01-24 01:06:24 +00:00
2013-03-16 08:12:29 +00:00
data = ( guint8 * ) g_memdup ( ba - > data , ba - > len ) ;
2007-01-24 01:06:24 +00:00
2013-03-16 08:12:29 +00:00
tvb = ( Tvb ) g_malloc ( sizeof ( struct _wslua_tvb ) ) ;
2008-07-26 23:41:31 +00:00
tvb - > ws_tvb = tvb_new_real_data ( data , ba - > len , ba - > len ) ;
tvb - > expired = FALSE ;
2011-11-06 17:39:13 +00:00
tvb - > need_free = TRUE ;
2008-07-26 23:41:31 +00:00
tvb_set_free_cb ( tvb - > ws_tvb , g_free ) ;
2007-01-24 01:06:24 +00:00
2008-07-26 23:41:31 +00:00
add_new_data_source ( lua_pinfo , tvb - > ws_tvb , name ) ;
2006-09-25 01:09:00 +00:00
PUSH_TVB ( L , tvb ) ;
2009-05-08 16:40:38 +00:00
WSLUA_RETURN ( 1 ) ; /* The created Tvb. */
2006-09-25 01:09:00 +00:00
}
2011-06-23 10:28:53 +00:00
WSLUA_CONSTRUCTOR TvbRange_tvb ( lua_State * L ) {
2014-02-18 15:03:04 +00:00
/* Creates a (sub)Tvb from a TvbRange */
2009-05-08 16:40:38 +00:00
# define WSLUA_ARG_Tvb_new_subset_RANGE 1 /* The TvbRange from which to create the new Tvb. */
2006-10-24 13:16:57 +00:00
2009-01-27 14:36:46 +00:00
TvbRange tvbr = checkTvbRange ( L , WSLUA_ARG_Tvb_new_subset_RANGE ) ;
2008-07-26 23:41:31 +00:00
Tvb tvb ;
2007-01-24 01:06:24 +00:00
2008-07-26 23:41:31 +00:00
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
2007-01-24 01:06:24 +00:00
2008-07-26 23:41:31 +00:00
if ( tvb_offset_exists ( tvbr - > tvb - > ws_tvb , tvbr - > offset + tvbr - > len - 1 ) ) {
2013-03-16 08:12:29 +00:00
tvb = ( Tvb ) g_malloc ( sizeof ( struct _wslua_tvb ) ) ;
2008-07-26 23:41:31 +00:00
tvb - > expired = FALSE ;
2011-11-06 17:39:13 +00:00
tvb - > need_free = FALSE ;
2008-07-26 23:41:31 +00:00
tvb - > ws_tvb = tvb_new_subset ( tvbr - > tvb - > ws_tvb , tvbr - > offset , tvbr - > len , tvbr - > len ) ;
PUSH_TVB ( L , tvb ) ;
2006-09-25 01:09:00 +00:00
return 1 ;
} else {
luaL_error ( L , " Out Of Bounds " ) ;
return 0 ;
}
}
2010-10-21 12:41:15 +00:00
WSLUA_METAMETHOD Tvb__tostring ( lua_State * L ) {
/* Convert the bytes of a Tvb into a string, to be used for debugging purposes as '...' will be appended in case the string is too long. */
2006-09-25 01:09:00 +00:00
Tvb tvb = checkTvb ( L , 1 ) ;
int len ;
gchar * str ;
2007-01-24 01:06:24 +00:00
2008-07-26 23:41:31 +00:00
len = tvb_length ( tvb - > ws_tvb ) ;
2013-12-19 15:49:09 +00:00
str = ep_strdup_printf ( " TVB(%i) : %s " , len , tvb_bytes_to_ep_str ( tvb - > ws_tvb , 0 , len ) ) ;
2006-09-25 01:09:00 +00:00
lua_pushstring ( L , str ) ;
2009-05-08 16:40:38 +00:00
WSLUA_RETURN ( 1 ) ; /* The string. */
2006-09-25 01:09:00 +00:00
}
2013-02-25 22:05:28 +00:00
/* Gets registered as metamethod automatically by WSLUA_REGISTER_CLASS/META */
2010-10-21 12:41:15 +00:00
static int Tvb__gc ( lua_State * L ) {
2014-02-19 08:22:55 +00:00
Tvb tvb = toTvb ( L , 1 ) ;
2008-07-26 23:41:31 +00:00
2011-11-06 17:39:13 +00:00
free_Tvb ( tvb ) ;
2008-07-26 23:41:31 +00:00
return 0 ;
}
2006-09-25 01:09:00 +00:00
2011-08-10 21:45:53 +00:00
WSLUA_METHOD Tvb_reported_len ( lua_State * L ) {
2014-03-10 05:54:51 +00:00
/* Obtain the reported (not captured) length of a TVB */
2011-08-10 21:45:53 +00:00
Tvb tvb = checkTvb ( L , 1 ) ;
lua_pushnumber ( L , tvb_reported_length ( tvb - > ws_tvb ) ) ;
WSLUA_RETURN ( 1 ) ; /* The length of the Tvb. */
}
2010-10-21 12:41:15 +00:00
WSLUA_METHOD Tvb_len ( lua_State * L ) {
2014-03-10 05:54:51 +00:00
/* Obtain the actual (captured) length of a TVB */
2006-09-25 01:09:00 +00:00
Tvb tvb = checkTvb ( L , 1 ) ;
2007-01-24 01:06:24 +00:00
2008-07-26 23:41:31 +00:00
lua_pushnumber ( L , tvb_length ( tvb - > ws_tvb ) ) ;
2009-05-08 16:40:38 +00:00
WSLUA_RETURN ( 1 ) ; /* The length of the Tvb. */
2006-09-25 01:09:00 +00:00
}
2011-08-11 00:49:43 +00:00
WSLUA_METHOD Tvb_reported_length_remaining ( lua_State * L ) {
2014-03-10 05:54:51 +00:00
/* Obtain the reported (not captured) length of packet data to end of a TVB or -1 if the offset is beyond the end of the TVB */
2011-08-11 00:49:43 +00:00
# define Tvb_reported_length_remaining_OFFSET 2 /* offset */
Tvb tvb = checkTvb ( L , 1 ) ;
int offset = luaL_optint ( L , Tvb_reported_length_remaining_OFFSET , 0 ) ;
lua_pushnumber ( L , tvb_reported_length_remaining ( tvb - > ws_tvb , offset ) ) ;
WSLUA_RETURN ( 1 ) ; /* The length of the Tvb. */
}
2010-10-21 12:41:15 +00:00
WSLUA_METHOD Tvb_offset ( lua_State * L ) {
/* Returns the raw offset (from the beginning of the source Tvb) of a sub Tvb. */
2006-09-25 01:09:00 +00:00
Tvb tvb = checkTvb ( L , 1 ) ;
2007-01-24 01:06:24 +00:00
2011-05-27 03:06:50 +00:00
lua_pushnumber ( L , tvb_raw_offset ( tvb - > ws_tvb ) ) ;
2009-05-08 16:40:38 +00:00
WSLUA_RETURN ( 1 ) ; /* The raw offset of the Tvb. */
2006-09-25 01:09:00 +00:00
}
2007-01-23 23:34:41 +00:00
# if USED_FOR_DOC_PURPOSES
2010-10-21 12:41:15 +00:00
WSLUA_METAMETHOD Tvb__call ( lua_State * L ) {
2009-05-08 16:40:38 +00:00
/* Equivalent to tvb:range(...) */
2007-01-24 01:06:24 +00:00
return 0 ;
2007-01-23 23:34:41 +00:00
}
# endif
2014-02-19 08:22:55 +00:00
WSLUA_CLASS_DEFINE ( TvbRange , FAIL_ON_NULL ( " TvbRange " ) , NOP ) ;
2006-09-25 01:09:00 +00:00
/*
2013-02-26 15:10:28 +00:00
A TvbRange represents a usable range of a Tvb and is used to extract data from the Tvb that generated it
TvbRanges are created by calling a tvb ( e . g . tvb ( offset , length ) ) . If the TvbRange span is outside the
Tvb ' s range the creation will cause a runtime error .
2006-09-25 01:09:00 +00:00
*/
2013-12-19 15:26:31 +00:00
gboolean push_TvbRange ( lua_State * L , tvbuff_t * ws_tvb , int offset , int len ) {
2006-09-25 01:09:00 +00:00
TvbRange tvbr ;
2007-01-24 01:06:24 +00:00
2008-07-26 23:41:31 +00:00
if ( ! ws_tvb ) {
luaL_error ( L , " expired tvb " ) ;
2013-12-19 15:26:31 +00:00
return FALSE ;
2008-07-26 23:41:31 +00:00
}
2006-09-25 01:09:00 +00:00
if ( len = = - 1 ) {
2008-07-26 23:41:31 +00:00
len = tvb_length_remaining ( ws_tvb , offset ) ;
2006-09-25 01:09:00 +00:00
if ( len < 0 ) {
luaL_error ( L , " out of bounds " ) ;
2013-12-19 15:26:31 +00:00
return FALSE ;
2007-01-24 01:06:24 +00:00
}
2008-07-26 23:41:31 +00:00
} else if ( ( guint ) ( len + offset ) > tvb_length ( ws_tvb ) ) {
2006-09-25 01:09:00 +00:00
luaL_error ( L , " Range is out of bounds " ) ;
2013-12-19 15:26:31 +00:00
return FALSE ;
2006-09-25 01:09:00 +00:00
}
2007-01-24 01:06:24 +00:00
2013-03-16 08:12:29 +00:00
tvbr = ( TvbRange ) g_malloc ( sizeof ( struct _wslua_tvbrange ) ) ;
tvbr - > tvb = ( Tvb ) g_malloc ( sizeof ( struct _wslua_tvb ) ) ;
2008-07-26 23:41:31 +00:00
tvbr - > tvb - > ws_tvb = ws_tvb ;
tvbr - > tvb - > expired = FALSE ;
2011-11-06 17:39:13 +00:00
tvbr - > tvb - > need_free = FALSE ;
2006-09-25 01:09:00 +00:00
tvbr - > offset = offset ;
tvbr - > len = len ;
2007-01-24 01:06:24 +00:00
2013-12-19 15:26:31 +00:00
PUSH_TVBRANGE ( L , tvbr ) ;
return TRUE ;
2006-09-25 01:09:00 +00:00
}
2007-01-24 01:06:24 +00:00
2010-10-21 12:41:15 +00:00
WSLUA_METHOD Tvb_range ( lua_State * L ) {
/* Creates a tvbr from this Tvb. This is used also as the Tvb:__call() metamethod. */
2013-02-26 04:42:26 +00:00
# define WSLUA_OPTARG_Tvb_range_OFFSET 2 /* The offset (in octets) from the beginning of the Tvb. Defaults to 0. */
2009-01-27 14:36:46 +00:00
# define WSLUA_OPTARG_Tvb_range_LENGTH 3 /* The length (in octets) of the range. Defaults to until the end of the Tvb. */
2007-01-24 01:06:24 +00:00
2006-09-25 01:09:00 +00:00
Tvb tvb = checkTvb ( L , 1 ) ;
2009-01-27 14:36:46 +00:00
int offset = luaL_optint ( L , WSLUA_OPTARG_Tvb_range_OFFSET , 0 ) ;
int len = luaL_optint ( L , WSLUA_OPTARG_Tvb_range_LENGTH , - 1 ) ;
2006-09-25 01:09:00 +00:00
2013-12-19 15:26:31 +00:00
if ( push_TvbRange ( L , tvb - > ws_tvb , offset , len ) ) {
2009-06-08 08:14:36 +00:00
WSLUA_RETURN ( 1 ) ; /* The TvbRange */
2006-09-25 01:09:00 +00:00
}
2007-01-24 01:06:24 +00:00
2006-09-25 01:09:00 +00:00
return 0 ;
}
2014-02-18 15:03:04 +00:00
WSLUA_METHOD Tvb_raw ( lua_State * L ) {
/* Obtain a Lua string of the binary bytes in a Tvb. */
# define WSLUA_OPTARG_Tvb_raw_OFFSET 2 /* The position of the first byte (default=0/first). */
# define WSLUA_OPTARG_Tvb_raw_LENGTH 3 /* The length of the segment to get (default=all). */
Tvb tvb = checkTvb ( L , 1 ) ;
int offset = luaL_optint ( L , WSLUA_OPTARG_Tvb_raw_OFFSET , 0 ) ;
int len = luaL_optint ( L , WSLUA_OPTARG_Tvb_raw_LENGTH , - 1 ) ;
if ( ! tvb ) return 0 ;
if ( tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
2014-02-27 04:42:15 +00:00
if ( ( guint ) offset > tvb_length ( tvb - > ws_tvb ) ) {
2014-02-18 15:03:04 +00:00
WSLUA_OPTARG_ERROR ( Tvb_raw , OFFSET , " offset beyond end of Tvb " ) ;
2014-02-27 04:42:15 +00:00
return 0 ;
}
2014-02-18 15:03:04 +00:00
if ( len = = - 1 ) {
len = tvb_length_remaining ( tvb - > ws_tvb , offset ) ;
if ( len < 0 ) {
luaL_error ( L , " out of bounds " ) ;
return FALSE ;
}
} else if ( ( guint ) ( len + offset ) > tvb_length ( tvb - > ws_tvb ) ) {
luaL_error ( L , " Range is out of bounds " ) ;
return FALSE ;
}
lua_pushlstring ( L , tvb_get_ptr ( tvb - > ws_tvb , offset , len ) , len ) ;
WSLUA_RETURN ( 1 ) ; /* A Lua string of the binary bytes in the Tvb. */
}
2014-02-19 08:22:55 +00:00
WSLUA_METHODS Tvb_methods [ ] = {
WSLUA_CLASS_FNREG ( Tvb , range ) ,
WSLUA_CLASS_FNREG ( Tvb , len ) ,
WSLUA_CLASS_FNREG ( Tvb , offset ) ,
WSLUA_CLASS_FNREG ( Tvb , reported_len ) ,
WSLUA_CLASS_FNREG ( Tvb , reported_length_remaining ) ,
2014-02-18 15:03:04 +00:00
WSLUA_CLASS_FNREG ( Tvb , raw ) ,
2008-04-25 18:59:20 +00:00
{ NULL , NULL }
2007-01-24 01:06:24 +00:00
} ;
2014-02-19 08:22:55 +00:00
WSLUA_META Tvb_meta [ ] = {
WSLUA_CLASS_MTREG ( Tvb , tostring ) ,
2007-01-24 01:06:24 +00:00
{ " __call " , Tvb_range } ,
2008-04-25 18:59:20 +00:00
{ NULL , NULL }
2007-01-24 01:06:24 +00:00
} ;
2010-10-21 12:41:15 +00:00
int Tvb_register ( lua_State * L ) {
2009-06-08 08:02:15 +00:00
WSLUA_REGISTER_CLASS ( Tvb ) ;
2014-01-31 07:25:42 +00:00
return 0 ;
2007-01-24 01:06:24 +00:00
}
2006-09-25 01:09:00 +00:00
2010-10-21 12:41:15 +00:00
/*
* get a Blefuscuoan unsigned integer from a tvb
*/
WSLUA_METHOD TvbRange_uint ( lua_State * L ) {
/* Get a Big Endian (network order) unsigned integer from a TvbRange. The range must be 1, 2, 3 or 4 octets long. */
2006-09-25 01:09:00 +00:00
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
2008-07-26 23:41:31 +00:00
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
2007-01-24 01:06:24 +00:00
2006-09-25 01:09:00 +00:00
switch ( tvbr - > len ) {
case 1 :
2008-07-26 23:41:31 +00:00
lua_pushnumber ( L , tvb_get_guint8 ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
2006-09-25 01:09:00 +00:00
return 1 ;
case 2 :
2008-07-26 23:41:31 +00:00
lua_pushnumber ( L , tvb_get_ntohs ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
2006-09-25 01:09:00 +00:00
return 1 ;
case 3 :
2008-07-26 23:41:31 +00:00
lua_pushnumber ( L , tvb_get_ntoh24 ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
2006-09-25 01:09:00 +00:00
return 1 ;
case 4 :
2008-07-26 23:41:31 +00:00
lua_pushnumber ( L , tvb_get_ntohl ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
2009-06-08 08:14:36 +00:00
WSLUA_RETURN ( 1 ) ; /* The unsigned integer value */
2006-09-25 01:09:00 +00:00
/*
* XXX :
* lua uses double so we have 52 bits to play with
* we are missing 5 and 6 byte integers within lua ' s range
* and 64 bit integers are not supported ( there ' s a lib for
* lua that does ) .
*/
default :
2010-01-05 16:07:21 +00:00
luaL_error ( L , " TvbRange:uint() does not handle %d byte integers " , tvbr - > len ) ;
2006-09-25 01:09:00 +00:00
return 0 ;
}
}
2010-10-21 12:41:15 +00:00
/*
* get a Lilliputian unsigned integer from a tvb
*/
WSLUA_METHOD TvbRange_le_uint ( lua_State * L ) {
/* Get a Little Endian unsigned integer from a TvbRange. The range must be 1, 2, 3 or 4 octets long. */
2006-09-25 01:09:00 +00:00
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
2008-07-26 23:41:31 +00:00
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
2007-01-24 01:06:24 +00:00
2006-09-25 01:09:00 +00:00
switch ( tvbr - > len ) {
case 1 :
/* XXX unsigned anyway */
2014-02-27 04:42:15 +00:00
lua_pushnumber ( L , ( lua_Number ) ( guint ) tvb_get_guint8 ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
2006-09-25 01:09:00 +00:00
return 1 ;
case 2 :
2008-07-26 23:41:31 +00:00
lua_pushnumber ( L , tvb_get_letohs ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
2006-09-25 01:09:00 +00:00
return 1 ;
case 3 :
2008-07-26 23:41:31 +00:00
lua_pushnumber ( L , tvb_get_letoh24 ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
2006-09-25 01:09:00 +00:00
return 1 ;
case 4 :
2008-07-26 23:41:31 +00:00
lua_pushnumber ( L , tvb_get_letohl ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
2009-06-08 08:14:36 +00:00
WSLUA_RETURN ( 1 ) ; /* The unsigned integer value */
2006-09-25 01:09:00 +00:00
default :
2010-01-05 16:07:21 +00:00
luaL_error ( L , " TvbRange:le_uint() does not handle %d byte integers " , tvbr - > len ) ;
2006-09-25 01:09:00 +00:00
return 0 ;
}
}
2010-10-21 12:41:15 +00:00
/*
* get a Blefuscuoan unsigned 64 bit integer from a tvb
*/
WSLUA_METHOD TvbRange_uint64 ( lua_State * L ) {
/* Get a Big Endian (network order) unsigned 64 bit integer from a TvbRange. The range must be 1-8 octets long. */
2008-09-16 14:37:00 +00:00
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
switch ( tvbr - > len ) {
case 1 :
case 2 :
case 3 :
case 4 :
case 5 :
case 6 :
case 7 :
case 8 : {
2014-02-03 03:49:30 +00:00
pushUInt64 ( L , tvb_get_ntoh64 ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
2008-09-16 14:37:00 +00:00
WSLUA_RETURN ( 1 ) ;
}
default :
2010-01-05 16:07:21 +00:00
luaL_error ( L , " TvbRange:uint64() does not handle %d byte integers " , tvbr - > len ) ;
2008-09-16 14:37:00 +00:00
return 0 ;
}
}
2010-10-21 12:41:15 +00:00
/*
* get a Lilliputian unsigned 64 bit integer from a tvb
*/
WSLUA_METHOD TvbRange_le_uint64 ( lua_State * L ) {
/* Get a Little Endian unsigned 64 bit integer from a TvbRange. The range must be 1-8 octets long. */
2008-09-16 14:37:00 +00:00
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
switch ( tvbr - > len ) {
case 1 :
case 2 :
case 3 :
case 4 :
case 5 :
case 6 :
case 7 :
case 8 : {
2014-02-03 03:49:30 +00:00
pushUInt64 ( L , tvb_get_letoh64 ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
2008-09-16 14:37:00 +00:00
WSLUA_RETURN ( 1 ) ;
}
default :
2010-01-05 16:07:21 +00:00
luaL_error ( L , " TvbRange:le_uint64() does not handle %d byte integers " , tvbr - > len ) ;
2008-09-16 14:37:00 +00:00
return 0 ;
}
}
2010-10-21 12:41:15 +00:00
/*
* get a Blefuscuoan signed integer from a tvb
*/
WSLUA_METHOD TvbRange_int ( lua_State * L ) {
/* Get a Big Endian (network order) signed integer from a TvbRange. The range must be 1, 2 or 4 octets long. */
2010-01-05 20:25:04 +00:00
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
switch ( tvbr - > len ) {
case 1 :
lua_pushnumber ( L , ( gchar ) tvb_get_guint8 ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
return 1 ;
case 2 :
lua_pushnumber ( L , ( gshort ) tvb_get_ntohs ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
return 1 ;
case 4 :
lua_pushnumber ( L , ( gint ) tvb_get_ntohl ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
WSLUA_RETURN ( 1 ) ; /* The signed integer value */
/*
* XXX :
* lua uses double so we have 52 bits to play with
* we are missing 5 and 6 byte integers within lua ' s range
* and 64 bit integers are not supported ( there ' s a lib for
* lua that does ) .
*/
default :
luaL_error ( L , " TvbRange:int() does not handle %d byte integers " , tvbr - > len ) ;
return 0 ;
}
}
2010-10-21 12:41:15 +00:00
/*
* get a Lilliputian signed integer from a tvb
*/
WSLUA_METHOD TvbRange_le_int ( lua_State * L ) {
/* Get a Little Endian signed integer from a TvbRange. The range must be 1, 2 or 4 octets long. */
2010-01-05 20:25:04 +00:00
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
switch ( tvbr - > len ) {
case 1 :
lua_pushnumber ( L , ( gchar ) tvb_get_guint8 ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
return 1 ;
case 2 :
lua_pushnumber ( L , ( gshort ) tvb_get_letohs ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
return 1 ;
case 4 :
lua_pushnumber ( L , ( gint ) tvb_get_letohl ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
WSLUA_RETURN ( 1 ) ; /* The signed integer value */
default :
luaL_error ( L , " TvbRange:le_int() does not handle %d byte integers " , tvbr - > len ) ;
return 0 ;
}
}
2010-10-21 12:41:15 +00:00
/*
* get a Blefuscuoan signed 64 bit integer from a tvb
*/
WSLUA_METHOD TvbRange_int64 ( lua_State * L ) {
/* Get a Big Endian (network order) signed 64 bit integer from a TvbRange. The range must be 1-8 octets long. */
2010-01-05 20:25:04 +00:00
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
switch ( tvbr - > len ) {
case 1 :
case 2 :
case 3 :
case 4 :
case 5 :
case 6 :
case 7 :
case 8 : {
2014-02-03 03:49:30 +00:00
pushInt64 ( L , ( gint64 ) tvb_get_ntoh64 ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
2010-01-05 20:25:04 +00:00
WSLUA_RETURN ( 1 ) ;
}
default :
luaL_error ( L , " TvbRange:int64() does not handle %d byte integers " , tvbr - > len ) ;
return 0 ;
}
}
2010-10-21 12:41:15 +00:00
/*
* get a Lilliputian signed 64 bit integer from a tvb
*/
WSLUA_METHOD TvbRange_le_int64 ( lua_State * L ) {
/* Get a Little Endian signed 64 bit integer from a TvbRange. The range must be 1-8 octets long. */
2010-01-05 20:25:04 +00:00
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
switch ( tvbr - > len ) {
case 1 :
case 2 :
case 3 :
case 4 :
case 5 :
case 6 :
case 7 :
case 8 : {
2014-02-03 03:49:30 +00:00
pushInt64 ( L , ( gint64 ) tvb_get_letoh64 ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
2010-01-05 20:25:04 +00:00
WSLUA_RETURN ( 1 ) ;
}
default :
luaL_error ( L , " TvbRange:le_int64() does not handle %d byte integers " , tvbr - > len ) ;
return 0 ;
}
}
2010-10-21 12:41:15 +00:00
/*
* get a Blefuscuoan float
*/
WSLUA_METHOD TvbRange_float ( lua_State * L ) {
/* Get a Big Endian (network order) floating point number from a TvbRange. The range must be 4 or 8 octets long. */
2006-09-25 01:09:00 +00:00
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
2008-07-26 23:41:31 +00:00
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
2007-01-24 01:06:24 +00:00
2006-09-25 01:09:00 +00:00
switch ( tvbr - > len ) {
case 4 :
2008-07-26 23:41:31 +00:00
lua_pushnumber ( L , ( double ) tvb_get_ntohieee_float ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
2006-09-25 01:09:00 +00:00
return 1 ;
case 8 :
2008-07-26 23:41:31 +00:00
lua_pushnumber ( L , tvb_get_ntohieee_double ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
2010-01-06 10:13:56 +00:00
WSLUA_RETURN ( 1 ) ; /* The floating point value */
2006-09-25 01:09:00 +00:00
default :
2010-01-05 16:07:21 +00:00
luaL_error ( L , " TvbRange:float() does not handle %d byte floating numbers " , tvbr - > len ) ;
2006-09-25 01:09:00 +00:00
return 0 ;
}
}
2010-10-21 12:41:15 +00:00
/*
* get a Lilliputian float
*/
WSLUA_METHOD TvbRange_le_float ( lua_State * L ) {
/* Get a Little Endian floating point number from a TvbRange. The range must be 4 or 8 octets long. */
2006-09-25 01:09:00 +00:00
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
2008-07-26 23:41:31 +00:00
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
2007-01-24 01:06:24 +00:00
2006-09-25 01:09:00 +00:00
switch ( tvbr - > len ) {
case 4 :
2008-07-26 23:41:31 +00:00
lua_pushnumber ( L , tvb_get_letohieee_float ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
2006-09-25 01:09:00 +00:00
return 1 ;
case 8 :
2008-07-26 23:41:31 +00:00
lua_pushnumber ( L , tvb_get_letohieee_double ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
2010-01-06 10:13:56 +00:00
WSLUA_RETURN ( 1 ) ; /* The floating point value */
2006-09-25 01:09:00 +00:00
default :
2010-01-05 16:07:21 +00:00
luaL_error ( L , " TvbRange:le_float() does not handle %d byte floating numbers " , tvbr - > len ) ;
2006-09-25 01:09:00 +00:00
return 0 ;
}
}
2010-10-21 12:41:15 +00:00
WSLUA_METHOD TvbRange_ipv4 ( lua_State * L ) {
/* Get an IPv4 Address from a TvbRange. */
2006-09-25 01:09:00 +00:00
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
Address addr ;
guint32 * ip_addr ;
2007-01-24 01:06:24 +00:00
2008-07-26 23:41:31 +00:00
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
2007-01-24 01:06:24 +00:00
2014-02-27 04:42:15 +00:00
if ( tvbr - > len ! = 4 ) {
2009-06-08 08:14:36 +00:00
WSLUA_ERROR ( TvbRange_ipv4 , " The range must be 4 octets long " ) ;
2014-02-27 04:42:15 +00:00
return 0 ;
}
2007-01-24 01:06:24 +00:00
2013-03-16 08:12:29 +00:00
addr = ( address * ) g_malloc ( sizeof ( address ) ) ;
2006-09-25 01:09:00 +00:00
2013-03-16 08:12:29 +00:00
ip_addr = ( guint32 * ) g_malloc ( sizeof ( guint32 ) ) ;
2008-07-26 23:41:31 +00:00
* ip_addr = tvb_get_ipv4 ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ;
2007-01-24 01:06:24 +00:00
SET_ADDRESS ( addr , AT_IPv4 , 4 , ip_addr ) ;
2006-09-25 01:09:00 +00:00
pushAddress ( L , addr ) ;
2009-06-08 08:14:36 +00:00
WSLUA_RETURN ( 1 ) ; /* The IPv4 Address */
2006-09-25 01:09:00 +00:00
}
2010-10-21 12:41:15 +00:00
WSLUA_METHOD TvbRange_le_ipv4 ( lua_State * L ) {
/* Get an Little Endian IPv4 Address from a TvbRange. */
2007-04-12 22:45:22 +00:00
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
Address addr ;
guint32 * ip_addr ;
2008-09-16 18:26:43 +00:00
2008-07-26 23:41:31 +00:00
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
2008-09-16 18:26:43 +00:00
2014-02-27 04:42:15 +00:00
if ( tvbr - > len ! = 4 ) {
2009-06-08 08:14:36 +00:00
WSLUA_ERROR ( TvbRange_ipv4 , " The range must be 4 octets long " ) ;
2014-02-27 04:42:15 +00:00
return 0 ;
}
2008-09-16 18:26:43 +00:00
2013-03-16 08:12:29 +00:00
addr = ( address * ) g_malloc ( sizeof ( address ) ) ;
2008-09-16 18:26:43 +00:00
2013-03-16 08:12:29 +00:00
ip_addr = ( guint32 * ) g_malloc ( sizeof ( guint32 ) ) ;
2008-07-26 23:41:31 +00:00
* ip_addr = tvb_get_ipv4 ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ;
2007-04-12 22:45:22 +00:00
* ( ( guint32 * ) ip_addr ) = GUINT32_SWAP_LE_BE ( * ( ( guint32 * ) ip_addr ) ) ;
2008-09-16 18:26:43 +00:00
2007-04-12 22:45:22 +00:00
SET_ADDRESS ( addr , AT_IPv4 , 4 , ip_addr ) ;
pushAddress ( L , addr ) ;
2008-09-16 18:26:43 +00:00
2009-06-08 08:14:36 +00:00
WSLUA_RETURN ( 1 ) ; /* The IPv4 Address */
2007-04-12 22:45:22 +00:00
}
2010-10-21 12:41:15 +00:00
WSLUA_METHOD TvbRange_ether ( lua_State * L ) {
/* Get an Ethernet Address from a TvbRange. */
2006-09-25 01:09:00 +00:00
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
Address addr ;
guint8 * buff ;
2007-01-24 01:06:24 +00:00
2008-07-26 23:41:31 +00:00
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
2007-01-24 01:06:24 +00:00
2014-02-27 04:42:15 +00:00
if ( tvbr - > len ! = 6 ) {
2009-06-08 08:14:36 +00:00
WSLUA_ERROR ( TvbRange_ether , " The range must be 6 bytes long " ) ;
2014-02-27 04:42:15 +00:00
return 0 ;
}
2007-01-24 01:06:24 +00:00
2012-04-27 06:02:45 +00:00
addr = g_new ( address , 1 ) ;
2013-09-22 15:50:55 +00:00
buff = ( guint8 * ) tvb_memdup ( NULL , tvbr - > tvb - > ws_tvb , tvbr - > offset , tvbr - > len ) ;
2007-01-24 01:06:24 +00:00
SET_ADDRESS ( addr , AT_ETHER , 6 , buff ) ;
2006-09-25 01:09:00 +00:00
pushAddress ( L , addr ) ;
2007-01-24 01:06:24 +00:00
2009-06-08 08:14:36 +00:00
WSLUA_RETURN ( 1 ) ; /* The Ethernet Address */
2006-09-25 01:09:00 +00:00
}
2011-08-19 08:36:02 +00:00
WSLUA_METHOD TvbRange_nstime ( lua_State * L ) {
/* Obtain a nstime from a TvbRange */
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
2012-04-27 06:02:45 +00:00
NSTime nstime ;
2011-08-19 08:36:02 +00:00
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
2012-04-27 06:02:45 +00:00
nstime = g_new ( nstime_t , 1 ) ;
2011-08-19 08:36:02 +00:00
if ( tvbr - > len = = 4 ) {
nstime - > secs = tvb_get_ntohl ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ;
nstime - > nsecs = 0 ;
} else if ( tvbr - > len = = 8 ) {
nstime - > secs = tvb_get_ntohl ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ;
nstime - > nsecs = tvb_get_ntohl ( tvbr - > tvb - > ws_tvb , tvbr - > offset + 4 ) ;
} else {
2012-04-27 06:02:45 +00:00
g_free ( nstime ) ;
2011-08-19 08:36:02 +00:00
WSLUA_ERROR ( TvbRange_nstime , " The range must be 4 or 8 bytes long " ) ;
return 0 ;
}
pushNSTime ( L , nstime ) ;
WSLUA_RETURN ( 1 ) ; /* The NSTime */
}
WSLUA_METHOD TvbRange_le_nstime ( lua_State * L ) {
/* Obtain a nstime from a TvbRange */
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
2012-04-27 06:02:45 +00:00
NSTime nstime ;
2011-08-19 08:36:02 +00:00
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
2012-04-27 06:02:45 +00:00
nstime = g_new ( nstime_t , 1 ) ;
2011-08-19 08:36:02 +00:00
if ( tvbr - > len = = 4 ) {
nstime - > secs = tvb_get_letohl ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ;
nstime - > nsecs = 0 ;
} else if ( tvbr - > len = = 8 ) {
nstime - > secs = tvb_get_letohl ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ;
nstime - > nsecs = tvb_get_letohl ( tvbr - > tvb - > ws_tvb , tvbr - > offset + 4 ) ;
} else {
2012-04-27 06:02:45 +00:00
g_free ( nstime ) ;
2011-08-19 08:36:02 +00:00
WSLUA_ERROR ( TvbRange_nstime , " The range must be 4 or 8 bytes long " ) ;
return 0 ;
}
pushNSTime ( L , nstime ) ;
WSLUA_RETURN ( 1 ) ; /* The NSTime */
}
2006-09-25 01:09:00 +00:00
2010-10-21 12:41:15 +00:00
WSLUA_METHOD TvbRange_string ( lua_State * L ) {
/* Obtain a string from a TvbRange */
2013-12-22 13:08:39 +00:00
# define WSLUA_OPTARG_TvbRange_string_ENCODING 2 /* The encoding to use. Defaults to ENC_ASCII. */
2006-09-25 01:09:00 +00:00
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
2013-12-22 13:08:39 +00:00
guint encoding = ( guint ) luaL_optint ( L , WSLUA_OPTARG_TvbRange_string_ENCODING , ENC_ASCII | ENC_NA ) ;
2007-01-24 01:06:24 +00:00
2008-07-26 23:41:31 +00:00
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
2007-01-24 01:06:24 +00:00
2013-12-22 13:08:39 +00:00
lua_pushlstring ( L , ( gchar * ) tvb_get_string_enc ( wmem_packet_scope ( ) , tvbr - > tvb - > ws_tvb , tvbr - > offset , tvbr - > len , encoding ) , tvbr - > len ) ;
2007-01-24 01:06:24 +00:00
2009-06-08 08:14:36 +00:00
WSLUA_RETURN ( 1 ) ; /* The string */
2006-09-25 01:09:00 +00:00
}
2011-10-02 17:02:10 +00:00
static int TvbRange_ustring_any ( lua_State * L , gboolean little_endian ) {
/* Obtain a UTF-16 encoded string from a TvbRange */
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
2013-01-10 06:55:16 +00:00
gchar * str ;
2011-10-02 17:02:10 +00:00
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
2013-12-20 20:29:27 +00:00
str = ( gchar * ) tvb_get_string_enc ( wmem_packet_scope ( ) , tvbr - > tvb - > ws_tvb , tvbr - > offset , tvbr - > len , ( little_endian ? ENC_UTF_16 | ENC_LITTLE_ENDIAN : ENC_UTF_16 | ENC_BIG_ENDIAN ) ) ;
2013-01-10 06:55:16 +00:00
lua_pushlstring ( L , str , strlen ( str ) ) ;
2011-10-02 17:02:10 +00:00
return 1 ; /* The string */
}
WSLUA_METHOD TvbRange_ustring ( lua_State * L ) {
/* Obtain a Big Endian (network order) UTF-16 encoded string from a TvbRange */
WSLUA_RETURN ( TvbRange_ustring_any ( L , FALSE ) ) ; /* The string */
}
WSLUA_METHOD TvbRange_le_ustring ( lua_State * L ) {
/* Obtain a Little Endian UTF-16 encoded string from a TvbRange */
WSLUA_RETURN ( TvbRange_ustring_any ( L , TRUE ) ) ; /* The string */
}
2013-12-22 13:08:39 +00:00
WSLUA_METHOD TvbRange_stringz ( lua_State * L ) {
/* Obtain a zero terminated string from a TvbRange */
# define WSLUA_OPTARG_TvbRange_stringz_ENCODING 2 /* The encoding to use. Defaults to ENC_ASCII. */
2013-12-20 20:29:27 +00:00
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
2013-12-22 13:08:39 +00:00
guint encoding = ( guint ) luaL_optint ( L , WSLUA_OPTARG_TvbRange_stringz_ENCODING , ENC_ASCII | ENC_NA ) ;
2013-12-20 20:29:27 +00:00
gint offset ;
gunichar2 uchar ;
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
switch ( encoding & ENC_CHARENCODING_MASK ) {
case ENC_UTF_16 :
case ENC_UCS_2 :
offset = tvbr - > offset ;
do {
if ( ! tvb_bytes_exist ( tvbr - > tvb - > ws_tvb , offset , 2 ) ) {
luaL_error ( L , " out of bounds " ) ;
return 0 ;
}
/* Endianness doesn't matter when looking for null */
uchar = tvb_get_ntohs ( tvbr - > tvb - > ws_tvb , offset ) ;
offset + = 2 ;
} while ( uchar ! = 0 ) ;
break ;
default :
if ( tvb_find_guint8 ( tvbr - > tvb - > ws_tvb , tvbr - > offset , - 1 , 0 ) = = - 1 ) {
luaL_error ( L , " out of bounds " ) ;
return 0 ;
}
break ;
}
lua_pushstring ( L , ( gchar * ) tvb_get_stringz_enc ( wmem_packet_scope ( ) , tvbr - > tvb - > ws_tvb , tvbr - > offset , NULL , encoding ) ) ;
WSLUA_RETURN ( 1 ) ; /* The zero terminated string */
}
2013-08-22 11:58:32 +00:00
WSLUA_METHOD TvbRange_strsize ( lua_State * L ) {
/* Find the size of a zero terminated string from a TvbRange. The size of the string includes the terminating zero. */
2013-12-22 22:09:06 +00:00
# define WSLUA_OPTARG_TvbRange_strsize_ENCODING 2 /* The encoding to use. Defaults to ENC_ASCII. */
2013-08-22 11:58:32 +00:00
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
2013-12-22 22:09:06 +00:00
guint encoding = ( guint ) luaL_optint ( L , WSLUA_OPTARG_TvbRange_strsize_ENCODING , ENC_ASCII | ENC_NA ) ;
gint offset ;
gunichar2 uchar ;
2013-08-22 11:58:32 +00:00
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
2013-12-22 22:09:06 +00:00
switch ( encoding & ENC_CHARENCODING_MASK ) {
2013-11-21 08:42:21 +00:00
2013-12-22 22:09:06 +00:00
case ENC_UTF_16 :
case ENC_UCS_2 :
offset = tvbr - > offset ;
do {
if ( ! tvb_bytes_exist ( tvbr - > tvb - > ws_tvb , offset , 2 ) ) {
luaL_error ( L , " out of bounds " ) ;
return 0 ;
}
/* Endianness doesn't matter when looking for null */
uchar = tvb_get_ntohs ( tvbr - > tvb - > ws_tvb , offset ) ;
offset + = 2 ;
} while ( uchar ! = 0 ) ;
lua_pushinteger ( L , tvb_unicode_strsize ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
break ;
default :
if ( tvb_find_guint8 ( tvbr - > tvb - > ws_tvb , tvbr - > offset , - 1 , 0 ) = = - 1 ) {
luaL_error ( L , " out of bounds " ) ;
return 0 ;
}
lua_pushinteger ( L , tvb_strsize ( tvbr - > tvb - > ws_tvb , tvbr - > offset ) ) ;
break ;
}
2013-08-22 11:58:32 +00:00
WSLUA_RETURN ( 1 ) ; /* Length of the zero terminated string */
}
2011-10-02 17:02:10 +00:00
static int TvbRange_ustringz_any ( lua_State * L , gboolean little_endian ) {
/* Obtain a zero terminated string from a TvbRange */
gint count ;
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
2013-12-22 22:19:41 +00:00
gint offset ;
gunichar2 uchar ;
2011-10-02 17:02:10 +00:00
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
2013-12-22 22:19:41 +00:00
offset = tvbr - > offset ;
do {
if ( ! tvb_bytes_exist ( tvbr - > tvb - > ws_tvb , offset , 2 ) ) {
2013-11-21 08:42:21 +00:00
luaL_error ( L , " out of bounds " ) ;
return 0 ;
2013-12-22 22:19:41 +00:00
}
/* Endianness doesn't matter when looking for null */
uchar = tvb_get_ntohs ( tvbr - > tvb - > ws_tvb , offset ) ;
offset + = 2 ;
} while ( uchar ! = 0 ) ;
2013-11-21 08:42:21 +00:00
2013-12-20 20:29:27 +00:00
lua_pushstring ( L , ( gchar * ) tvb_get_stringz_enc ( wmem_packet_scope ( ) , tvbr - > tvb - > ws_tvb , tvbr - > offset , & count , ( little_endian ? ENC_UTF_16 | ENC_LITTLE_ENDIAN : ENC_UTF_16 | ENC_BIG_ENDIAN ) ) ) ;
2011-10-02 17:02:10 +00:00
lua_pushinteger ( L , count ) ;
return 2 ; /* The zero terminated string, the length found in tvbr */
}
WSLUA_METHOD TvbRange_ustringz ( lua_State * L ) {
/* Obtain a Big Endian (network order) UTF-16 encoded zero terminated string from a TvbRange */
WSLUA_RETURN ( TvbRange_ustringz_any ( L , FALSE ) ) ; /* The zero terminated string, the length found in tvbr */
}
WSLUA_METHOD TvbRange_le_ustringz ( lua_State * L ) {
/* Obtain a Little Endian UTF-16 encoded zero terminated string from a TvbRange */
WSLUA_RETURN ( TvbRange_ustringz_any ( L , TRUE ) ) ; /* The zero terminated string, the length found in tvbr */
}
2010-10-21 12:41:15 +00:00
WSLUA_METHOD TvbRange_bytes ( lua_State * L ) {
/* Obtain a ByteArray */
2006-09-25 01:09:00 +00:00
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
GByteArray * ba ;
2007-01-24 01:06:24 +00:00
2008-07-26 23:41:31 +00:00
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
2007-01-24 01:06:24 +00:00
2006-09-25 01:09:00 +00:00
ba = g_byte_array_new ( ) ;
2013-09-22 15:50:55 +00:00
g_byte_array_append ( ba , ( const guint8 * ) tvb_memdup ( wmem_packet_scope ( ) , tvbr - > tvb - > ws_tvb , tvbr - > offset , tvbr - > len ) , tvbr - > len ) ;
2007-01-24 01:06:24 +00:00
2006-09-25 01:09:00 +00:00
pushByteArray ( L , ba ) ;
2007-01-24 01:06:24 +00:00
2009-06-08 08:14:36 +00:00
WSLUA_RETURN ( 1 ) ; /* The ByteArray */
}
2010-10-21 12:41:15 +00:00
WSLUA_METHOD TvbRange_bitfield ( lua_State * L ) {
/* Get a bitfield from a TvbRange. */
2013-02-26 04:42:26 +00:00
# define WSLUA_OPTARG_TvbRange_bitfield_POSITION 2 /* The bit offset from the beginning of the TvbRange. Defaults to 0. */
2009-06-08 08:14:36 +00:00
# define WSLUA_OPTARG_TvbRange_bitfield_LENGTH 3 /* The length (in bits) of the field. Defaults to 1. */
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
int pos = luaL_optint ( L , WSLUA_OPTARG_TvbRange_bitfield_POSITION , 0 ) ;
int len = luaL_optint ( L , WSLUA_OPTARG_TvbRange_bitfield_LENGTH , 1 ) ;
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
if ( ( pos + len ) > ( tvbr - > len < < 3 ) ) {
luaL_error ( L , " Requested bitfield out of range " ) ;
return 0 ;
}
if ( len < = 8 ) {
2014-02-27 04:42:15 +00:00
lua_pushnumber ( L , ( lua_Number ) ( guint ) tvb_get_bits8 ( tvbr - > tvb - > ws_tvb , tvbr - > offset * 8 + pos , len ) ) ;
2009-06-08 08:14:36 +00:00
return 1 ;
} else if ( len < = 16 ) {
lua_pushnumber ( L , tvb_get_bits16 ( tvbr - > tvb - > ws_tvb , tvbr - > offset * 8 + pos , len , FALSE ) ) ;
return 1 ;
} else if ( len < = 32 ) {
lua_pushnumber ( L , tvb_get_bits32 ( tvbr - > tvb - > ws_tvb , tvbr - > offset * 8 + pos , len , FALSE ) ) ;
return 1 ;
} else if ( len < = 64 ) {
2014-02-03 03:49:30 +00:00
pushUInt64 ( L , tvb_get_bits64 ( tvbr - > tvb - > ws_tvb , tvbr - > offset * 8 + pos , len , FALSE ) ) ;
2009-06-08 08:14:36 +00:00
WSLUA_RETURN ( 1 ) ; /* The bitfield value */
} else {
luaL_error ( L , " TvbRange:bitfield() does not handle %d bits " , len ) ;
return 0 ;
}
}
2010-10-21 12:41:15 +00:00
WSLUA_METHOD TvbRange_range ( lua_State * L ) {
/* Creates a sub-TvbRange from this TvbRange. This is used also as the TvbRange:__call() metamethod. */
2013-02-26 04:42:26 +00:00
# define WSLUA_OPTARG_TvbRange_range_OFFSET 2 /* The offset (in octets) from the beginning of the TvbRange. Defaults to 0. */
2009-06-08 08:14:36 +00:00
# define WSLUA_OPTARG_TvbRange_range_LENGTH 3 /* The length (in octets) of the range. Defaults to until the end of the TvbRange. */
2010-10-21 02:50:27 +00:00
2009-06-08 08:14:36 +00:00
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
int offset = luaL_optint ( L , WSLUA_OPTARG_TvbRange_range_OFFSET , 0 ) ;
2012-06-05 15:26:09 +00:00
int len ;
2013-02-26 04:42:26 +00:00
2009-06-08 08:14:36 +00:00
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
2012-06-05 15:26:09 +00:00
len = luaL_optint ( L , WSLUA_OPTARG_TvbRange_range_LENGTH , tvbr - > len - offset ) ;
2009-06-08 08:14:36 +00:00
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
if ( offset > = tvbr - > len | | ( len + offset ) > tvbr - > len ) {
luaL_error ( L , " Range is out of bounds " ) ;
return 0 ;
}
2013-12-19 15:26:31 +00:00
if ( push_TvbRange ( L , tvbr - > tvb - > ws_tvb , tvbr - > offset + offset , len ) ) {
2009-06-08 08:14:36 +00:00
WSLUA_RETURN ( 1 ) ; /* The TvbRange */
}
return 0 ;
2006-09-25 01:09:00 +00:00
}
2013-03-19 17:15:27 +00:00
static int TvbRange_uncompress ( lua_State * L ) {
/* Obtain a uncompressed TvbRange from a TvbRange */
2013-12-19 15:26:31 +00:00
# define WSLUA_ARG_TvbRange_uncompress_NAME 2 /* The name to be given to the new data-source. */
2013-03-19 17:15:27 +00:00
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
2013-12-19 15:26:31 +00:00
const gchar * name = luaL_optstring ( L , WSLUA_ARG_TvbRange_uncompress_NAME , " Uncompressed " ) ;
2013-03-19 17:15:27 +00:00
tvbuff_t * uncompr_tvb ;
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
2014-02-25 20:42:35 +00:00
2013-03-19 17:15:27 +00:00
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
# ifdef HAVE_LIBZ
uncompr_tvb = tvb_child_uncompress ( tvbr - > tvb - > ws_tvb , tvbr - > tvb - > ws_tvb , tvbr - > offset , tvbr - > len ) ;
if ( uncompr_tvb ) {
add_new_data_source ( lua_pinfo , uncompr_tvb , name ) ;
2013-12-19 15:26:31 +00:00
if ( push_TvbRange ( L , uncompr_tvb , 0 , tvb_length ( uncompr_tvb ) ) ) {
2013-03-19 17:15:27 +00:00
WSLUA_RETURN ( 1 ) ; /* The TvbRange */
}
}
# else
luaL_error ( L , " Missing support for ZLIB " ) ;
# endif
return 0 ;
}
2013-02-25 22:05:28 +00:00
/* Gets registered as metamethod automatically by WSLUA_REGISTER_CLASS/META */
2011-11-06 17:39:13 +00:00
static int TvbRange__gc ( lua_State * L ) {
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
free_TvbRange ( tvbr ) ;
return 0 ;
}
2010-10-21 12:41:15 +00:00
WSLUA_METHOD TvbRange_len ( lua_State * L ) {
/* Obtain the length of a TvbRange */
2008-10-31 18:14:47 +00:00
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
2011-11-06 17:39:13 +00:00
lua_pushnumber ( L , ( lua_Number ) tvbr - > len ) ;
return 1 ;
2008-10-31 18:14:47 +00:00
}
2010-10-21 12:41:15 +00:00
WSLUA_METHOD TvbRange_offset ( lua_State * L ) {
/* Obtain the offset in a TvbRange */
2008-10-31 18:14:47 +00:00
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
2011-11-06 17:39:13 +00:00
lua_pushnumber ( L , ( lua_Number ) tvbr - > offset ) ;
return 1 ;
2008-10-31 18:14:47 +00:00
}
2014-02-18 15:03:04 +00:00
WSLUA_METHOD TvbRange_raw ( lua_State * L ) {
/* Obtain a Lua string of the binary bytes in a TvbRange. */
# define WSLUA_OPTARG_TvbRange_raw_OFFSET 2 /* The position of the first byte (default=0/first). */
# define WSLUA_OPTARG_TvbRange_raw_LENGTH 3 /* The length of the segment to get (default=all). */
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
int offset = luaL_optint ( L , WSLUA_OPTARG_TvbRange_raw_OFFSET , 0 ) ;
int len = luaL_optint ( L , WSLUA_OPTARG_TvbRange_raw_LENGTH , - 1 ) ;
if ( ! tvbr | | ! tvbr - > tvb ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
2014-02-27 04:42:15 +00:00
if ( ( guint ) offset > tvb_length ( tvbr - > tvb - > ws_tvb ) ) {
2014-02-18 15:03:04 +00:00
WSLUA_OPTARG_ERROR ( Tvb_raw , OFFSET , " offset beyond end of Tvb " ) ;
2014-02-27 04:42:15 +00:00
return 0 ;
}
2014-02-18 15:03:04 +00:00
if ( len = = - 1 ) {
len = tvb_length_remaining ( tvbr - > tvb - > ws_tvb , offset ) ;
if ( len < 0 ) {
luaL_error ( L , " out of bounds " ) ;
return FALSE ;
}
} else if ( ( guint ) ( len + offset ) > tvb_length ( tvbr - > tvb - > ws_tvb ) ) {
luaL_error ( L , " Range is out of bounds " ) ;
return FALSE ;
}
lua_pushlstring ( L , tvb_get_ptr ( tvbr - > tvb - > ws_tvb , offset , len ) , len ) ;
WSLUA_RETURN ( 1 ) ; /* A Lua string of the binary bytes in the TvbRange. */
}
2008-10-31 18:14:47 +00:00
2010-10-21 12:41:15 +00:00
WSLUA_METAMETHOD TvbRange__tostring ( lua_State * L ) {
/* Converts the TvbRange into a string. As the string gets truncated
you should use this only for debugging purposes
or if what you want is to have a truncated string in the format 67 : 89 : AB : . . . */
2006-09-25 01:09:00 +00:00
TvbRange tvbr = checkTvbRange ( L , 1 ) ;
2008-07-26 23:41:31 +00:00
if ( ! ( tvbr & & tvbr - > tvb ) ) return 0 ;
if ( tvbr - > tvb - > expired ) {
luaL_error ( L , " expired tvb " ) ;
return 0 ;
}
2007-01-24 01:06:24 +00:00
2013-12-19 15:49:09 +00:00
lua_pushstring ( L , tvb_bytes_to_ep_str ( tvbr - > tvb - > ws_tvb , tvbr - > offset , tvbr - > len ) ) ;
2006-09-25 01:09:00 +00:00
return 1 ;
}
2014-02-19 08:22:55 +00:00
WSLUA_METHODS TvbRange_methods [ ] = {
WSLUA_CLASS_FNREG ( TvbRange , uint ) ,
WSLUA_CLASS_FNREG ( TvbRange , le_uint ) ,
WSLUA_CLASS_FNREG ( TvbRange , int ) ,
WSLUA_CLASS_FNREG ( TvbRange , le_int ) ,
WSLUA_CLASS_FNREG ( TvbRange , uint64 ) ,
WSLUA_CLASS_FNREG ( TvbRange , le_uint64 ) ,
WSLUA_CLASS_FNREG ( TvbRange , int64 ) ,
WSLUA_CLASS_FNREG ( TvbRange , le_int64 ) ,
WSLUA_CLASS_FNREG ( TvbRange , float ) ,
WSLUA_CLASS_FNREG ( TvbRange , le_float ) ,
WSLUA_CLASS_FNREG ( TvbRange , ether ) ,
WSLUA_CLASS_FNREG ( TvbRange , ipv4 ) ,
WSLUA_CLASS_FNREG ( TvbRange , le_ipv4 ) ,
WSLUA_CLASS_FNREG ( TvbRange , nstime ) ,
WSLUA_CLASS_FNREG ( TvbRange , le_nstime ) ,
WSLUA_CLASS_FNREG ( TvbRange , string ) ,
WSLUA_CLASS_FNREG ( TvbRange , stringz ) ,
WSLUA_CLASS_FNREG ( TvbRange , strsize ) ,
WSLUA_CLASS_FNREG ( TvbRange , bytes ) ,
WSLUA_CLASS_FNREG ( TvbRange , bitfield ) ,
WSLUA_CLASS_FNREG ( TvbRange , range ) ,
WSLUA_CLASS_FNREG ( TvbRange , len ) ,
WSLUA_CLASS_FNREG ( TvbRange , offset ) ,
WSLUA_CLASS_FNREG ( TvbRange , tvb ) ,
WSLUA_CLASS_FNREG ( TvbRange , le_ustring ) ,
WSLUA_CLASS_FNREG ( TvbRange , ustring ) ,
WSLUA_CLASS_FNREG ( TvbRange , le_ustringz ) ,
WSLUA_CLASS_FNREG ( TvbRange , ustringz ) ,
WSLUA_CLASS_FNREG ( TvbRange , uncompress ) ,
2014-02-18 15:03:04 +00:00
WSLUA_CLASS_FNREG ( TvbRange , raw ) ,
2008-04-25 18:59:20 +00:00
{ NULL , NULL }
2006-09-25 01:09:00 +00:00
} ;
2014-02-19 08:22:55 +00:00
WSLUA_META TvbRange_meta [ ] = {
WSLUA_CLASS_MTREG ( TvbRange , tostring ) ,
WSLUA_CLASS_MTREG ( wslua , concat ) ,
2009-06-08 08:14:36 +00:00
{ " __call " , TvbRange_range } ,
2008-04-25 18:59:20 +00:00
{ NULL , NULL }
2006-09-25 01:09:00 +00:00
} ;
2010-10-21 12:41:15 +00:00
int TvbRange_register ( lua_State * L ) {
2008-07-26 23:41:31 +00:00
outstanding_Tvb = g_ptr_array_new ( ) ;
outstanding_TvbRange = g_ptr_array_new ( ) ;
2006-09-25 01:09:00 +00:00
WSLUA_REGISTER_CLASS ( TvbRange ) ;
2014-01-31 07:25:42 +00:00
return 0 ;
2006-09-25 01:09:00 +00:00
}
2008-09-16 14:37:00 +00:00