/* Everytime the dissector has finished dissecting a packet (and all
subdissectors have returned) and if the dissector has been made "tappable"
it will push some data to everyone tapping this layer by a call
to tap_queue_packet().
The first parameter is the tap_id returned by the register_tap()
call for this dissector (so the tap system can keep track of who it came
from and who is listening to it)
The second is the packet_info structure which many tap readers will find
interesting.
The third argument is specific to each tap point or NULL if no additional
data is available to this tap. A tap point in say IP will probably want to
push the IP header structure here. Same thing for TCP and ONCRPC.
The pinfo and the specific pointer are what is supplied to every listener
in the read_callback() call made to every one currently listening to this
tap.
The tap reader is responsible to know how to parse any structure pointed
to by the tap specific data pointer.
*/
void
tap_queue_packet(int tap_id, packet_info *pinfo, const void *tap_specific_data)
{
tap_packet_t *tpt;
if(!tapping_is_active){
return;
}
/*
* XXX - should we allocate this with an ep_allocator,
* rather than having a fixed maximum number of entries?
*/
if(tap_packet_index >= TAP_PACKET_QUEUE_LEN){
ws_g_warning("Too many taps queued");
return;
}
tpt=&tap_packet_array[tap_packet_index];
tpt->tap_id=tap_id;
tpt->flags = 0;
if (pinfo->flags.in_error_pkt)
tpt->flags |= TAP_PACKET_IS_ERROR_PACKET;
tpt->pinfo=pinfo;
tpt->tap_specific_data=tap_specific_data;
tap_packet_index++;
}
/* The classic wtap dump_open function.
* This returns 1 (TRUE) on success.
*/
static int
wslua_filehandler_dump_open(wtap_dumper *wdh, int *err)
{
FileHandler fh = (FileHandler)(wdh->wslua_data);
int retval = 0;
lua_State* L = NULL;
File *fp = NULL;
CaptureInfoConst *fc = NULL;
INIT_FILEHANDLER_ROUTINE(write_open,0);
create_wdh_priv(L, wdh);
fp = push_Wdh(L, wdh);
fc = push_CaptureInfoConst(L,wdh);
/* Reset err */
if (err) {
*err = 0;
}
switch ( lua_pcall(L,2,1,1) ) {
case 0:
retval = wslua_optboolint(L,-1,0);
break;
CASE_ERROR("write_open")
}
END_FILEHANDLER_ROUTINE();
(*fp)->expired = TRUE;
(*fc)->expired = TRUE;
if (retval == 1) {
/* this is our file type - set the routines and settings into wtap */
if (fh->write_ref != LUA_NOREF) {
wdh->subtype_write = wslua_filehandler_dump;
}
else {
ws_g_warning("FileHandler was not set with a write function, even though write_open() returned true");
return 0;
}
/* it's ok to not have a finish routine */
if (fh->write_close_ref != LUA_NOREF)
wdh->subtype_finish = wslua_filehandler_dump_finish;
else
wdh->subtype_finish = NULL;
}
else {
/* not our file type? */
remove_wdh_priv(L, wdh);
}
return retval;
}
const nstime_t *
epan_get_frame_ts(const epan_t *session, guint32 frame_num)
{
const nstime_t *abs_ts = NULL;
if (session->get_frame_ts)
abs_ts = session->get_frame_ts(session->data, frame_num);
if (!abs_ts)
ws_g_warning("!!! couldn't get frame ts for %u !!!\n", frame_num);
return abs_ts;
}
/* Initializes an extended value string. Behaves like a match function to
* permit lazy initialization of extended value strings.
* - Goes through the value_string array to determine the fastest possible
* access method.
* - Verifies that the value_string contains no NULL string pointers.
* - Verifies that the value_string is terminated by {0, NULL}
*/
const value_string *
_try_val_to_str_ext_init(const guint32 val, value_string_ext *vse)
{
const value_string *vs_p = vse->_vs_p;
const guint vs_num_entries = vse->_vs_num_entries;
/* The matching algorithm used:
* VS_SEARCH - slow sequential search (as in a normal value string)
* VS_BIN_TREE - log(n)-time binary search, the values must be sorted
* VS_INDEX - constant-time index lookup, the values must be contiguous
*/
enum { VS_SEARCH, VS_BIN_TREE, VS_INDEX } type = VS_INDEX;
/* Note: The value_string 'value' is *unsigned*, but we do a little magic
* to help with value strings that have negative values.
*
* { -3, -2, -1, 0, 1, 2 }
* will be treated as "ascending ordered" (although it isn't technically),
* thus allowing constant-time index search
*
* { -3, -2, 0, 1, 2 } and { -3, -2, -1, 0, 2 }
* will both be considered as "out-of-order with gaps", thus falling
* back to the slow linear search
*
* { 0, 1, 2, -3, -2 } and { 0, 2, -3, -2, -1 }
* will be considered "ascending ordered with gaps" thus allowing
* a log(n)-time 'binary' search
*
* If you're confused, think of how negative values are represented, or
* google two's complement.
*/
guint32 prev_value;
guint first_value;
guint i;
DISSECTOR_ASSERT((vs_p[vs_num_entries].value == 0) &&
(vs_p[vs_num_entries].strptr == NULL));
vse->_vs_first_value = vs_p[0].value;
first_value = vs_p[0].value;
prev_value = first_value;
for (i = 0; i < vs_num_entries; i++) {
DISSECTOR_ASSERT(vs_p[i].strptr != NULL);
if ((type == VS_INDEX) && (vs_p[i].value != (i + first_value))) {
type = VS_BIN_TREE;
}
/* XXX: Should check for dups ?? */
if (type == VS_BIN_TREE) {
if (prev_value > vs_p[i].value) {
ws_g_warning("Extended value string '%s' forced to fall back to linear search:\n"
" entry %u, value %u [%#x] < previous entry, value %u [%#x]",
vse->_vs_name, i, vs_p[i].value, vs_p[i].value, prev_value, prev_value);
type = VS_SEARCH;
break;
}
if (first_value > vs_p[i].value) {
ws_g_warning("Extended value string '%s' forced to fall back to linear search:\n"
" entry %u, value %u [%#x] < first entry, value %u [%#x]",
vse->_vs_name, i, vs_p[i].value, vs_p[i].value, first_value, first_value);
type = VS_SEARCH;
break;
}
}
prev_value = vs_p[i].value;
}
switch (type) {
case VS_SEARCH:
vse->_vs_match2 = _try_val_to_str_linear;
break;
case VS_BIN_TREE:
vse->_vs_match2 = _try_val_to_str_bsearch;
break;
case VS_INDEX:
vse->_vs_match2 = _try_val_to_str_index;
break;
default:
g_assert_not_reached();
break;
}
return vse->_vs_match2(val, vse);
}
/* XXX - Would it make more sense to use GStrings here instead of reallocing
our buffers? */
static int
read_filters_file(const gchar *path, FILE *f, gpointer user_data, color_filter_add_cb_func add_cb)
{
#define INIT_BUF_SIZE 128
gchar *name = NULL;
gchar *filter_exp = NULL;
guint32 name_len = INIT_BUF_SIZE;
guint32 filter_exp_len = INIT_BUF_SIZE;
guint32 i = 0;
int c;
guint16 fg_r, fg_g, fg_b, bg_r, bg_g, bg_b;
gboolean disabled = FALSE;
gboolean skip_end_of_line = FALSE;
int ret = 0;
name = (gchar *)g_malloc(name_len + 1);
filter_exp = (gchar *)g_malloc(filter_exp_len + 1);
while (1) {
if (skip_end_of_line) {
do {
c = ws_getc_unlocked(f);
} while (c != EOF && c != '\n');
if (c == EOF)
break;
disabled = FALSE;
skip_end_of_line = FALSE;
}
while ((c = ws_getc_unlocked(f)) != EOF && g_ascii_isspace(c)) {
if (c == '\n') {
continue;
}
}
if (c == EOF)
break;
if (c == '!') {
disabled = TRUE;
continue;
}
/* skip # comments and invalid lines */
if (c != '@') {
skip_end_of_line = TRUE;
continue;
}
/* we get the @ delimiter.
* Format is:
* @name@filter expression@[background r,g,b][foreground r,g,b]
*/
/* retrieve name */
i = 0;
while (1) {
c = ws_getc_unlocked(f);
if (c == EOF || c == '@')
break;
if (i >= name_len) {
/* buffer isn't long enough; double its length.*/
name_len *= 2;
name = (gchar *)g_realloc(name, name_len + 1);
}
name[i++] = c;
}
name[i] = '\0';
if (c == EOF) {
break;
} else if (i == 0) {
skip_end_of_line = TRUE;
continue;
}
/* retrieve filter expression */
i = 0;
while (1) {
c = ws_getc_unlocked(f);
if (c == EOF || c == '@')
break;
if (i >= filter_exp_len) {
/* buffer isn't long enough; double its length.*/
filter_exp_len *= 2;
filter_exp = (gchar *)g_realloc(filter_exp, filter_exp_len + 1);
}
filter_exp[i++] = c;
}
filter_exp[i] = '\0';
if (c == EOF) {
break;
} else if (i == 0) {
skip_end_of_line = TRUE;
continue;
}
/* retrieve background and foreground colors */
if (fscanf(f,"[%hu,%hu,%hu][%hu,%hu,%hu]",
&bg_r, &bg_g, &bg_b, &fg_r, &fg_g, &fg_b) == 6) {
/* we got a complete color filter */
color_t bg_color, fg_color;
color_filter_t *colorf;
dfilter_t *temp_dfilter = NULL;
gchar *local_err_msg = NULL;
if (!disabled && !dfilter_compile(filter_exp, &temp_dfilter, &local_err_msg)) {
ws_g_warning("Could not compile \"%s\" in colorfilters file \"%s\".\n%s",
name, path, local_err_msg);
g_free(local_err_msg);
prefs.unknown_colorfilters = TRUE;
/* skip_end_of_line = TRUE; */
disabled = TRUE;
}
fg_color.red = fg_r;
fg_color.green = fg_g;
fg_color.blue = fg_b;
bg_color.red = bg_r;
bg_color.green = bg_g;
bg_color.blue = bg_b;
colorf = color_filter_new(name, filter_exp, &bg_color,
&fg_color, disabled);
if(user_data == &color_filter_list) {
GSList **cfl = (GSList **)user_data;
/* internal call */
colorf->c_colorfilter = temp_dfilter;
*cfl = g_slist_append(*cfl, colorf);
} else {
/* external call */
/* just editing, don't need the compiled filter */
dfilter_free(temp_dfilter);
add_cb(colorf, user_data);
}
} /* if sscanf */
skip_end_of_line = TRUE;
}
if (ferror(f))
ret = errno;
g_free(name);
g_free(filter_exp);
return ret;
}
/* This is our one-and-only open routine for file handling. When called by
* file_access.c, the wtap wth argument has a void* wslua_data that holds the specific
* FileHandler for the specific registered file format reader. It has this because
* we passed it in when we registered the open routine.
* The open_file_* routines should return:
* -1 on an I/O error;
* 1 if the file they're reading is one of the types it handles;
* 0 if the file they're reading isn't the type they're checking for.
* If the routine handles this type of file, it should set the "file_type"
* field in the "struct wtap" to the type of the file.
*/
static wtap_open_return_val
wslua_filehandler_open(wtap *wth, int *err, gchar **err_info)
{
FileHandler fh = (FileHandler)(wth->wslua_data);
wtap_open_return_val retval = WTAP_OPEN_NOT_MINE;
lua_State* L = NULL;
File *fp = NULL;
CaptureInfo *fc = NULL;
INIT_FILEHANDLER_ROUTINE(read_open,WTAP_OPEN_NOT_MINE);
create_wth_priv(L, wth);
fp = push_File(L, wth->fh);
fc = push_CaptureInfo(L, wth, TRUE);
errno = WTAP_ERR_CANT_OPEN;
switch ( lua_pcall(L,2,1,1) ) {
case 0:
retval = (wtap_open_return_val)wslua_optboolint(L,-1,0);
break;
CASE_ERROR_ERRINFO("read_open")
}
END_FILEHANDLER_ROUTINE();
(*fp)->expired = TRUE;
(*fc)->expired = TRUE;
if (retval == WTAP_OPEN_MINE) {
/* this is our file type - set the routines and settings into wtap */
if (fh->read_ref != LUA_NOREF) {
wth->subtype_read = wslua_filehandler_read;
}
else {
ws_g_warning("Lua file format module lacks a read routine");
return WTAP_OPEN_NOT_MINE;
}
if (fh->seek_read_ref != LUA_NOREF) {
wth->subtype_seek_read = wslua_filehandler_seek_read;
}
else {
ws_g_warning("Lua file format module lacks a seek-read routine");
return WTAP_OPEN_NOT_MINE;
}
/* it's ok to not have a close routine */
if (fh->read_close_ref != LUA_NOREF)
wth->subtype_close = wslua_filehandler_close;
else
wth->subtype_close = NULL;
/* it's ok to not have a sequential close routine */
if (fh->seq_read_close_ref != LUA_NOREF)
wth->subtype_sequential_close = wslua_filehandler_sequential_close;
else
wth->subtype_sequential_close = NULL;
wth->file_type_subtype = fh->file_type;
}
else if (retval == WTAP_OPEN_ERROR) {
/* open error - we *must* return an error code! */
if (err) {
*err = WTAP_ERR_CANT_OPEN;
}
}
else if (retval == WTAP_OPEN_NOT_MINE) {
/* not our file type */
remove_wth_priv(L, wth);
}
else {
/* not a valid return type */
ws_g_warning("FileHandler read_open routine returned %d", retval);
if (err) {
*err = WTAP_ERR_INTERNAL;
}
retval = WTAP_OPEN_ERROR;
}
lua_settop(L,0);
return retval;
}
