2001-04-01 07:32:35 +00:00
|
|
|
/* column-utils.c
|
|
|
|
* Routines for column utilities.
|
|
|
|
*
|
2006-05-21 05:12:17 +00:00
|
|
|
* Wireshark - Network traffic analyzer
|
|
|
|
* By Gerald Combs <gerald@wireshark.org>
|
2001-04-01 07:32:35 +00:00
|
|
|
* Copyright 1998 Gerald Combs
|
2002-08-28 20:41:00 +00:00
|
|
|
*
|
2001-04-01 07:32:35 +00:00
|
|
|
* 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.
|
2002-08-28 20:41:00 +00:00
|
|
|
*
|
2001-04-01 07:32:35 +00:00
|
|
|
* 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.
|
2002-08-28 20:41:00 +00:00
|
|
|
*
|
2001-04-01 07:32:35 +00:00
|
|
|
* 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.
|
2001-04-01 07:32:35 +00:00
|
|
|
*/
|
|
|
|
|
2012-09-20 01:48:30 +00:00
|
|
|
#include "config.h"
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2001-04-02 02:30:06 +00:00
|
|
|
#include <string.h>
|
|
|
|
#include <time.h>
|
|
|
|
|
2001-04-01 07:32:35 +00:00
|
|
|
#include "column-utils.h"
|
|
|
|
#include "timestamp.h"
|
|
|
|
#include "sna-utils.h"
|
|
|
|
#include "atalk-utils.h"
|
|
|
|
#include "to_str.h"
|
|
|
|
#include "packet_info.h"
|
2013-08-01 23:34:47 +00:00
|
|
|
#include "wsutil/pint.h"
|
2004-08-06 19:57:49 +00:00
|
|
|
#include "addr_resolv.h"
|
2002-08-28 20:41:00 +00:00
|
|
|
#include "ipv6-utils.h"
|
2001-04-01 07:32:35 +00:00
|
|
|
#include "osi-utils.h"
|
2002-12-10 01:17:21 +00:00
|
|
|
#include "value_string.h"
|
2013-10-18 13:06:05 +00:00
|
|
|
#include "column-info.h"
|
2012-10-26 01:59:17 +00:00
|
|
|
#include "proto.h"
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2007-10-26 05:42:12 +00:00
|
|
|
#include <epan/strutil.h>
|
2013-09-13 08:16:50 +00:00
|
|
|
#include <epan/emem.h>
|
2008-02-13 05:05:33 +00:00
|
|
|
#include <epan/epan.h>
|
|
|
|
|
2001-04-01 07:32:35 +00:00
|
|
|
/* Allocate all the data structures for constructing column data, given
|
|
|
|
the number of columns. */
|
|
|
|
void
|
2010-04-03 18:18:50 +00:00
|
|
|
col_setup(column_info *cinfo, const gint num_cols)
|
2001-04-01 07:32:35 +00:00
|
|
|
{
|
2003-12-02 23:14:32 +00:00
|
|
|
int i;
|
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
cinfo->num_cols = num_cols;
|
|
|
|
cinfo->col_fmt = g_new(gint, num_cols);
|
|
|
|
cinfo->fmt_matx = g_new(gboolean*, num_cols);
|
|
|
|
cinfo->col_first = g_new(int, NUM_COL_FMTS);
|
|
|
|
cinfo->col_last = g_new(int, NUM_COL_FMTS);
|
|
|
|
cinfo->col_title = g_new(gchar*, num_cols);
|
|
|
|
cinfo->col_custom_field = g_new(gchar*, num_cols);
|
2010-09-22 20:56:14 +00:00
|
|
|
cinfo->col_custom_occurrence = g_new(gint, num_cols);
|
2013-06-25 19:38:15 +00:00
|
|
|
cinfo->col_custom_field_id = g_new(int, num_cols);
|
2013-12-03 21:31:04 +00:00
|
|
|
cinfo->col_custom_dfilter = g_new(struct epan_dfilter*, num_cols);
|
2013-07-16 02:34:44 +00:00
|
|
|
cinfo->col_data = g_new(const gchar*, num_cols);
|
2013-06-25 19:38:15 +00:00
|
|
|
cinfo->col_buf = g_new(gchar*, num_cols);
|
|
|
|
cinfo->col_fence = g_new(int, num_cols);
|
2013-07-16 02:34:44 +00:00
|
|
|
cinfo->col_expr.col_expr = g_new(const gchar*, num_cols + 1);
|
2009-07-22 05:02:24 +00:00
|
|
|
cinfo->col_expr.col_expr_val = g_new(gchar*, num_cols + 1);
|
2003-12-02 23:14:32 +00:00
|
|
|
|
|
|
|
for (i = 0; i < NUM_COL_FMTS; i++) {
|
2005-10-02 14:56:27 +00:00
|
|
|
cinfo->col_first[i] = -1;
|
|
|
|
cinfo->col_last[i] = -1;
|
2003-12-02 23:14:32 +00:00
|
|
|
}
|
2001-04-01 07:32:35 +00:00
|
|
|
}
|
|
|
|
|
2012-10-08 17:04:37 +00:00
|
|
|
/* Cleanup all the data structures for constructing column data; undoes
|
|
|
|
the allocations that col_setup() does. */
|
|
|
|
void
|
|
|
|
col_cleanup(column_info *cinfo)
|
|
|
|
{
|
|
|
|
g_free(cinfo->col_fmt);
|
|
|
|
g_free(cinfo->fmt_matx);
|
|
|
|
g_free(cinfo->col_first);
|
|
|
|
g_free(cinfo->col_last);
|
|
|
|
g_free(cinfo->col_title);
|
|
|
|
g_free(cinfo->col_custom_field);
|
|
|
|
g_free(cinfo->col_custom_occurrence);
|
|
|
|
g_free(cinfo->col_custom_field_id);
|
|
|
|
g_free(cinfo->col_custom_dfilter);
|
|
|
|
/*
|
|
|
|
* XXX - MSVC doesn't correctly handle the "const" qualifier; it thinks
|
|
|
|
* "const XXX **" means "pointer to const pointer to XXX", i.e. that
|
|
|
|
* it's a pointer to something that's "const"ant, not "pointer to
|
|
|
|
* pointer to const XXX", i.e. that it's a pointer to a pointer to
|
|
|
|
* something that's "const"ant. Cast its bogus complaints away.
|
|
|
|
*/
|
|
|
|
g_free((gchar **)cinfo->col_data);
|
|
|
|
g_free(cinfo->col_buf);
|
|
|
|
g_free(cinfo->col_fence);
|
|
|
|
/* XXX - see above */
|
|
|
|
g_free((gchar **)cinfo->col_expr.col_expr);
|
|
|
|
g_free(cinfo->col_expr.col_expr_val);
|
|
|
|
}
|
|
|
|
|
2003-04-16 05:55:41 +00:00
|
|
|
/* Initialize the data structures for constructing column data. */
|
|
|
|
void
|
2013-07-21 20:48:30 +00:00
|
|
|
col_init(column_info *cinfo, const struct epan_session *epan)
|
2003-04-16 05:55:41 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2009-08-22 19:29:44 +00:00
|
|
|
if (!cinfo)
|
|
|
|
return;
|
|
|
|
|
2003-04-16 05:55:41 +00:00
|
|
|
for (i = 0; i < cinfo->num_cols; i++) {
|
|
|
|
cinfo->col_buf[i][0] = '\0';
|
|
|
|
cinfo->col_data[i] = cinfo->col_buf[i];
|
|
|
|
cinfo->col_fence[i] = 0;
|
2009-08-19 07:55:11 +00:00
|
|
|
cinfo->col_expr.col_expr[i] = "";
|
2008-03-01 05:16:45 +00:00
|
|
|
cinfo->col_expr.col_expr_val[i][0] = '\0';
|
2003-04-16 05:55:41 +00:00
|
|
|
}
|
|
|
|
cinfo->writable = TRUE;
|
2013-07-21 20:48:30 +00:00
|
|
|
cinfo->epan = epan;
|
2003-04-16 05:55:41 +00:00
|
|
|
}
|
|
|
|
|
2009-09-06 09:03:15 +00:00
|
|
|
#define COL_GET_WRITABLE(cinfo) (cinfo ? cinfo->writable : FALSE)
|
|
|
|
|
2001-04-01 07:32:35 +00:00
|
|
|
gboolean
|
2001-12-10 00:26:21 +00:00
|
|
|
col_get_writable(column_info *cinfo)
|
2001-04-01 07:32:35 +00:00
|
|
|
{
|
2013-06-25 19:38:15 +00:00
|
|
|
return COL_GET_WRITABLE(cinfo);
|
2001-04-01 07:32:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-04-03 18:18:50 +00:00
|
|
|
col_set_writable(column_info *cinfo, const gboolean writable)
|
2001-04-01 07:32:35 +00:00
|
|
|
{
|
2013-06-25 19:38:15 +00:00
|
|
|
if (cinfo)
|
|
|
|
cinfo->writable = writable;
|
2001-04-01 07:32:35 +00:00
|
|
|
}
|
|
|
|
|
2009-09-06 09:03:15 +00:00
|
|
|
/* Checks to see if a particular packet information element is needed for the packet list */
|
|
|
|
#define CHECK_COL(cinfo, el) \
|
|
|
|
/* We are constructing columns, and they're writable */ \
|
|
|
|
(COL_GET_WRITABLE(cinfo) && \
|
|
|
|
/* There is at least one column in that format */ \
|
|
|
|
((cinfo)->col_first[el] >= 0))
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2003-04-16 04:52:55 +00:00
|
|
|
/* Sets the fence for a column to be at the end of the column. */
|
|
|
|
void
|
2010-04-03 18:18:50 +00:00
|
|
|
col_set_fence(column_info *cinfo, const gint el)
|
2003-04-16 04:52:55 +00:00
|
|
|
{
|
|
|
|
int i;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2009-09-06 09:03:15 +00:00
|
|
|
if (!CHECK_COL(cinfo, el))
|
2009-03-20 12:41:03 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) {
|
|
|
|
if (cinfo->fmt_matx[i][el]) {
|
2009-04-07 16:36:52 +00:00
|
|
|
cinfo->col_fence[i] = (int)strlen(cinfo->col_data[i]);
|
2003-04-16 04:52:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2013-12-18 14:18:45 +00:00
|
|
|
/* Clear the fence for a column. */
|
|
|
|
void
|
|
|
|
col_clear_fence(column_info *cinfo, const gint el)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!CHECK_COL(cinfo, el))
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) {
|
|
|
|
if (cinfo->fmt_matx[i][el]) {
|
|
|
|
cinfo->col_fence[i] = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-25 20:43:06 +00:00
|
|
|
/* Gets the text of a column */
|
|
|
|
const gchar *
|
|
|
|
col_get_text(column_info *cinfo, const gint el)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
const gchar* text = NULL;
|
|
|
|
|
|
|
|
if (!(cinfo && (cinfo)->col_first[el] >= 0)) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) {
|
|
|
|
if (cinfo->fmt_matx[i][el]) {
|
|
|
|
text = (cinfo->col_data[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return text;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-04-01 07:32:35 +00:00
|
|
|
/* Use this to clear out a column, especially if you're going to be
|
|
|
|
appending to it later; at least on some platforms, it's more
|
|
|
|
efficient than using "col_add_str()" with a null string, and
|
|
|
|
more efficient than "col_set_str()" with a null string if you
|
|
|
|
later append to it, as the later append will cause a string
|
|
|
|
copy to be done. */
|
|
|
|
void
|
2010-04-03 18:18:50 +00:00
|
|
|
col_clear(column_info *cinfo, const gint el)
|
2003-04-16 04:52:55 +00:00
|
|
|
{
|
2001-04-01 07:32:35 +00:00
|
|
|
int i;
|
2003-04-16 04:52:55 +00:00
|
|
|
int fence;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2009-09-06 09:03:15 +00:00
|
|
|
if (!CHECK_COL(cinfo, el))
|
2009-03-20 12:41:03 +00:00
|
|
|
return;
|
|
|
|
|
2003-12-02 23:14:32 +00:00
|
|
|
for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) {
|
2001-12-10 00:26:21 +00:00
|
|
|
if (cinfo->fmt_matx[i][el]) {
|
2003-04-16 04:52:55 +00:00
|
|
|
/*
|
|
|
|
* At this point, either
|
|
|
|
*
|
|
|
|
* 1) col_data[i] is equal to col_buf[i], in which case we
|
|
|
|
* don't have to worry about copying col_data[i] to
|
|
|
|
* col_buf[i];
|
|
|
|
*
|
|
|
|
* 2) col_data[i] isn't equal to col_buf[i], in which case
|
|
|
|
* the only thing that's been done to the column is
|
|
|
|
* "col_set_str()" calls and possibly "col_set_fence()"
|
|
|
|
* calls, in which case the fence is either unset and
|
|
|
|
* at the beginning of the string or set and at the end
|
|
|
|
* of the string - if it's at the beginning, we're just
|
|
|
|
* going to clear the column, and if it's at the end,
|
|
|
|
* we don't do anything.
|
|
|
|
*/
|
|
|
|
fence = cinfo->col_fence[i];
|
2009-09-23 14:30:36 +00:00
|
|
|
if (cinfo->col_buf[i] == cinfo->col_data[i] || fence == 0) {
|
2003-04-16 04:52:55 +00:00
|
|
|
/*
|
|
|
|
* The fence isn't at the end of the column, or the column wasn't
|
|
|
|
* last set with "col_set_str()", so clear the column out.
|
|
|
|
*/
|
|
|
|
cinfo->col_buf[i][fence] = '\0';
|
|
|
|
cinfo->col_data[i] = cinfo->col_buf[i];
|
|
|
|
}
|
2009-08-19 07:55:11 +00:00
|
|
|
cinfo->col_expr.col_expr[i] = "";
|
2008-03-01 05:16:45 +00:00
|
|
|
cinfo->col_expr.col_expr_val[i][0] = '\0';
|
2001-04-01 07:32:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-04-16 04:52:55 +00:00
|
|
|
#define COL_CHECK_APPEND(cinfo, i, max_len) \
|
2009-08-22 19:29:44 +00:00
|
|
|
if (cinfo->col_data[i] != cinfo->col_buf[i]) { \
|
|
|
|
/* This was set with "col_set_str()"; copy the string they \
|
|
|
|
set it to into the buffer, so we can append to it. */ \
|
|
|
|
g_strlcpy(cinfo->col_buf[i], cinfo->col_data[i], max_len); \
|
|
|
|
cinfo->col_data[i] = cinfo->col_buf[i]; \
|
2003-04-16 04:52:55 +00:00
|
|
|
}
|
|
|
|
|
2009-09-08 15:55:10 +00:00
|
|
|
#define COL_CHECK_REF_TIME(fd, buf) \
|
2013-06-25 19:38:15 +00:00
|
|
|
if (fd->flags.ref_time) { \
|
2009-08-22 19:29:44 +00:00
|
|
|
g_strlcpy(buf, "*REF*", COL_MAX_LEN ); \
|
2009-09-08 15:55:10 +00:00
|
|
|
return; \
|
2005-08-31 21:38:08 +00:00
|
|
|
}
|
|
|
|
|
2009-09-06 09:11:17 +00:00
|
|
|
/* The same as CHECK_COL(), but without the check to see if the column is writable. */
|
|
|
|
#define HAVE_CUSTOM_COLS(cinfo) ((cinfo) && (cinfo)->col_first[COL_CUSTOM] >= 0)
|
|
|
|
|
|
|
|
gboolean
|
|
|
|
have_custom_cols(column_info *cinfo)
|
|
|
|
{
|
|
|
|
return HAVE_CUSTOM_COLS(cinfo);
|
|
|
|
}
|
|
|
|
|
2009-08-25 21:10:35 +00:00
|
|
|
/* search in edt tree custom fields */
|
|
|
|
void col_custom_set_edt(epan_dissect_t *edt, column_info *cinfo)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
if (!HAVE_CUSTOM_COLS(cinfo))
|
2009-08-25 21:10:35 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = cinfo->col_first[COL_CUSTOM];
|
|
|
|
i <= cinfo->col_last[COL_CUSTOM]; i++) {
|
2009-10-08 16:35:58 +00:00
|
|
|
if (cinfo->fmt_matx[i][COL_CUSTOM] &&
|
|
|
|
cinfo->col_custom_field[i] &&
|
|
|
|
cinfo->col_custom_field_id[i] != -1) {
|
|
|
|
cinfo->col_data[i] = cinfo->col_buf[i];
|
2009-09-08 10:33:15 +00:00
|
|
|
cinfo->col_expr.col_expr[i] = epan_custom_set(edt, cinfo->col_custom_field_id[i],
|
2010-09-22 20:56:14 +00:00
|
|
|
cinfo->col_custom_occurrence[i],
|
2009-08-25 21:10:35 +00:00
|
|
|
cinfo->col_buf[i],
|
2009-09-06 09:03:15 +00:00
|
|
|
cinfo->col_expr.col_expr_val[i],
|
2009-08-25 21:10:35 +00:00
|
|
|
COL_MAX_LEN);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-13 05:05:33 +00:00
|
|
|
void
|
|
|
|
col_custom_prime_edt(epan_dissect_t *edt, column_info *cinfo)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
if (!HAVE_CUSTOM_COLS(cinfo))
|
|
|
|
return;
|
2008-02-13 05:05:33 +00:00
|
|
|
|
|
|
|
for (i = cinfo->col_first[COL_CUSTOM];
|
|
|
|
i <= cinfo->col_last[COL_CUSTOM]; i++) {
|
2009-09-08 10:33:15 +00:00
|
|
|
|
|
|
|
cinfo->col_custom_field_id[i] = -1;
|
2008-02-22 22:47:19 +00:00
|
|
|
if (cinfo->fmt_matx[i][COL_CUSTOM] &&
|
2013-06-25 19:38:15 +00:00
|
|
|
cinfo->col_custom_dfilter[i]) {
|
|
|
|
epan_dissect_prime_dfilter(edt, cinfo->col_custom_dfilter[i]);
|
|
|
|
if (cinfo->col_custom_field) {
|
|
|
|
header_field_info* hfinfo = proto_registrar_get_byname(cinfo->col_custom_field[i]);
|
|
|
|
cinfo->col_custom_field_id[i] = hfinfo ? hfinfo->id : -1;
|
|
|
|
}
|
2009-09-11 14:00:36 +00:00
|
|
|
}
|
2008-02-13 05:05:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-07-08 02:54:26 +00:00
|
|
|
/* Appends a vararg list to a packet info string.
|
|
|
|
* This function's code is duplicated in col_append_sep_fstr() below because
|
|
|
|
* the for() loop below requires us to call va_start/va_end so intermediate
|
|
|
|
* functions are a problem.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
col_append_fstr(column_info *cinfo, const gint el, const gchar *format, ...)
|
2003-04-16 04:52:55 +00:00
|
|
|
{
|
2009-04-07 16:36:52 +00:00
|
|
|
int i;
|
2010-07-08 02:54:26 +00:00
|
|
|
int len, max_len;
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
if (!CHECK_COL(cinfo, el))
|
|
|
|
return;
|
2002-08-28 20:41:00 +00:00
|
|
|
|
2001-04-01 07:32:35 +00:00
|
|
|
if (el == COL_INFO)
|
2009-08-22 19:29:44 +00:00
|
|
|
max_len = COL_MAX_INFO_LEN;
|
2001-04-01 07:32:35 +00:00
|
|
|
else
|
2009-08-22 19:29:44 +00:00
|
|
|
max_len = COL_MAX_LEN;
|
2002-08-28 20:41:00 +00:00
|
|
|
|
2003-12-02 23:14:32 +00:00
|
|
|
for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) {
|
2001-12-10 00:26:21 +00:00
|
|
|
if (cinfo->fmt_matx[i][el]) {
|
2003-04-16 04:52:55 +00:00
|
|
|
/*
|
|
|
|
* First arrange that we can append, if necessary.
|
|
|
|
*/
|
|
|
|
COL_CHECK_APPEND(cinfo, i, max_len);
|
2004-08-24 08:20:20 +00:00
|
|
|
|
2009-04-07 16:36:52 +00:00
|
|
|
len = (int) strlen(cinfo->col_buf[i]);
|
2004-08-24 08:20:20 +00:00
|
|
|
|
2010-07-08 02:54:26 +00:00
|
|
|
va_start(ap, format);
|
2005-08-18 19:31:15 +00:00
|
|
|
g_vsnprintf(&cinfo->col_buf[i][len], max_len - len, format, ap);
|
2010-07-08 02:54:26 +00:00
|
|
|
va_end(ap);
|
2001-04-01 07:32:35 +00:00
|
|
|
}
|
|
|
|
}
|
2004-08-24 08:20:20 +00:00
|
|
|
|
2002-01-29 08:44:53 +00:00
|
|
|
}
|
|
|
|
|
2010-07-08 02:54:26 +00:00
|
|
|
/* Appends a vararg list to a packet info string.
|
|
|
|
* Prefixes it with the given separator if the column is not empty.
|
|
|
|
* Code is duplicated from col_append_fstr above().
|
|
|
|
*/
|
2004-02-05 23:57:15 +00:00
|
|
|
void
|
2010-04-03 18:18:50 +00:00
|
|
|
col_append_sep_fstr(column_info *cinfo, const gint el, const gchar *separator,
|
2013-06-25 19:38:15 +00:00
|
|
|
const gchar *format, ...)
|
2004-02-05 23:57:15 +00:00
|
|
|
{
|
2010-07-08 02:54:26 +00:00
|
|
|
int i;
|
|
|
|
int len, max_len, sep_len;
|
2004-02-05 23:57:15 +00:00
|
|
|
va_list ap;
|
|
|
|
|
2009-09-06 09:03:15 +00:00
|
|
|
if (!CHECK_COL(cinfo, el))
|
2009-03-20 12:41:03 +00:00
|
|
|
return;
|
|
|
|
|
2004-08-24 08:20:20 +00:00
|
|
|
if (separator == NULL)
|
|
|
|
separator = ", "; /* default */
|
2004-02-05 23:57:15 +00:00
|
|
|
|
2010-07-08 02:54:26 +00:00
|
|
|
sep_len = (int) strlen(separator);
|
|
|
|
|
|
|
|
if (el == COL_INFO)
|
|
|
|
max_len = COL_MAX_INFO_LEN;
|
|
|
|
else
|
|
|
|
max_len = COL_MAX_LEN;
|
2004-02-05 23:57:15 +00:00
|
|
|
|
2010-07-08 02:54:26 +00:00
|
|
|
for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) {
|
|
|
|
if (cinfo->fmt_matx[i][el]) {
|
|
|
|
/*
|
|
|
|
* First arrange that we can append, if necessary.
|
|
|
|
*/
|
|
|
|
COL_CHECK_APPEND(cinfo, i, max_len);
|
|
|
|
|
|
|
|
len = (int) strlen(cinfo->col_buf[i]);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we have a separator, append it if the column isn't empty.
|
|
|
|
*/
|
2011-03-31 17:27:48 +00:00
|
|
|
if (sep_len != 0) {
|
2010-07-08 02:54:26 +00:00
|
|
|
if (len != 0) {
|
|
|
|
g_strlcat(cinfo->col_buf[i], separator, max_len);
|
|
|
|
len += sep_len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
va_start(ap, format);
|
|
|
|
g_vsnprintf(&cinfo->col_buf[i][len], max_len - len, format, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2004-02-05 23:57:15 +00:00
|
|
|
|
2002-01-29 08:44:53 +00:00
|
|
|
/* Prepends a vararg list to a packet info string. */
|
2002-01-31 08:03:39 +00:00
|
|
|
#define COL_BUF_MAX_LEN (((COL_MAX_INFO_LEN) > (COL_MAX_LEN)) ? \
|
2009-08-22 19:29:44 +00:00
|
|
|
(COL_MAX_INFO_LEN) : (COL_MAX_LEN))
|
2002-01-29 08:44:53 +00:00
|
|
|
void
|
2010-04-03 18:18:50 +00:00
|
|
|
col_prepend_fstr(column_info *cinfo, const gint el, const gchar *format, ...)
|
2002-01-29 08:44:53 +00:00
|
|
|
{
|
2004-12-30 23:42:02 +00:00
|
|
|
va_list ap;
|
|
|
|
int i;
|
|
|
|
char orig_buf[COL_BUF_MAX_LEN];
|
|
|
|
const char *orig;
|
2009-04-07 16:36:52 +00:00
|
|
|
int max_len;
|
2002-08-28 20:41:00 +00:00
|
|
|
|
2009-09-06 09:03:15 +00:00
|
|
|
if (!CHECK_COL(cinfo, el))
|
2009-03-20 12:41:03 +00:00
|
|
|
return;
|
|
|
|
|
2002-01-29 08:44:53 +00:00
|
|
|
if (el == COL_INFO)
|
2009-08-22 19:29:44 +00:00
|
|
|
max_len = COL_MAX_INFO_LEN;
|
2002-01-29 08:44:53 +00:00
|
|
|
else
|
2009-08-22 19:29:44 +00:00
|
|
|
max_len = COL_MAX_LEN;
|
2002-08-28 20:41:00 +00:00
|
|
|
|
2003-12-02 23:14:32 +00:00
|
|
|
for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) {
|
2002-01-29 08:44:53 +00:00
|
|
|
if (cinfo->fmt_matx[i][el]) {
|
|
|
|
if (cinfo->col_data[i] != cinfo->col_buf[i]) {
|
2004-12-30 23:42:02 +00:00
|
|
|
/* This was set with "col_set_str()"; which is effectively const */
|
2002-01-29 08:44:53 +00:00
|
|
|
orig = cinfo->col_data[i];
|
|
|
|
} else {
|
2007-10-26 05:42:12 +00:00
|
|
|
g_strlcpy(orig_buf, cinfo->col_buf[i], max_len);
|
2002-01-31 00:51:36 +00:00
|
|
|
orig = orig_buf;
|
2002-01-29 08:44:53 +00:00
|
|
|
}
|
2010-05-26 02:01:49 +00:00
|
|
|
va_start(ap, format);
|
2005-08-18 19:31:15 +00:00
|
|
|
g_vsnprintf(cinfo->col_buf[i], max_len, format, ap);
|
2010-05-26 02:01:49 +00:00
|
|
|
va_end(ap);
|
2003-04-16 04:52:55 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Move the fence, unless it's at the beginning of the string.
|
|
|
|
*/
|
|
|
|
if (cinfo->col_fence[i] > 0)
|
2009-04-07 16:36:52 +00:00
|
|
|
cinfo->col_fence[i] += (int) strlen(cinfo->col_buf[i]);
|
2003-04-16 04:52:55 +00:00
|
|
|
|
2007-10-27 14:44:29 +00:00
|
|
|
g_strlcat(cinfo->col_buf[i], orig, max_len);
|
2002-01-29 08:44:53 +00:00
|
|
|
cinfo->col_data[i] = cinfo->col_buf[i];
|
|
|
|
}
|
|
|
|
}
|
2001-04-01 07:32:35 +00:00
|
|
|
}
|
2005-10-04 13:34:52 +00:00
|
|
|
void
|
2010-04-03 18:18:50 +00:00
|
|
|
col_prepend_fence_fstr(column_info *cinfo, const gint el, const gchar *format, ...)
|
2005-10-04 13:34:52 +00:00
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
int i;
|
|
|
|
char orig_buf[COL_BUF_MAX_LEN];
|
|
|
|
const char *orig;
|
2009-04-07 16:36:52 +00:00
|
|
|
int max_len;
|
2005-10-04 13:34:52 +00:00
|
|
|
|
2009-09-06 09:03:15 +00:00
|
|
|
if (!CHECK_COL(cinfo, el))
|
2009-03-20 12:41:03 +00:00
|
|
|
return;
|
|
|
|
|
2005-10-04 13:34:52 +00:00
|
|
|
if (el == COL_INFO)
|
2009-08-22 19:29:44 +00:00
|
|
|
max_len = COL_MAX_INFO_LEN;
|
2005-10-04 13:34:52 +00:00
|
|
|
else
|
2009-08-22 19:29:44 +00:00
|
|
|
max_len = COL_MAX_LEN;
|
2005-10-04 13:34:52 +00:00
|
|
|
|
|
|
|
for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) {
|
|
|
|
if (cinfo->fmt_matx[i][el]) {
|
|
|
|
if (cinfo->col_data[i] != cinfo->col_buf[i]) {
|
|
|
|
/* This was set with "col_set_str()"; which is effectively const */
|
|
|
|
orig = cinfo->col_data[i];
|
|
|
|
} else {
|
2007-10-26 05:42:12 +00:00
|
|
|
g_strlcpy(orig_buf, cinfo->col_buf[i], max_len);
|
2005-10-04 13:34:52 +00:00
|
|
|
orig = orig_buf;
|
|
|
|
}
|
2010-05-26 02:01:49 +00:00
|
|
|
va_start(ap, format);
|
2005-10-04 13:34:52 +00:00
|
|
|
g_vsnprintf(cinfo->col_buf[i], max_len, format, ap);
|
2010-05-26 02:01:49 +00:00
|
|
|
va_end(ap);
|
2005-10-04 13:34:52 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Move the fence if it exists, else create a new fence at the
|
|
|
|
* end of the prepended data.
|
|
|
|
*/
|
|
|
|
if (cinfo->col_fence[i] > 0) {
|
2009-04-07 16:36:52 +00:00
|
|
|
cinfo->col_fence[i] += (int) strlen(cinfo->col_buf[i]);
|
2005-10-04 13:34:52 +00:00
|
|
|
} else {
|
2009-04-07 16:36:52 +00:00
|
|
|
cinfo->col_fence[i] = (int) strlen(cinfo->col_buf[i]);
|
2005-10-04 13:34:52 +00:00
|
|
|
}
|
2007-10-27 14:44:29 +00:00
|
|
|
g_strlcat(cinfo->col_buf[i], orig, max_len);
|
2005-10-04 13:34:52 +00:00
|
|
|
cinfo->col_data[i] = cinfo->col_buf[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2001-04-01 07:32:35 +00:00
|
|
|
|
|
|
|
/* Use this if "str" points to something that won't stay around (and
|
|
|
|
must thus be copied). */
|
|
|
|
void
|
2010-04-03 18:18:50 +00:00
|
|
|
col_add_str(column_info *cinfo, const gint el, const gchar* str)
|
2003-04-16 04:52:55 +00:00
|
|
|
{
|
2001-04-01 07:32:35 +00:00
|
|
|
int i;
|
2003-04-16 04:52:55 +00:00
|
|
|
int fence;
|
2001-04-01 07:32:35 +00:00
|
|
|
size_t max_len;
|
|
|
|
|
2009-09-06 09:03:15 +00:00
|
|
|
if (!CHECK_COL(cinfo, el))
|
2009-03-20 12:41:03 +00:00
|
|
|
return;
|
|
|
|
|
2001-04-01 07:32:35 +00:00
|
|
|
if (el == COL_INFO)
|
2009-08-22 19:29:44 +00:00
|
|
|
max_len = COL_MAX_INFO_LEN;
|
2001-04-01 07:32:35 +00:00
|
|
|
else
|
2009-08-22 19:29:44 +00:00
|
|
|
max_len = COL_MAX_LEN;
|
2002-08-28 20:41:00 +00:00
|
|
|
|
2003-12-02 23:14:32 +00:00
|
|
|
for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) {
|
2001-12-10 00:26:21 +00:00
|
|
|
if (cinfo->fmt_matx[i][el]) {
|
2003-04-16 04:52:55 +00:00
|
|
|
fence = cinfo->col_fence[i];
|
|
|
|
if (fence != 0) {
|
|
|
|
/*
|
|
|
|
* We will append the string after the fence.
|
|
|
|
* First arrange that we can append, if necessary.
|
|
|
|
*/
|
|
|
|
COL_CHECK_APPEND(cinfo, i, max_len);
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* There's no fence, so we can just write to the string.
|
|
|
|
*/
|
|
|
|
cinfo->col_data[i] = cinfo->col_buf[i];
|
|
|
|
}
|
2007-10-26 05:42:12 +00:00
|
|
|
g_strlcpy(&cinfo->col_buf[i][fence], str, max_len - fence);
|
2001-04-01 07:32:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-22 21:08:48 +00:00
|
|
|
/* Use this if "str" points to something that will stay around (and thus
|
|
|
|
needn't be copied). */
|
|
|
|
void
|
2010-04-03 18:18:50 +00:00
|
|
|
col_set_str(column_info *cinfo, const gint el, const gchar* str)
|
2009-09-22 21:08:48 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int fence;
|
|
|
|
size_t max_len;
|
|
|
|
|
|
|
|
DISSECTOR_ASSERT(str);
|
|
|
|
|
|
|
|
/* The caller is expected to pass in something that 'will stay around' and
|
|
|
|
* something from the ephemeral pool certainly doesn't fit the bill. */
|
|
|
|
DISSECTOR_ASSERT(!ep_verify_pointer(str));
|
|
|
|
|
|
|
|
if (!CHECK_COL(cinfo, el))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (el == COL_INFO)
|
|
|
|
max_len = COL_MAX_INFO_LEN;
|
|
|
|
else
|
|
|
|
max_len = COL_MAX_LEN;
|
|
|
|
|
|
|
|
for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) {
|
|
|
|
if (cinfo->fmt_matx[i][el]) {
|
|
|
|
fence = cinfo->col_fence[i];
|
|
|
|
if (fence != 0) {
|
|
|
|
/*
|
|
|
|
* We will append the string after the fence.
|
|
|
|
* First arrange that we can append, if necessary.
|
|
|
|
*/
|
|
|
|
COL_CHECK_APPEND(cinfo, i, max_len);
|
|
|
|
|
|
|
|
g_strlcpy(&cinfo->col_buf[i][fence], str, max_len - fence);
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* There's no fence, so we can just set the column to point
|
|
|
|
* to the string.
|
|
|
|
*/
|
|
|
|
cinfo->col_data[i] = str;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Adds a vararg list to a packet info string. */
|
|
|
|
void
|
2010-04-03 18:18:50 +00:00
|
|
|
col_add_fstr(column_info *cinfo, const gint el, const gchar *format, ...) {
|
2009-09-22 21:08:48 +00:00
|
|
|
va_list ap;
|
|
|
|
int i;
|
|
|
|
int fence;
|
|
|
|
int max_len;
|
|
|
|
|
|
|
|
if (!CHECK_COL(cinfo, el))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (el == COL_INFO)
|
|
|
|
max_len = COL_MAX_INFO_LEN;
|
|
|
|
else
|
|
|
|
max_len = COL_MAX_LEN;
|
|
|
|
|
|
|
|
for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) {
|
|
|
|
if (cinfo->fmt_matx[i][el]) {
|
|
|
|
fence = cinfo->col_fence[i];
|
|
|
|
if (fence != 0) {
|
|
|
|
/*
|
|
|
|
* We will append the string after the fence.
|
|
|
|
* First arrange that we can append, if necessary.
|
|
|
|
*/
|
|
|
|
COL_CHECK_APPEND(cinfo, i, max_len);
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* There's no fence, so we can just write to the string.
|
|
|
|
*/
|
|
|
|
cinfo->col_data[i] = cinfo->col_buf[i];
|
|
|
|
}
|
2010-05-26 02:01:49 +00:00
|
|
|
va_start(ap, format);
|
2009-09-22 21:08:48 +00:00
|
|
|
g_vsnprintf(&cinfo->col_buf[i][fence], max_len - fence, format, ap);
|
2010-05-26 02:01:49 +00:00
|
|
|
va_end(ap);
|
2009-09-22 21:08:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-08-24 08:20:20 +00:00
|
|
|
static void
|
2010-04-03 18:18:50 +00:00
|
|
|
col_do_append_str(column_info *cinfo, const gint el, const gchar* separator,
|
2004-08-24 08:20:20 +00:00
|
|
|
const gchar* str)
|
2003-04-16 04:52:55 +00:00
|
|
|
{
|
2001-04-01 07:32:35 +00:00
|
|
|
int i;
|
2009-09-29 19:19:40 +00:00
|
|
|
size_t len, max_len;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
|
|
|
if (el == COL_INFO)
|
2009-08-22 19:29:44 +00:00
|
|
|
max_len = COL_MAX_INFO_LEN;
|
2001-04-01 07:32:35 +00:00
|
|
|
else
|
2009-08-22 19:29:44 +00:00
|
|
|
max_len = COL_MAX_LEN;
|
2002-08-28 20:41:00 +00:00
|
|
|
|
2003-12-02 23:14:32 +00:00
|
|
|
for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) {
|
2001-12-10 00:26:21 +00:00
|
|
|
if (cinfo->fmt_matx[i][el]) {
|
2003-04-16 04:52:55 +00:00
|
|
|
/*
|
|
|
|
* First arrange that we can append, if necessary.
|
|
|
|
*/
|
|
|
|
COL_CHECK_APPEND(cinfo, i, max_len);
|
2004-08-24 08:20:20 +00:00
|
|
|
|
2007-10-27 14:44:29 +00:00
|
|
|
len = cinfo->col_buf[i][0];
|
2004-08-24 08:20:20 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we have a separator, append it if the column isn't empty.
|
|
|
|
*/
|
|
|
|
if (separator != NULL) {
|
|
|
|
if (len != 0) {
|
2007-10-27 14:44:29 +00:00
|
|
|
g_strlcat(cinfo->col_buf[i], separator, max_len);
|
2004-08-24 08:20:20 +00:00
|
|
|
}
|
|
|
|
}
|
2007-10-27 14:44:29 +00:00
|
|
|
g_strlcat(cinfo->col_buf[i], str, max_len);
|
2001-04-01 07:32:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-08-24 08:20:20 +00:00
|
|
|
void
|
2010-04-03 18:18:50 +00:00
|
|
|
col_append_str(column_info *cinfo, const gint el, const gchar* str)
|
2004-08-24 08:20:20 +00:00
|
|
|
{
|
2009-09-11 14:00:36 +00:00
|
|
|
if (!CHECK_COL(cinfo, el))
|
|
|
|
return;
|
|
|
|
|
2004-08-24 08:20:20 +00:00
|
|
|
col_do_append_str(cinfo, el, NULL, str);
|
|
|
|
}
|
|
|
|
|
2004-02-05 23:57:15 +00:00
|
|
|
void
|
2010-04-03 18:18:50 +00:00
|
|
|
col_append_sep_str(column_info *cinfo, const gint el, const gchar* separator,
|
2004-02-05 23:57:15 +00:00
|
|
|
const gchar* str)
|
|
|
|
{
|
2009-09-11 14:00:36 +00:00
|
|
|
if (!CHECK_COL(cinfo, el))
|
|
|
|
return;
|
|
|
|
|
2004-08-24 08:20:20 +00:00
|
|
|
if (separator == NULL)
|
|
|
|
separator = ", "; /* default */
|
2009-09-20 12:09:25 +00:00
|
|
|
|
2004-08-24 08:20:20 +00:00
|
|
|
col_do_append_str(cinfo, el, separator, str);
|
2004-02-05 23:57:15 +00:00
|
|
|
}
|
|
|
|
|
2009-08-19 07:55:11 +00:00
|
|
|
/* --------------------------------- */
|
2009-09-22 21:08:48 +00:00
|
|
|
gboolean
|
2010-04-03 18:18:50 +00:00
|
|
|
col_has_time_fmt(column_info *cinfo, const gint col)
|
2009-09-22 21:08:48 +00:00
|
|
|
{
|
|
|
|
return ((cinfo->fmt_matx[col][COL_CLS_TIME]) ||
|
|
|
|
(cinfo->fmt_matx[col][COL_ABS_TIME]) ||
|
2013-11-06 20:39:09 +00:00
|
|
|
(cinfo->fmt_matx[col][COL_ABS_YMD_TIME]) ||
|
|
|
|
(cinfo->fmt_matx[col][COL_ABS_YDOY_TIME]) ||
|
2011-07-04 21:43:34 +00:00
|
|
|
(cinfo->fmt_matx[col][COL_UTC_TIME]) ||
|
2013-11-06 20:39:09 +00:00
|
|
|
(cinfo->fmt_matx[col][COL_UTC_YMD_TIME]) ||
|
|
|
|
(cinfo->fmt_matx[col][COL_UTC_YDOY_TIME]) ||
|
2009-09-22 21:08:48 +00:00
|
|
|
(cinfo->fmt_matx[col][COL_REL_TIME]) ||
|
|
|
|
(cinfo->fmt_matx[col][COL_DELTA_TIME]) ||
|
|
|
|
(cinfo->fmt_matx[col][COL_DELTA_TIME_DIS]));
|
|
|
|
}
|
|
|
|
|
2011-09-16 14:25:50 +00:00
|
|
|
static void
|
2013-11-06 20:39:09 +00:00
|
|
|
set_abs_ymd_time(const frame_data *fd, gchar *buf, gboolean local)
|
2001-04-01 07:32:35 +00:00
|
|
|
{
|
|
|
|
struct tm *tmp;
|
|
|
|
time_t then;
|
|
|
|
|
2012-02-25 23:24:34 +00:00
|
|
|
if (fd->flags.has_ts) {
|
|
|
|
then = fd->abs_ts.secs;
|
|
|
|
if (local)
|
2013-06-25 19:38:15 +00:00
|
|
|
tmp = localtime(&then);
|
2012-02-25 23:24:34 +00:00
|
|
|
else
|
2013-06-25 19:38:15 +00:00
|
|
|
tmp = gmtime(&then);
|
2012-02-25 23:24:34 +00:00
|
|
|
} else
|
|
|
|
tmp = NULL;
|
2001-07-15 19:14:03 +00:00
|
|
|
if (tmp != NULL) {
|
2013-06-25 19:38:15 +00:00
|
|
|
switch (timestamp_get_precision()) {
|
|
|
|
case TS_PREC_FIXED_SEC:
|
|
|
|
case TS_PREC_AUTO_SEC:
|
|
|
|
g_snprintf(buf, COL_MAX_LEN,"%04d-%02d-%02d %02d:%02d:%02d",
|
|
|
|
tmp->tm_year + 1900,
|
|
|
|
tmp->tm_mon + 1,
|
|
|
|
tmp->tm_mday,
|
|
|
|
tmp->tm_hour,
|
|
|
|
tmp->tm_min,
|
|
|
|
tmp->tm_sec);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_DSEC:
|
|
|
|
case TS_PREC_AUTO_DSEC:
|
|
|
|
g_snprintf(buf, COL_MAX_LEN,"%04d-%02d-%02d %02d:%02d:%02d.%01d",
|
|
|
|
tmp->tm_year + 1900,
|
|
|
|
tmp->tm_mon + 1,
|
|
|
|
tmp->tm_mday,
|
|
|
|
tmp->tm_hour,
|
|
|
|
tmp->tm_min,
|
|
|
|
tmp->tm_sec,
|
|
|
|
fd->abs_ts.nsecs / 100000000);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_CSEC:
|
|
|
|
case TS_PREC_AUTO_CSEC:
|
|
|
|
g_snprintf(buf, COL_MAX_LEN,"%04d-%02d-%02d %02d:%02d:%02d.%02d",
|
|
|
|
tmp->tm_year + 1900,
|
|
|
|
tmp->tm_mon + 1,
|
|
|
|
tmp->tm_mday,
|
|
|
|
tmp->tm_hour,
|
|
|
|
tmp->tm_min,
|
|
|
|
tmp->tm_sec,
|
|
|
|
fd->abs_ts.nsecs / 10000000);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_MSEC:
|
|
|
|
case TS_PREC_AUTO_MSEC:
|
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%04d-%02d-%02d %02d:%02d:%02d.%03d",
|
|
|
|
tmp->tm_year + 1900,
|
|
|
|
tmp->tm_mon + 1,
|
|
|
|
tmp->tm_mday,
|
|
|
|
tmp->tm_hour,
|
|
|
|
tmp->tm_min,
|
|
|
|
tmp->tm_sec,
|
|
|
|
fd->abs_ts.nsecs / 1000000);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_USEC:
|
|
|
|
case TS_PREC_AUTO_USEC:
|
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%04d-%02d-%02d %02d:%02d:%02d.%06d",
|
|
|
|
tmp->tm_year + 1900,
|
|
|
|
tmp->tm_mon + 1,
|
|
|
|
tmp->tm_mday,
|
|
|
|
tmp->tm_hour,
|
|
|
|
tmp->tm_min,
|
|
|
|
tmp->tm_sec,
|
|
|
|
fd->abs_ts.nsecs / 1000);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_NSEC:
|
|
|
|
case TS_PREC_AUTO_NSEC:
|
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%04d-%02d-%02d %02d:%02d:%02d.%09d",
|
|
|
|
tmp->tm_year + 1900,
|
|
|
|
tmp->tm_mon + 1,
|
|
|
|
tmp->tm_mday,
|
|
|
|
tmp->tm_hour,
|
|
|
|
tmp->tm_min,
|
|
|
|
tmp->tm_sec,
|
|
|
|
fd->abs_ts.nsecs);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
2001-07-15 19:14:03 +00:00
|
|
|
} else {
|
2009-08-19 07:55:11 +00:00
|
|
|
buf[0] = '\0';
|
2001-07-15 19:14:03 +00:00
|
|
|
}
|
2001-04-01 07:32:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2013-11-06 20:39:09 +00:00
|
|
|
col_set_abs_ymd_time(const frame_data *fd, column_info *cinfo, const int col)
|
2009-08-19 07:55:11 +00:00
|
|
|
{
|
2013-11-06 20:39:09 +00:00
|
|
|
set_abs_ymd_time(fd, cinfo->col_buf[col], TRUE);
|
2011-09-16 14:25:50 +00:00
|
|
|
cinfo->col_expr.col_expr[col] = "frame.time";
|
|
|
|
g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
|
|
|
|
|
2011-07-04 21:43:34 +00:00
|
|
|
cinfo->col_data[col] = cinfo->col_buf[col];
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2013-11-06 20:39:09 +00:00
|
|
|
col_set_utc_ymd_time(const frame_data *fd, column_info *cinfo, const int col)
|
2011-07-04 21:43:34 +00:00
|
|
|
{
|
2013-11-06 20:39:09 +00:00
|
|
|
set_abs_ymd_time(fd, cinfo->col_buf[col], FALSE);
|
|
|
|
cinfo->col_expr.col_expr[col] = "frame.time";
|
|
|
|
g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
|
|
|
|
|
|
|
|
cinfo->col_data[col] = cinfo->col_buf[col];
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
set_abs_ydoy_time(const frame_data *fd, gchar *buf, gboolean local)
|
|
|
|
{
|
|
|
|
struct tm *tmp;
|
|
|
|
time_t then;
|
|
|
|
|
|
|
|
if (fd->flags.has_ts) {
|
|
|
|
then = fd->abs_ts.secs;
|
|
|
|
if (local)
|
|
|
|
tmp = localtime(&then);
|
|
|
|
else
|
|
|
|
tmp = gmtime(&then);
|
|
|
|
} else
|
|
|
|
tmp = NULL;
|
|
|
|
if (tmp != NULL) {
|
|
|
|
switch (timestamp_get_precision()) {
|
|
|
|
case TS_PREC_FIXED_SEC:
|
|
|
|
case TS_PREC_AUTO_SEC:
|
|
|
|
g_snprintf(buf, COL_MAX_LEN,"%04d/%03d %02d:%02d:%02d",
|
|
|
|
tmp->tm_year + 1900,
|
|
|
|
tmp->tm_yday + 1,
|
|
|
|
tmp->tm_hour,
|
|
|
|
tmp->tm_min,
|
|
|
|
tmp->tm_sec);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_DSEC:
|
|
|
|
case TS_PREC_AUTO_DSEC:
|
|
|
|
g_snprintf(buf, COL_MAX_LEN,"%04d/%03d %02d:%02d:%02d.%01d",
|
|
|
|
tmp->tm_year + 1900,
|
|
|
|
tmp->tm_yday + 1,
|
|
|
|
tmp->tm_hour,
|
|
|
|
tmp->tm_min,
|
|
|
|
tmp->tm_sec,
|
|
|
|
fd->abs_ts.nsecs / 100000000);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_CSEC:
|
|
|
|
case TS_PREC_AUTO_CSEC:
|
|
|
|
g_snprintf(buf, COL_MAX_LEN,"%04d/%03d %02d:%02d:%02d.%02d",
|
|
|
|
tmp->tm_year + 1900,
|
|
|
|
tmp->tm_yday + 1,
|
|
|
|
tmp->tm_hour,
|
|
|
|
tmp->tm_min,
|
|
|
|
tmp->tm_sec,
|
|
|
|
fd->abs_ts.nsecs / 10000000);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_MSEC:
|
|
|
|
case TS_PREC_AUTO_MSEC:
|
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%04d/%03d %02d:%02d:%02d.%03d",
|
|
|
|
tmp->tm_year + 1900,
|
|
|
|
tmp->tm_yday + 1,
|
|
|
|
tmp->tm_hour,
|
|
|
|
tmp->tm_min,
|
|
|
|
tmp->tm_sec,
|
|
|
|
fd->abs_ts.nsecs / 1000000);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_USEC:
|
|
|
|
case TS_PREC_AUTO_USEC:
|
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%04d/%03d %02d:%02d:%02d.%06d",
|
|
|
|
tmp->tm_year + 1900,
|
|
|
|
tmp->tm_yday + 1,
|
|
|
|
tmp->tm_hour,
|
|
|
|
tmp->tm_min,
|
|
|
|
tmp->tm_sec,
|
|
|
|
fd->abs_ts.nsecs / 1000);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_NSEC:
|
|
|
|
case TS_PREC_AUTO_NSEC:
|
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%04d/%03d %02d:%02d:%02d.%09d",
|
|
|
|
tmp->tm_year + 1900,
|
|
|
|
tmp->tm_yday + 1,
|
|
|
|
tmp->tm_hour,
|
|
|
|
tmp->tm_min,
|
|
|
|
tmp->tm_sec,
|
|
|
|
fd->abs_ts.nsecs);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
buf[0] = '\0';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
col_set_abs_ydoy_time(const frame_data *fd, column_info *cinfo, const int col)
|
|
|
|
{
|
|
|
|
set_abs_ydoy_time(fd, cinfo->col_buf[col], TRUE);
|
|
|
|
cinfo->col_expr.col_expr[col] = "frame.time";
|
|
|
|
g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
|
|
|
|
|
|
|
|
cinfo->col_data[col] = cinfo->col_buf[col];
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
col_set_utc_ydoy_time(const frame_data *fd, column_info *cinfo, const int col)
|
|
|
|
{
|
|
|
|
set_abs_ydoy_time(fd, cinfo->col_buf[col], FALSE);
|
2011-09-16 14:25:50 +00:00
|
|
|
cinfo->col_expr.col_expr[col] = "frame.time";
|
|
|
|
g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
|
|
|
|
|
2009-08-19 07:55:11 +00:00
|
|
|
cinfo->col_data[col] = cinfo->col_buf[col];
|
|
|
|
}
|
|
|
|
|
2011-09-19 05:15:58 +00:00
|
|
|
static void
|
2010-05-06 10:32:59 +00:00
|
|
|
set_time_seconds(const nstime_t *ts, gchar *buf)
|
2001-04-01 07:32:35 +00:00
|
|
|
{
|
2013-06-25 19:38:15 +00:00
|
|
|
switch (timestamp_get_precision()) {
|
|
|
|
case TS_PREC_FIXED_SEC:
|
|
|
|
case TS_PREC_AUTO_SEC:
|
|
|
|
display_signed_time(buf, COL_MAX_LEN,
|
|
|
|
(gint32) ts->secs, ts->nsecs / 1000000000, TO_STR_TIME_RES_T_SECS);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_DSEC:
|
|
|
|
case TS_PREC_AUTO_DSEC:
|
|
|
|
display_signed_time(buf, COL_MAX_LEN,
|
|
|
|
(gint32) ts->secs, ts->nsecs / 100000000, TO_STR_TIME_RES_T_DSECS);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_CSEC:
|
|
|
|
case TS_PREC_AUTO_CSEC:
|
|
|
|
display_signed_time(buf, COL_MAX_LEN,
|
|
|
|
(gint32) ts->secs, ts->nsecs / 10000000, TO_STR_TIME_RES_T_CSECS);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_MSEC:
|
|
|
|
case TS_PREC_AUTO_MSEC:
|
|
|
|
display_signed_time(buf, COL_MAX_LEN,
|
|
|
|
(gint32) ts->secs, ts->nsecs / 1000000, TO_STR_TIME_RES_T_MSECS);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_USEC:
|
|
|
|
case TS_PREC_AUTO_USEC:
|
|
|
|
display_signed_time(buf, COL_MAX_LEN,
|
|
|
|
(gint32) ts->secs, ts->nsecs / 1000, TO_STR_TIME_RES_T_USECS);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_NSEC:
|
|
|
|
case TS_PREC_AUTO_NSEC:
|
|
|
|
display_signed_time(buf, COL_MAX_LEN,
|
|
|
|
(gint32) ts->secs, ts->nsecs, TO_STR_TIME_RES_T_NSECS);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
2005-08-25 21:29:54 +00:00
|
|
|
}
|
2001-04-01 07:32:35 +00:00
|
|
|
}
|
|
|
|
|
2011-09-19 05:15:58 +00:00
|
|
|
static void
|
2010-05-06 10:32:59 +00:00
|
|
|
set_time_hour_min_sec(const nstime_t *ts, gchar *buf)
|
2001-04-01 07:32:35 +00:00
|
|
|
{
|
2010-09-08 10:29:06 +00:00
|
|
|
time_t secs = ts->secs;
|
2011-09-02 11:46:33 +00:00
|
|
|
long nsecs = (long) ts->nsecs;
|
2010-09-08 10:29:06 +00:00
|
|
|
gboolean negative = FALSE;
|
|
|
|
|
|
|
|
if (secs < 0) {
|
|
|
|
secs = -secs;
|
|
|
|
negative = TRUE;
|
|
|
|
}
|
2011-09-02 11:46:33 +00:00
|
|
|
if (nsecs < 0) {
|
|
|
|
nsecs = -nsecs;
|
|
|
|
negative = TRUE;
|
|
|
|
}
|
2010-09-08 10:29:06 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
switch (timestamp_get_precision()) {
|
2010-05-06 10:32:59 +00:00
|
|
|
case TS_PREC_FIXED_SEC:
|
|
|
|
case TS_PREC_AUTO_SEC:
|
2010-09-08 10:29:06 +00:00
|
|
|
if (secs >= (60*60)) {
|
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%s%dh %2dm %2ds",
|
2013-06-25 19:38:15 +00:00
|
|
|
negative ? "- " : "",
|
|
|
|
(gint32) secs / (60 * 60),
|
|
|
|
(gint32) (secs / 60) % 60,
|
|
|
|
(gint32) secs % 60);
|
2010-09-08 10:29:06 +00:00
|
|
|
} else if (secs >= 60) {
|
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%s%dm %2ds",
|
2013-06-25 19:38:15 +00:00
|
|
|
negative ? "- " : "",
|
|
|
|
(gint32) secs / 60,
|
|
|
|
(gint32) secs % 60);
|
2010-05-06 10:32:59 +00:00
|
|
|
} else {
|
2010-09-08 10:29:06 +00:00
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%s%ds",
|
2013-06-25 19:38:15 +00:00
|
|
|
negative ? "- " : "",
|
|
|
|
(gint32) secs);
|
2010-05-06 10:32:59 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_DSEC:
|
|
|
|
case TS_PREC_AUTO_DSEC:
|
2010-09-08 10:29:06 +00:00
|
|
|
if (secs >= (60*60)) {
|
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%s%dh %2dm %2d.%01lds",
|
2013-06-25 19:38:15 +00:00
|
|
|
negative ? "- " : "",
|
|
|
|
(gint32) secs / (60 * 60),
|
|
|
|
(gint32) (secs / 60) % 60,
|
|
|
|
(gint32) secs % 60,
|
|
|
|
nsecs / 100000000);
|
2010-09-08 10:29:06 +00:00
|
|
|
} else if (secs >= 60) {
|
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%s%dm %2d.%01lds",
|
2013-06-25 19:38:15 +00:00
|
|
|
negative ? "- " : "",
|
|
|
|
(gint32) secs / 60,
|
|
|
|
(gint32) secs % 60,
|
|
|
|
nsecs / 100000000);
|
2010-05-06 10:32:59 +00:00
|
|
|
} else {
|
2010-09-08 10:29:06 +00:00
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%s%d.%01lds",
|
2013-06-25 19:38:15 +00:00
|
|
|
negative ? "- " : "",
|
|
|
|
(gint32) secs,
|
|
|
|
nsecs / 100000000);
|
2010-05-06 10:32:59 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_CSEC:
|
|
|
|
case TS_PREC_AUTO_CSEC:
|
2010-09-08 10:29:06 +00:00
|
|
|
if (secs >= (60*60)) {
|
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%s%dh %2dm %2d.%02lds",
|
2013-06-25 19:38:15 +00:00
|
|
|
negative ? "- " : "",
|
|
|
|
(gint32) secs / (60 * 60),
|
|
|
|
(gint32) (secs / 60) % 60,
|
|
|
|
(gint32) secs % 60,
|
|
|
|
nsecs / 10000000);
|
2010-09-08 10:29:06 +00:00
|
|
|
} else if (secs >= 60) {
|
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%s%dm %2d.%02lds",
|
2013-06-25 19:38:15 +00:00
|
|
|
negative ? "- " : "",
|
|
|
|
(gint32) secs / 60,
|
|
|
|
(gint32) secs % 60,
|
|
|
|
nsecs / 10000000);
|
2010-05-06 10:32:59 +00:00
|
|
|
} else {
|
2010-09-08 10:29:06 +00:00
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%s%d.%02lds",
|
2013-06-25 19:38:15 +00:00
|
|
|
negative ? "- " : "",
|
|
|
|
(gint32) secs,
|
|
|
|
nsecs / 10000000);
|
2010-05-06 10:32:59 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_MSEC:
|
|
|
|
case TS_PREC_AUTO_MSEC:
|
2010-09-08 10:29:06 +00:00
|
|
|
if (secs >= (60*60)) {
|
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%s%dh %2dm %2d.%03lds",
|
2013-06-25 19:38:15 +00:00
|
|
|
negative ? "- " : "",
|
|
|
|
(gint32) secs / (60 * 60),
|
|
|
|
(gint32) (secs / 60) % 60,
|
|
|
|
(gint32) secs % 60,
|
|
|
|
nsecs / 1000000);
|
2010-09-08 10:29:06 +00:00
|
|
|
} else if (secs >= 60) {
|
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%s%dm %2d.%03lds",
|
2013-06-25 19:38:15 +00:00
|
|
|
negative ? "- " : "",
|
|
|
|
(gint32) secs / 60,
|
|
|
|
(gint32) secs % 60,
|
|
|
|
nsecs / 1000000);
|
2010-05-06 10:32:59 +00:00
|
|
|
} else {
|
2010-09-08 10:29:06 +00:00
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%s%d.%03lds",
|
2013-06-25 19:38:15 +00:00
|
|
|
negative ? "- " : "",
|
|
|
|
(gint32) secs,
|
|
|
|
nsecs / 1000000);
|
2010-05-06 10:32:59 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_USEC:
|
|
|
|
case TS_PREC_AUTO_USEC:
|
2010-09-08 10:29:06 +00:00
|
|
|
if (secs >= (60*60)) {
|
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%s%dh %2dm %2d.%06lds",
|
2013-06-25 19:38:15 +00:00
|
|
|
negative ? "- " : "",
|
|
|
|
(gint32) secs / (60 * 60),
|
|
|
|
(gint32) (secs / 60) % 60,
|
|
|
|
(gint32) secs % 60,
|
|
|
|
nsecs / 1000);
|
2010-09-08 10:29:06 +00:00
|
|
|
} else if (secs >= 60) {
|
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%s%dm %2d.%06lds",
|
2013-06-25 19:38:15 +00:00
|
|
|
negative ? "- " : "",
|
|
|
|
(gint32) secs / 60,
|
|
|
|
(gint32) secs % 60,
|
|
|
|
nsecs / 1000);
|
2010-05-06 10:32:59 +00:00
|
|
|
} else {
|
2010-09-08 10:29:06 +00:00
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%s%d.%06lds",
|
2013-06-25 19:38:15 +00:00
|
|
|
negative ? "- " : "",
|
|
|
|
(gint32) secs,
|
|
|
|
nsecs / 1000);
|
2010-05-06 10:32:59 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_NSEC:
|
|
|
|
case TS_PREC_AUTO_NSEC:
|
2010-09-08 10:29:06 +00:00
|
|
|
if (secs >= (60*60)) {
|
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%s%dh %2dm %2d.%09lds",
|
2013-06-25 19:38:15 +00:00
|
|
|
negative ? "- " : "",
|
|
|
|
(gint32) secs / (60 * 60),
|
|
|
|
(gint32) (secs / 60) % 60,
|
|
|
|
(gint32) secs % 60,
|
|
|
|
nsecs);
|
2010-09-08 10:29:06 +00:00
|
|
|
} else if (secs >= 60) {
|
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%s%dm %2d.%09lds",
|
2013-06-25 19:38:15 +00:00
|
|
|
negative ? "- " : "",
|
|
|
|
(gint32) secs / 60,
|
|
|
|
(gint32) secs % 60,
|
|
|
|
nsecs);
|
2010-05-06 10:32:59 +00:00
|
|
|
} else {
|
2010-09-08 10:29:06 +00:00
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%s%d.%09lds",
|
2013-06-25 19:38:15 +00:00
|
|
|
negative ? "- " : "",
|
|
|
|
(gint32) secs,
|
|
|
|
nsecs);
|
2010-05-06 10:32:59 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
2005-08-25 21:29:54 +00:00
|
|
|
}
|
2001-04-01 07:32:35 +00:00
|
|
|
}
|
|
|
|
|
2007-03-23 18:08:17 +00:00
|
|
|
static void
|
2010-05-06 10:32:59 +00:00
|
|
|
col_set_rel_time(const frame_data *fd, column_info *cinfo, const int col)
|
2007-03-23 18:08:17 +00:00
|
|
|
{
|
2013-07-21 23:07:33 +00:00
|
|
|
nstime_t del_rel_ts;
|
|
|
|
|
2012-02-25 23:24:34 +00:00
|
|
|
if (!fd->flags.has_ts) {
|
|
|
|
cinfo->col_buf[col][0] = '\0';
|
|
|
|
return;
|
|
|
|
}
|
2013-07-21 23:07:33 +00:00
|
|
|
|
|
|
|
frame_delta_abs_time(cinfo->epan, fd, fd->frame_ref_num, &del_rel_ts);
|
|
|
|
|
2010-05-06 10:32:59 +00:00
|
|
|
switch (timestamp_get_seconds_type()) {
|
|
|
|
case TS_SECONDS_DEFAULT:
|
2013-07-21 23:07:33 +00:00
|
|
|
set_time_seconds(&del_rel_ts, cinfo->col_buf[col]);
|
2011-09-19 05:15:58 +00:00
|
|
|
cinfo->col_expr.col_expr[col] = "frame.time_relative";
|
|
|
|
g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
|
2010-05-06 10:32:59 +00:00
|
|
|
break;
|
|
|
|
case TS_SECONDS_HOUR_MIN_SEC:
|
2013-07-21 23:07:33 +00:00
|
|
|
set_time_hour_min_sec(&del_rel_ts, cinfo->col_buf[col]);
|
2011-09-19 05:15:58 +00:00
|
|
|
cinfo->col_expr.col_expr[col] = "frame.time_relative";
|
2013-07-21 23:07:33 +00:00
|
|
|
set_time_seconds(&del_rel_ts, cinfo->col_expr.col_expr_val[col]);
|
2010-05-06 10:32:59 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
2009-08-19 07:55:11 +00:00
|
|
|
}
|
|
|
|
cinfo->col_data[col] = cinfo->col_buf[col];
|
|
|
|
}
|
|
|
|
|
2010-05-06 10:32:59 +00:00
|
|
|
static void
|
|
|
|
col_set_delta_time(const frame_data *fd, column_info *cinfo, const int col)
|
2009-08-19 07:55:11 +00:00
|
|
|
{
|
2012-09-23 16:25:28 +00:00
|
|
|
nstime_t del_cap_ts;
|
|
|
|
|
2013-07-21 20:48:30 +00:00
|
|
|
frame_delta_abs_time(cinfo->epan, fd, fd->num - 1, &del_cap_ts);
|
2012-09-23 16:25:28 +00:00
|
|
|
|
2010-05-06 10:32:59 +00:00
|
|
|
switch (timestamp_get_seconds_type()) {
|
|
|
|
case TS_SECONDS_DEFAULT:
|
2012-09-23 16:25:28 +00:00
|
|
|
set_time_seconds(&del_cap_ts, cinfo->col_buf[col]);
|
2011-09-19 05:15:58 +00:00
|
|
|
cinfo->col_expr.col_expr[col] = "frame.time_delta";
|
|
|
|
g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
|
2010-05-06 10:32:59 +00:00
|
|
|
break;
|
|
|
|
case TS_SECONDS_HOUR_MIN_SEC:
|
2012-09-23 16:25:28 +00:00
|
|
|
set_time_hour_min_sec(&del_cap_ts, cinfo->col_buf[col]);
|
2011-09-19 05:15:58 +00:00
|
|
|
cinfo->col_expr.col_expr[col] = "frame.time_delta";
|
2012-09-23 16:25:28 +00:00
|
|
|
set_time_seconds(&del_cap_ts, cinfo->col_expr.col_expr_val[col]);
|
2010-05-06 10:32:59 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
2007-03-23 18:08:17 +00:00
|
|
|
}
|
2010-05-06 10:32:59 +00:00
|
|
|
|
|
|
|
cinfo->col_data[col] = cinfo->col_buf[col];
|
2009-08-19 07:55:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-04-03 18:18:50 +00:00
|
|
|
col_set_delta_time_dis(const frame_data *fd, column_info *cinfo, const int col)
|
2009-08-19 07:55:11 +00:00
|
|
|
{
|
2012-09-23 16:25:28 +00:00
|
|
|
nstime_t del_dis_ts;
|
|
|
|
|
2012-02-25 23:24:34 +00:00
|
|
|
if (!fd->flags.has_ts) {
|
|
|
|
cinfo->col_buf[col][0] = '\0';
|
|
|
|
return;
|
|
|
|
}
|
2012-09-23 16:25:28 +00:00
|
|
|
|
2013-07-21 20:48:30 +00:00
|
|
|
frame_delta_abs_time(cinfo->epan, fd, fd->prev_dis_num, &del_dis_ts);
|
2012-09-23 16:25:28 +00:00
|
|
|
|
2010-05-06 10:32:59 +00:00
|
|
|
switch (timestamp_get_seconds_type()) {
|
|
|
|
case TS_SECONDS_DEFAULT:
|
2012-09-23 16:25:28 +00:00
|
|
|
set_time_seconds(&del_dis_ts, cinfo->col_buf[col]);
|
2011-09-19 05:15:58 +00:00
|
|
|
cinfo->col_expr.col_expr[col] = "frame.time_delta_displayed";
|
|
|
|
g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
|
2010-05-06 10:32:59 +00:00
|
|
|
break;
|
|
|
|
case TS_SECONDS_HOUR_MIN_SEC:
|
2012-09-23 16:25:28 +00:00
|
|
|
set_time_hour_min_sec(&del_dis_ts, cinfo->col_buf[col]);
|
2011-09-19 05:15:58 +00:00
|
|
|
cinfo->col_expr.col_expr[col] = "frame.time_delta_displayed";
|
2012-09-23 16:25:28 +00:00
|
|
|
set_time_seconds(&del_dis_ts, cinfo->col_expr.col_expr_val[col]);
|
2010-05-06 10:32:59 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
2009-08-19 07:55:11 +00:00
|
|
|
}
|
2010-05-06 10:32:59 +00:00
|
|
|
|
2007-03-23 18:08:17 +00:00
|
|
|
cinfo->col_data[col] = cinfo->col_buf[col];
|
|
|
|
}
|
|
|
|
|
2011-09-16 14:25:50 +00:00
|
|
|
static void
|
2011-07-04 21:43:34 +00:00
|
|
|
set_abs_time(const frame_data *fd, gchar *buf, gboolean local)
|
2001-04-01 07:32:35 +00:00
|
|
|
{
|
|
|
|
struct tm *tmp;
|
|
|
|
time_t then;
|
|
|
|
|
2012-02-25 23:24:34 +00:00
|
|
|
if (fd->flags.has_ts) {
|
|
|
|
then = fd->abs_ts.secs;
|
|
|
|
if (local)
|
2013-06-25 19:38:15 +00:00
|
|
|
tmp = localtime(&then);
|
2012-02-25 23:24:34 +00:00
|
|
|
else
|
2013-06-25 19:38:15 +00:00
|
|
|
tmp = gmtime(&then);
|
2012-02-25 23:24:34 +00:00
|
|
|
} else
|
|
|
|
tmp = NULL;
|
2001-07-15 19:14:03 +00:00
|
|
|
if (tmp != NULL) {
|
2013-06-25 19:38:15 +00:00
|
|
|
switch (timestamp_get_precision()) {
|
|
|
|
case TS_PREC_FIXED_SEC:
|
|
|
|
case TS_PREC_AUTO_SEC:
|
|
|
|
g_snprintf(buf, COL_MAX_LEN,"%02d:%02d:%02d",
|
|
|
|
tmp->tm_hour,
|
|
|
|
tmp->tm_min,
|
|
|
|
tmp->tm_sec);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_DSEC:
|
|
|
|
case TS_PREC_AUTO_DSEC:
|
|
|
|
g_snprintf(buf, COL_MAX_LEN,"%02d:%02d:%02d.%01d",
|
|
|
|
tmp->tm_hour,
|
|
|
|
tmp->tm_min,
|
|
|
|
tmp->tm_sec,
|
|
|
|
fd->abs_ts.nsecs / 100000000);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_CSEC:
|
|
|
|
case TS_PREC_AUTO_CSEC:
|
|
|
|
g_snprintf(buf, COL_MAX_LEN,"%02d:%02d:%02d.%02d",
|
|
|
|
tmp->tm_hour,
|
|
|
|
tmp->tm_min,
|
|
|
|
tmp->tm_sec,
|
|
|
|
fd->abs_ts.nsecs / 10000000);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_MSEC:
|
|
|
|
case TS_PREC_AUTO_MSEC:
|
|
|
|
g_snprintf(buf, COL_MAX_LEN,"%02d:%02d:%02d.%03d",
|
|
|
|
tmp->tm_hour,
|
|
|
|
tmp->tm_min,
|
|
|
|
tmp->tm_sec,
|
|
|
|
fd->abs_ts.nsecs / 1000000);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_USEC:
|
|
|
|
case TS_PREC_AUTO_USEC:
|
|
|
|
g_snprintf(buf, COL_MAX_LEN,"%02d:%02d:%02d.%06d",
|
|
|
|
tmp->tm_hour,
|
|
|
|
tmp->tm_min,
|
|
|
|
tmp->tm_sec,
|
|
|
|
fd->abs_ts.nsecs / 1000);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_NSEC:
|
|
|
|
case TS_PREC_AUTO_NSEC:
|
|
|
|
g_snprintf(buf, COL_MAX_LEN, "%02d:%02d:%02d.%09d",
|
|
|
|
tmp->tm_hour,
|
|
|
|
tmp->tm_min,
|
|
|
|
tmp->tm_sec,
|
|
|
|
fd->abs_ts.nsecs);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
2009-09-06 09:03:15 +00:00
|
|
|
|
2001-07-15 19:14:03 +00:00
|
|
|
} else {
|
2009-08-19 07:55:11 +00:00
|
|
|
*buf = '\0';
|
2001-07-15 19:14:03 +00:00
|
|
|
}
|
2001-04-01 07:32:35 +00:00
|
|
|
}
|
|
|
|
|
2006-12-05 03:19:51 +00:00
|
|
|
static void
|
2010-04-03 18:18:50 +00:00
|
|
|
col_set_abs_time(const frame_data *fd, column_info *cinfo, const int col)
|
2006-12-05 03:19:51 +00:00
|
|
|
{
|
2011-09-16 14:25:50 +00:00
|
|
|
set_abs_time(fd, cinfo->col_buf[col], TRUE);
|
|
|
|
cinfo->col_expr.col_expr[col] = "frame.time";
|
|
|
|
g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
|
|
|
|
|
2011-07-04 21:43:34 +00:00
|
|
|
cinfo->col_data[col] = cinfo->col_buf[col];
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
col_set_utc_time(const frame_data *fd, column_info *cinfo, const int col)
|
|
|
|
{
|
2011-09-16 14:25:50 +00:00
|
|
|
set_abs_time(fd, cinfo->col_buf[col], FALSE);
|
|
|
|
cinfo->col_expr.col_expr[col] = "frame.time";
|
|
|
|
g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
|
|
|
|
|
2009-08-19 07:55:11 +00:00
|
|
|
cinfo->col_data[col] = cinfo->col_buf[col];
|
|
|
|
}
|
2006-12-05 03:19:51 +00:00
|
|
|
|
2012-02-25 23:24:34 +00:00
|
|
|
static gboolean
|
2010-04-03 18:18:50 +00:00
|
|
|
set_epoch_time(const frame_data *fd, gchar *buf)
|
2009-08-19 07:55:11 +00:00
|
|
|
{
|
2012-02-25 23:24:34 +00:00
|
|
|
if (!fd->flags.has_ts) {
|
|
|
|
buf[0] = '\0';
|
|
|
|
return FALSE;
|
|
|
|
}
|
2013-06-25 19:38:15 +00:00
|
|
|
switch (timestamp_get_precision()) {
|
|
|
|
case TS_PREC_FIXED_SEC:
|
|
|
|
case TS_PREC_AUTO_SEC:
|
|
|
|
display_epoch_time(buf, COL_MAX_LEN,
|
|
|
|
fd->abs_ts.secs, fd->abs_ts.nsecs / 1000000000, TO_STR_TIME_RES_T_SECS);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_DSEC:
|
|
|
|
case TS_PREC_AUTO_DSEC:
|
|
|
|
display_epoch_time(buf, COL_MAX_LEN,
|
|
|
|
fd->abs_ts.secs, fd->abs_ts.nsecs / 100000000, TO_STR_TIME_RES_T_DSECS);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_CSEC:
|
|
|
|
case TS_PREC_AUTO_CSEC:
|
|
|
|
display_epoch_time(buf, COL_MAX_LEN,
|
|
|
|
fd->abs_ts.secs, fd->abs_ts.nsecs / 10000000, TO_STR_TIME_RES_T_CSECS);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_MSEC:
|
|
|
|
case TS_PREC_AUTO_MSEC:
|
|
|
|
display_epoch_time(buf, COL_MAX_LEN,
|
|
|
|
fd->abs_ts.secs, fd->abs_ts.nsecs / 1000000, TO_STR_TIME_RES_T_MSECS);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_USEC:
|
|
|
|
case TS_PREC_AUTO_USEC:
|
|
|
|
display_epoch_time(buf, COL_MAX_LEN,
|
|
|
|
fd->abs_ts.secs, fd->abs_ts.nsecs / 1000, TO_STR_TIME_RES_T_USECS);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_NSEC:
|
|
|
|
case TS_PREC_AUTO_NSEC:
|
|
|
|
display_epoch_time(buf, COL_MAX_LEN,
|
|
|
|
fd->abs_ts.secs, fd->abs_ts.nsecs, TO_STR_TIME_RES_T_NSECS);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
2006-12-05 03:19:51 +00:00
|
|
|
}
|
2012-02-25 23:24:34 +00:00
|
|
|
return TRUE;
|
2009-08-19 07:55:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-04-03 18:18:50 +00:00
|
|
|
col_set_epoch_time(const frame_data *fd, column_info *cinfo, const int col)
|
2009-08-19 07:55:11 +00:00
|
|
|
{
|
|
|
|
if (set_epoch_time(fd, cinfo->col_buf[col])) {
|
|
|
|
cinfo->col_expr.col_expr[col] = "frame.time_delta";
|
|
|
|
g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
|
|
|
|
}
|
2006-12-05 03:19:51 +00:00
|
|
|
cinfo->col_data[col] = cinfo->col_buf[col];
|
|
|
|
}
|
2008-06-14 16:51:11 +00:00
|
|
|
|
2009-08-19 07:55:11 +00:00
|
|
|
void
|
2013-07-21 20:48:30 +00:00
|
|
|
set_fd_time(const epan_t *epan, frame_data *fd, gchar *buf)
|
2009-08-19 07:55:11 +00:00
|
|
|
{
|
2009-09-08 15:55:10 +00:00
|
|
|
|
2009-08-19 07:55:11 +00:00
|
|
|
switch (timestamp_get_type()) {
|
2013-06-25 19:38:15 +00:00
|
|
|
case TS_ABSOLUTE:
|
|
|
|
set_abs_time(fd, buf, TRUE);
|
|
|
|
break;
|
2009-08-19 07:55:11 +00:00
|
|
|
|
2013-11-06 20:39:09 +00:00
|
|
|
case TS_ABSOLUTE_WITH_YMD:
|
|
|
|
set_abs_ymd_time(fd, buf, TRUE);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TS_ABSOLUTE_WITH_YDOY:
|
|
|
|
set_abs_ydoy_time(fd, buf, TRUE);
|
2013-06-25 19:38:15 +00:00
|
|
|
break;
|
2009-08-19 07:55:11 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
case TS_RELATIVE:
|
|
|
|
if (fd->flags.has_ts) {
|
2013-07-21 23:07:33 +00:00
|
|
|
nstime_t del_rel_ts;
|
|
|
|
|
|
|
|
frame_delta_abs_time(epan, fd, fd->frame_ref_num, &del_rel_ts);
|
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
switch (timestamp_get_seconds_type()) {
|
|
|
|
case TS_SECONDS_DEFAULT:
|
2013-07-21 23:07:33 +00:00
|
|
|
set_time_seconds(&del_rel_ts, buf);
|
2013-06-25 19:38:15 +00:00
|
|
|
break;
|
|
|
|
case TS_SECONDS_HOUR_MIN_SEC:
|
2013-07-21 23:07:33 +00:00
|
|
|
set_time_seconds(&del_rel_ts, buf);
|
2013-06-25 19:38:15 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
2012-02-25 23:24:34 +00:00
|
|
|
}
|
2013-06-25 19:38:15 +00:00
|
|
|
} else {
|
|
|
|
buf[0] = '\0';
|
|
|
|
}
|
|
|
|
break;
|
2009-08-19 07:55:11 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
case TS_DELTA:
|
|
|
|
if (fd->flags.has_ts) {
|
|
|
|
nstime_t del_cap_ts;
|
|
|
|
|
2013-07-21 20:48:30 +00:00
|
|
|
frame_delta_abs_time(epan, fd, fd->num - 1, &del_cap_ts);
|
2013-06-25 19:38:15 +00:00
|
|
|
|
|
|
|
switch (timestamp_get_seconds_type()) {
|
|
|
|
case TS_SECONDS_DEFAULT:
|
|
|
|
set_time_seconds(&del_cap_ts, buf);
|
|
|
|
break;
|
|
|
|
case TS_SECONDS_HOUR_MIN_SEC:
|
|
|
|
set_time_hour_min_sec(&del_cap_ts, buf);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
2012-02-25 23:24:34 +00:00
|
|
|
}
|
2013-06-25 19:38:15 +00:00
|
|
|
} else {
|
|
|
|
buf[0] = '\0';
|
|
|
|
}
|
|
|
|
break;
|
2009-08-19 07:55:11 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
case TS_DELTA_DIS:
|
|
|
|
if (fd->flags.has_ts) {
|
|
|
|
nstime_t del_dis_ts;
|
|
|
|
|
2013-07-21 20:48:30 +00:00
|
|
|
frame_delta_abs_time(epan, fd, fd->prev_dis_num, &del_dis_ts);
|
2013-06-25 19:38:15 +00:00
|
|
|
|
|
|
|
switch (timestamp_get_seconds_type()) {
|
|
|
|
case TS_SECONDS_DEFAULT:
|
|
|
|
set_time_seconds(&del_dis_ts, buf);
|
|
|
|
break;
|
|
|
|
case TS_SECONDS_HOUR_MIN_SEC:
|
|
|
|
set_time_hour_min_sec(&del_dis_ts, buf);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
2012-02-25 23:24:34 +00:00
|
|
|
}
|
2013-06-25 19:38:15 +00:00
|
|
|
} else {
|
|
|
|
buf[0] = '\0';
|
|
|
|
}
|
|
|
|
break;
|
2009-08-19 07:55:11 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
case TS_EPOCH:
|
|
|
|
set_epoch_time(fd, buf);
|
|
|
|
break;
|
2009-08-19 07:55:11 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
case TS_UTC:
|
|
|
|
set_abs_time(fd, buf, FALSE);
|
|
|
|
break;
|
2011-09-19 05:15:58 +00:00
|
|
|
|
2013-11-06 20:39:09 +00:00
|
|
|
case TS_UTC_WITH_YMD:
|
|
|
|
set_abs_ymd_time(fd, buf, FALSE);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TS_UTC_WITH_YDOY:
|
|
|
|
set_abs_ydoy_time(fd, buf, FALSE);
|
2013-06-25 19:38:15 +00:00
|
|
|
break;
|
2011-09-19 05:15:58 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
case TS_NOT_SET:
|
|
|
|
/* code is missing for this case, but I don't know which [jmayer20051219] */
|
|
|
|
g_assert(FALSE);
|
|
|
|
break;
|
2009-08-19 07:55:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-06-14 16:51:11 +00:00
|
|
|
static void
|
2010-04-03 18:18:50 +00:00
|
|
|
col_set_cls_time(const frame_data *fd, column_info *cinfo, const gint col)
|
2001-04-01 07:32:35 +00:00
|
|
|
{
|
2005-08-25 21:29:54 +00:00
|
|
|
switch (timestamp_get_type()) {
|
2013-06-25 19:38:15 +00:00
|
|
|
case TS_ABSOLUTE:
|
|
|
|
col_set_abs_time(fd, cinfo, col);
|
|
|
|
break;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2013-11-06 20:39:09 +00:00
|
|
|
case TS_ABSOLUTE_WITH_YMD:
|
|
|
|
col_set_abs_ymd_time(fd, cinfo, col);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TS_ABSOLUTE_WITH_YDOY:
|
|
|
|
col_set_abs_ydoy_time(fd, cinfo, col);
|
2013-06-25 19:38:15 +00:00
|
|
|
break;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
case TS_RELATIVE:
|
|
|
|
col_set_rel_time(fd, cinfo, col);
|
|
|
|
break;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
case TS_DELTA:
|
|
|
|
col_set_delta_time(fd, cinfo, col);
|
|
|
|
break;
|
2007-03-23 18:08:17 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
case TS_DELTA_DIS:
|
|
|
|
col_set_delta_time_dis(fd, cinfo, col);
|
|
|
|
break;
|
2007-03-23 18:08:17 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
case TS_EPOCH:
|
|
|
|
col_set_epoch_time(fd, cinfo, col);
|
|
|
|
break;
|
2007-03-23 18:08:17 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
case TS_UTC:
|
|
|
|
col_set_utc_time(fd, cinfo, col);
|
|
|
|
break;
|
2011-07-04 21:43:34 +00:00
|
|
|
|
2013-11-06 20:39:09 +00:00
|
|
|
case TS_UTC_WITH_YMD:
|
|
|
|
col_set_utc_ymd_time(fd, cinfo, col);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TS_UTC_WITH_YDOY:
|
|
|
|
col_set_utc_ydoy_time(fd, cinfo, col);
|
2013-06-25 19:38:15 +00:00
|
|
|
break;
|
2011-07-04 21:43:34 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
case TS_NOT_SET:
|
|
|
|
/* code is missing for this case, but I don't know which [jmayer20051219] */
|
|
|
|
g_assert_not_reached();
|
|
|
|
break;
|
2008-06-14 16:51:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-28 02:21:03 +00:00
|
|
|
/* Set the format of the variable time format. */
|
|
|
|
static void
|
2010-04-03 18:18:50 +00:00
|
|
|
col_set_fmt_time(const frame_data *fd, column_info *cinfo, const gint fmt, const gint col)
|
2008-06-14 16:51:11 +00:00
|
|
|
{
|
2009-09-08 15:55:10 +00:00
|
|
|
COL_CHECK_REF_TIME(fd, cinfo->col_buf[col]);
|
|
|
|
|
2008-06-14 16:51:11 +00:00
|
|
|
switch (fmt) {
|
2013-06-25 19:38:15 +00:00
|
|
|
case COL_CLS_TIME:
|
|
|
|
col_set_cls_time(fd, cinfo, col);
|
|
|
|
break;
|
2008-06-14 16:51:11 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
case COL_ABS_TIME:
|
|
|
|
col_set_abs_time(fd, cinfo, col);
|
|
|
|
break;
|
2008-06-14 16:51:11 +00:00
|
|
|
|
2013-11-06 20:39:09 +00:00
|
|
|
case COL_ABS_YMD_TIME:
|
|
|
|
col_set_abs_ymd_time(fd, cinfo, col);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case COL_ABS_YDOY_TIME:
|
|
|
|
col_set_abs_ydoy_time(fd, cinfo, col);
|
2013-06-25 19:38:15 +00:00
|
|
|
break;
|
2008-06-14 16:51:11 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
case COL_REL_TIME:
|
|
|
|
col_set_rel_time(fd, cinfo, col);
|
|
|
|
break;
|
2008-06-14 16:51:11 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
case COL_DELTA_TIME:
|
|
|
|
col_set_delta_time(fd, cinfo, col);
|
|
|
|
break;
|
2008-06-14 16:51:11 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
case COL_DELTA_TIME_DIS:
|
|
|
|
col_set_delta_time_dis(fd, cinfo, col);
|
|
|
|
break;
|
2008-06-14 16:51:11 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
case COL_UTC_TIME:
|
|
|
|
col_set_utc_time(fd, cinfo, col);
|
|
|
|
break;
|
2011-07-04 21:43:34 +00:00
|
|
|
|
2013-11-06 20:39:09 +00:00
|
|
|
case COL_UTC_YMD_TIME:
|
|
|
|
col_set_utc_ymd_time(fd, cinfo, col);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case COL_UTC_YDOY_TIME:
|
|
|
|
col_set_utc_ydoy_time(fd, cinfo, col);
|
2013-06-25 19:38:15 +00:00
|
|
|
break;
|
2011-07-04 21:43:34 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
|
|
|
break;
|
2001-04-01 07:32:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-19 07:55:11 +00:00
|
|
|
/* --------------------------- */
|
2010-08-30 05:39:02 +00:00
|
|
|
/* Set the given (relative) time to a column element.
|
|
|
|
*
|
|
|
|
* Used by multiple dissectors to set the time in the column
|
|
|
|
* COL_DELTA_CONV_TIME
|
|
|
|
*
|
2013-06-25 19:38:15 +00:00
|
|
|
* @param cinfo the current packet row
|
|
|
|
* @param el the column to use, e.g. COL_INFO
|
|
|
|
* @param ts the time to set in the column
|
|
|
|
* @param fieldname the fieldname to use for creating a filter (when
|
|
|
|
* applying/preparing/copying as filter)
|
2010-08-30 05:39:02 +00:00
|
|
|
*/
|
2007-10-03 14:02:08 +00:00
|
|
|
void
|
2012-12-26 05:57:06 +00:00
|
|
|
col_set_time(column_info *cinfo, const gint el, const nstime_t *ts, const char *fieldname)
|
2007-10-03 14:02:08 +00:00
|
|
|
{
|
2009-09-08 15:55:10 +00:00
|
|
|
int col;
|
2007-10-03 14:02:08 +00:00
|
|
|
|
2009-09-06 09:03:15 +00:00
|
|
|
if (!CHECK_COL(cinfo, el))
|
2009-03-20 12:41:03 +00:00
|
|
|
return;
|
2007-10-03 14:02:08 +00:00
|
|
|
|
2010-08-30 05:39:02 +00:00
|
|
|
/** @todo TODO: We don't respect fd->flags.ref_time (no way to access 'fd')
|
2009-09-08 15:55:10 +00:00
|
|
|
COL_CHECK_REF_TIME(fd, buf);
|
|
|
|
*/
|
|
|
|
|
2007-10-03 14:02:08 +00:00
|
|
|
for (col = cinfo->col_first[el]; col <= cinfo->col_last[el]; col++) {
|
|
|
|
if (cinfo->fmt_matx[col][el]) {
|
2013-06-25 19:38:15 +00:00
|
|
|
switch (timestamp_get_precision()) {
|
|
|
|
case TS_PREC_FIXED_SEC:
|
|
|
|
case TS_PREC_AUTO_SEC:
|
|
|
|
display_signed_time(cinfo->col_buf[col], COL_MAX_LEN,
|
|
|
|
(gint32) ts->secs, ts->nsecs / 1000000000, TO_STR_TIME_RES_T_SECS);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_DSEC:
|
|
|
|
case TS_PREC_AUTO_DSEC:
|
|
|
|
display_signed_time(cinfo->col_buf[col], COL_MAX_LEN,
|
|
|
|
(gint32) ts->secs, ts->nsecs / 100000000, TO_STR_TIME_RES_T_DSECS);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_CSEC:
|
|
|
|
case TS_PREC_AUTO_CSEC:
|
|
|
|
display_signed_time(cinfo->col_buf[col], COL_MAX_LEN,
|
|
|
|
(gint32) ts->secs, ts->nsecs / 10000000, TO_STR_TIME_RES_T_CSECS);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_MSEC:
|
|
|
|
case TS_PREC_AUTO_MSEC:
|
|
|
|
display_signed_time(cinfo->col_buf[col], COL_MAX_LEN,
|
|
|
|
(gint32) ts->secs, ts->nsecs / 1000000, TO_STR_TIME_RES_T_MSECS);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_USEC:
|
|
|
|
case TS_PREC_AUTO_USEC:
|
|
|
|
display_signed_time(cinfo->col_buf[col], COL_MAX_LEN,
|
|
|
|
(gint32) ts->secs, ts->nsecs / 1000, TO_STR_TIME_RES_T_USECS);
|
|
|
|
break;
|
|
|
|
case TS_PREC_FIXED_NSEC:
|
|
|
|
case TS_PREC_AUTO_NSEC:
|
|
|
|
display_signed_time(cinfo->col_buf[col], COL_MAX_LEN,
|
|
|
|
(gint32) ts->secs, ts->nsecs, TO_STR_TIME_RES_T_NSECS);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
2007-10-03 14:02:08 +00:00
|
|
|
}
|
|
|
|
cinfo->col_data[col] = cinfo->col_buf[col];
|
2009-08-19 07:55:11 +00:00
|
|
|
cinfo->col_expr.col_expr[col] = fieldname;
|
|
|
|
g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
|
2007-10-03 14:02:08 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-04-01 07:32:35 +00:00
|
|
|
static void
|
2013-06-04 21:36:47 +00:00
|
|
|
col_set_addr(packet_info *pinfo, const int col, const address *addr, const gboolean is_src,
|
|
|
|
const gboolean fill_col_exprs, const gboolean res)
|
2001-04-01 07:32:35 +00:00
|
|
|
{
|
2009-09-11 14:21:04 +00:00
|
|
|
if (addr->type == AT_NONE) {
|
2009-09-07 16:05:37 +00:00
|
|
|
/* No address, nothing to do */
|
|
|
|
return;
|
2009-09-11 14:21:04 +00:00
|
|
|
}
|
2007-08-17 19:34:14 +00:00
|
|
|
|
2013-06-04 21:36:47 +00:00
|
|
|
if (res)
|
|
|
|
pinfo->cinfo->col_data[col] = se_get_addr_name(addr);
|
|
|
|
else
|
|
|
|
pinfo->cinfo->col_data[col] = se_address_to_str(addr);
|
2003-08-26 01:30:48 +00:00
|
|
|
|
2009-09-08 19:00:54 +00:00
|
|
|
if (!fill_col_exprs)
|
|
|
|
return;
|
|
|
|
|
2001-04-01 07:32:35 +00:00
|
|
|
switch (addr->type) {
|
2012-08-02 16:54:43 +00:00
|
|
|
case AT_AX25:
|
|
|
|
if (is_src)
|
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "ax25.src";
|
|
|
|
else
|
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "ax25.dst";
|
2014-01-14 18:16:12 +00:00
|
|
|
g_strlcpy(pinfo->cinfo->col_expr.col_expr_val[col], ax25_to_str((const guint8 *)addr->data), COL_MAX_LEN);
|
2012-08-02 16:54:43 +00:00
|
|
|
break;
|
|
|
|
|
2001-04-01 07:32:35 +00:00
|
|
|
case AT_ETHER:
|
2012-10-26 00:42:34 +00:00
|
|
|
if (is_src)
|
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "eth.src";
|
|
|
|
else
|
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "eth.dst";
|
|
|
|
address_to_str_buf(addr, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
|
2001-04-01 07:32:35 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case AT_IPv4:
|
2002-01-11 08:21:02 +00:00
|
|
|
if (is_src)
|
2009-08-19 07:55:11 +00:00
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "ip.src";
|
2002-01-11 08:21:02 +00:00
|
|
|
else
|
2009-08-19 07:55:11 +00:00
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "ip.dst";
|
2014-01-14 18:16:12 +00:00
|
|
|
ip_to_str_buf((const guint8 *)addr->data, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
|
2001-04-01 07:32:35 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case AT_IPv6:
|
2002-01-11 08:21:02 +00:00
|
|
|
if (is_src)
|
2009-08-19 07:55:11 +00:00
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "ipv6.src";
|
2002-01-11 08:21:02 +00:00
|
|
|
else
|
2009-08-19 07:55:11 +00:00
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "ipv6.dst";
|
2010-02-23 19:28:38 +00:00
|
|
|
address_to_str_buf(addr, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
|
2001-04-01 07:32:35 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case AT_ATALK:
|
2002-06-28 20:13:03 +00:00
|
|
|
if (is_src)
|
2009-08-19 07:55:11 +00:00
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "ddp.src";
|
2002-06-28 20:13:03 +00:00
|
|
|
else
|
2009-08-19 07:55:11 +00:00
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "ddp.dst";
|
2008-03-02 23:45:24 +00:00
|
|
|
g_strlcpy(pinfo->cinfo->col_expr.col_expr_val[col], pinfo->cinfo->col_buf[col], COL_MAX_LEN);
|
2001-04-01 07:32:35 +00:00
|
|
|
break;
|
|
|
|
|
2002-10-18 21:40:13 +00:00
|
|
|
case AT_ARCNET:
|
|
|
|
if (is_src)
|
2009-08-19 07:55:11 +00:00
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "arcnet.src";
|
2002-10-18 21:40:13 +00:00
|
|
|
else
|
2009-08-19 07:55:11 +00:00
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "arcnet.dst";
|
2008-03-02 23:45:24 +00:00
|
|
|
g_strlcpy(pinfo->cinfo->col_expr.col_expr_val[col], pinfo->cinfo->col_buf[col], COL_MAX_LEN);
|
2002-10-18 21:40:13 +00:00
|
|
|
break;
|
|
|
|
|
2007-09-28 19:00:45 +00:00
|
|
|
case AT_URI:
|
|
|
|
if (is_src)
|
2009-08-19 07:55:11 +00:00
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "uri.src";
|
2007-09-28 19:00:45 +00:00
|
|
|
else
|
2009-08-19 07:55:11 +00:00
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "uri.dst";
|
2008-03-01 05:16:45 +00:00
|
|
|
address_to_str_buf(addr, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
|
2007-09-28 19:00:45 +00:00
|
|
|
break;
|
|
|
|
|
2001-04-01 07:32:35 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2012-10-26 01:59:17 +00:00
|
|
|
|
2012-10-27 02:48:45 +00:00
|
|
|
/* Some addresses (e.g. ieee80211) use a standard format like AT_ETHER but
|
|
|
|
* don't use the same hf_ value (and thus don't use the same filter string).
|
|
|
|
* Such address can use the SET_ADDRESS_HF macro to pass in the specific hf_
|
|
|
|
* value they use. If they did so, we overwrite the default filter string
|
|
|
|
* with their specific one here. See bug #7728 for further discussion.
|
|
|
|
* https://bugs.wireshark.org/bugzilla/show_bug.cgi?id=7728 */
|
2012-10-26 01:59:17 +00:00
|
|
|
if (addr->hf != -1) {
|
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = proto_registrar_get_nth(addr->hf)->abbrev;
|
|
|
|
}
|
|
|
|
|
2001-04-01 07:32:35 +00:00
|
|
|
}
|
|
|
|
|
2009-08-19 07:55:11 +00:00
|
|
|
/* ------------------------ */
|
2001-04-01 07:32:35 +00:00
|
|
|
static void
|
2010-04-03 18:18:50 +00:00
|
|
|
col_set_port(packet_info *pinfo, const int col, const gboolean is_res, const gboolean is_src, const gboolean fill_col_exprs _U_)
|
2001-04-01 07:32:35 +00:00
|
|
|
{
|
2002-12-10 01:17:21 +00:00
|
|
|
guint32 port;
|
|
|
|
|
|
|
|
if (is_src)
|
|
|
|
port = pinfo->srcport;
|
|
|
|
else
|
|
|
|
port = pinfo->destport;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2009-09-08 19:00:54 +00:00
|
|
|
/* TODO: Use fill_col_exprs */
|
|
|
|
|
2009-08-22 19:29:44 +00:00
|
|
|
switch (pinfo->ptype) {
|
2001-04-01 07:32:35 +00:00
|
|
|
case PT_SCTP:
|
|
|
|
if (is_res)
|
2007-10-26 05:42:12 +00:00
|
|
|
g_strlcpy(pinfo->cinfo->col_buf[col], get_sctp_port(port), COL_MAX_LEN);
|
2001-04-01 07:32:35 +00:00
|
|
|
else
|
2010-02-23 19:28:38 +00:00
|
|
|
guint32_to_str_buf(port, pinfo->cinfo->col_buf[col], COL_MAX_LEN);
|
2001-04-01 07:32:35 +00:00
|
|
|
break;
|
2002-08-28 20:41:00 +00:00
|
|
|
|
2001-04-01 07:32:35 +00:00
|
|
|
case PT_TCP:
|
2010-02-23 19:28:38 +00:00
|
|
|
guint32_to_str_buf(port, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
|
2001-04-01 07:32:35 +00:00
|
|
|
if (is_res)
|
2007-10-26 05:42:12 +00:00
|
|
|
g_strlcpy(pinfo->cinfo->col_buf[col], get_tcp_port(port), COL_MAX_LEN);
|
2001-04-01 07:32:35 +00:00
|
|
|
else
|
2009-08-19 07:55:11 +00:00
|
|
|
g_strlcpy(pinfo->cinfo->col_buf[col], pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
|
2002-01-11 08:21:02 +00:00
|
|
|
if (is_src)
|
2009-08-19 07:55:11 +00:00
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "tcp.srcport";
|
2002-01-11 08:21:02 +00:00
|
|
|
else
|
2009-08-19 07:55:11 +00:00
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "tcp.dstport";
|
2001-04-01 07:32:35 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case PT_UDP:
|
2010-02-23 19:28:38 +00:00
|
|
|
guint32_to_str_buf(port, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
|
2001-04-01 07:32:35 +00:00
|
|
|
if (is_res)
|
2007-10-26 05:42:12 +00:00
|
|
|
g_strlcpy(pinfo->cinfo->col_buf[col], get_udp_port(port), COL_MAX_LEN);
|
2001-04-01 07:32:35 +00:00
|
|
|
else
|
2009-08-19 07:55:11 +00:00
|
|
|
g_strlcpy(pinfo->cinfo->col_buf[col], pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
|
2002-01-11 08:21:02 +00:00
|
|
|
if (is_src)
|
2009-08-19 07:55:11 +00:00
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "udp.srcport";
|
2002-01-11 08:21:02 +00:00
|
|
|
else
|
2009-08-19 07:55:11 +00:00
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "udp.dstport";
|
2001-04-01 07:32:35 +00:00
|
|
|
break;
|
|
|
|
|
2002-06-28 20:13:03 +00:00
|
|
|
case PT_DDP:
|
|
|
|
if (is_src)
|
2009-08-19 07:55:11 +00:00
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "ddp.src_socket";
|
2002-06-28 20:13:03 +00:00
|
|
|
else
|
2009-08-19 07:55:11 +00:00
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "ddp.dst_socket";
|
2010-02-23 19:28:38 +00:00
|
|
|
guint32_to_str_buf(port, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
|
2009-08-19 07:55:11 +00:00
|
|
|
g_strlcpy(pinfo->cinfo->col_buf[col], pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
|
2002-06-28 20:13:03 +00:00
|
|
|
break;
|
|
|
|
|
Add a new port type, PT_IPX, for IPX socket numbers; set "pinfo->ptype",
"pinfo->srcport", and "pinfo->destport" appropriately in the IPX
dissector. Add support for PT_IPX port types in display columns.
Have an "spx.socket" dissector table, similar to the "ipx.socket"
dissector table, and have the SPX dissector use that, with the IPX
socket numbers from "pinfo->srcport" and "pinfo->destport", so that
dissectors for protocols that run atop SPX can register with particular
socket numbers. (Think of it as similar to what would have been the
case had the IP header had 16-bit source and destination port numbers,
and had TCP and UDP used those port numbers rather than having port
numbers in their headers.) Also, have the SPX dissector dissect
subprotocols regardless of whether we're building a protocol tree or not.
Use the dissector handle for the IPX message dissector for both IPX
socket numbers; there's no need to create separate handles for both
registrations.
Have NDPS register as a subdissector of the SPX dissector, using
"spx.socket", and get rid of the duplicate SPX dissection in the NDPS
dissector.
Make the NDPS dissector set the columns regardless of whether a protocol
tree is being built, and clean up the dissector (fixing some bugs).
Get rid of unneeded includes in "packet-ndps.c".
svn path=/trunk/; revision=6424
2002-10-15 04:31:00 +00:00
|
|
|
case PT_IPX:
|
|
|
|
/* XXX - resolve IPX socket numbers */
|
2005-08-08 18:50:39 +00:00
|
|
|
g_snprintf(pinfo->cinfo->col_buf[col], COL_MAX_LEN, "0x%04x", port);
|
2009-08-19 07:55:11 +00:00
|
|
|
g_strlcpy(pinfo->cinfo->col_expr.col_expr_val[col], pinfo->cinfo->col_buf[col],COL_MAX_LEN);
|
Add a new port type, PT_IPX, for IPX socket numbers; set "pinfo->ptype",
"pinfo->srcport", and "pinfo->destport" appropriately in the IPX
dissector. Add support for PT_IPX port types in display columns.
Have an "spx.socket" dissector table, similar to the "ipx.socket"
dissector table, and have the SPX dissector use that, with the IPX
socket numbers from "pinfo->srcport" and "pinfo->destport", so that
dissectors for protocols that run atop SPX can register with particular
socket numbers. (Think of it as similar to what would have been the
case had the IP header had 16-bit source and destination port numbers,
and had TCP and UDP used those port numbers rather than having port
numbers in their headers.) Also, have the SPX dissector dissect
subprotocols regardless of whether we're building a protocol tree or not.
Use the dissector handle for the IPX message dissector for both IPX
socket numbers; there's no need to create separate handles for both
registrations.
Have NDPS register as a subdissector of the SPX dissector, using
"spx.socket", and get rid of the duplicate SPX dissection in the NDPS
dissector.
Make the NDPS dissector set the columns regardless of whether a protocol
tree is being built, and clean up the dissector (fixing some bugs).
Get rid of unneeded includes in "packet-ndps.c".
svn path=/trunk/; revision=6424
2002-10-15 04:31:00 +00:00
|
|
|
if (is_src)
|
2009-08-19 07:55:11 +00:00
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "ipx.src.socket";
|
Add a new port type, PT_IPX, for IPX socket numbers; set "pinfo->ptype",
"pinfo->srcport", and "pinfo->destport" appropriately in the IPX
dissector. Add support for PT_IPX port types in display columns.
Have an "spx.socket" dissector table, similar to the "ipx.socket"
dissector table, and have the SPX dissector use that, with the IPX
socket numbers from "pinfo->srcport" and "pinfo->destport", so that
dissectors for protocols that run atop SPX can register with particular
socket numbers. (Think of it as similar to what would have been the
case had the IP header had 16-bit source and destination port numbers,
and had TCP and UDP used those port numbers rather than having port
numbers in their headers.) Also, have the SPX dissector dissect
subprotocols regardless of whether we're building a protocol tree or not.
Use the dissector handle for the IPX message dissector for both IPX
socket numbers; there's no need to create separate handles for both
registrations.
Have NDPS register as a subdissector of the SPX dissector, using
"spx.socket", and get rid of the duplicate SPX dissection in the NDPS
dissector.
Make the NDPS dissector set the columns regardless of whether a protocol
tree is being built, and clean up the dissector (fixing some bugs).
Get rid of unneeded includes in "packet-ndps.c".
svn path=/trunk/; revision=6424
2002-10-15 04:31:00 +00:00
|
|
|
else
|
2009-08-19 07:55:11 +00:00
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "ipx.dst.socket";
|
2005-03-06 20:13:58 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case PT_IDP:
|
|
|
|
/* XXX - resolve IDP socket numbers */
|
2005-08-08 18:50:39 +00:00
|
|
|
g_snprintf(pinfo->cinfo->col_buf[col], COL_MAX_LEN, "0x%04x", port);
|
2009-08-19 07:55:11 +00:00
|
|
|
g_strlcpy(pinfo->cinfo->col_expr.col_expr_val[col], pinfo->cinfo->col_buf[col],COL_MAX_LEN);
|
2005-03-06 20:13:58 +00:00
|
|
|
if (is_src)
|
2009-08-19 07:55:11 +00:00
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "idp.src.socket";
|
2005-03-06 20:13:58 +00:00
|
|
|
else
|
2009-08-19 07:55:11 +00:00
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "idp.dst.socket";
|
Add a new port type, PT_IPX, for IPX socket numbers; set "pinfo->ptype",
"pinfo->srcport", and "pinfo->destport" appropriately in the IPX
dissector. Add support for PT_IPX port types in display columns.
Have an "spx.socket" dissector table, similar to the "ipx.socket"
dissector table, and have the SPX dissector use that, with the IPX
socket numbers from "pinfo->srcport" and "pinfo->destport", so that
dissectors for protocols that run atop SPX can register with particular
socket numbers. (Think of it as similar to what would have been the
case had the IP header had 16-bit source and destination port numbers,
and had TCP and UDP used those port numbers rather than having port
numbers in their headers.) Also, have the SPX dissector dissect
subprotocols regardless of whether we're building a protocol tree or not.
Use the dissector handle for the IPX message dissector for both IPX
socket numbers; there's no need to create separate handles for both
registrations.
Have NDPS register as a subdissector of the SPX dissector, using
"spx.socket", and get rid of the duplicate SPX dissection in the NDPS
dissector.
Make the NDPS dissector set the columns regardless of whether a protocol
tree is being built, and clean up the dissector (fixing some bugs).
Get rid of unneeded includes in "packet-ndps.c".
svn path=/trunk/; revision=6424
2002-10-15 04:31:00 +00:00
|
|
|
break;
|
|
|
|
|
2006-10-15 06:10:59 +00:00
|
|
|
case PT_USB:
|
|
|
|
/* XXX - resolve USB endpoint numbers */
|
|
|
|
g_snprintf(pinfo->cinfo->col_buf[col], COL_MAX_LEN, "0x%08x", port);
|
2009-08-19 07:55:11 +00:00
|
|
|
g_strlcpy(pinfo->cinfo->col_expr.col_expr_val[col], pinfo->cinfo->col_buf[col],COL_MAX_LEN);
|
2006-10-15 06:10:59 +00:00
|
|
|
if (is_src)
|
2009-08-19 07:55:11 +00:00
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "usb.src.endpoint";
|
2006-10-15 06:10:59 +00:00
|
|
|
else
|
2009-08-19 07:55:11 +00:00
|
|
|
pinfo->cinfo->col_expr.col_expr[col] = "usb.dst.endpoint";
|
2006-10-15 06:10:59 +00:00
|
|
|
break;
|
|
|
|
|
2001-04-01 07:32:35 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2001-12-10 00:26:21 +00:00
|
|
|
pinfo->cinfo->col_data[col] = pinfo->cinfo->col_buf[col];
|
2001-04-01 07:32:35 +00:00
|
|
|
}
|
|
|
|
|
2009-07-27 03:34:57 +00:00
|
|
|
gboolean
|
2010-04-03 18:18:50 +00:00
|
|
|
col_based_on_frame_data(column_info *cinfo, const gint col)
|
2001-04-01 07:32:35 +00:00
|
|
|
{
|
2013-06-25 19:38:15 +00:00
|
|
|
g_assert(cinfo);
|
|
|
|
g_assert(col < cinfo->num_cols);
|
|
|
|
|
|
|
|
switch (cinfo->col_fmt[col]) {
|
|
|
|
case COL_NUMBER:
|
|
|
|
case COL_CLS_TIME:
|
|
|
|
case COL_ABS_TIME:
|
2013-11-06 20:39:09 +00:00
|
|
|
case COL_ABS_YMD_TIME:
|
|
|
|
case COL_ABS_YDOY_TIME:
|
2013-06-25 19:38:15 +00:00
|
|
|
case COL_UTC_TIME:
|
2013-11-06 20:39:09 +00:00
|
|
|
case COL_UTC_YMD_TIME:
|
|
|
|
case COL_UTC_YDOY_TIME:
|
2013-06-25 19:38:15 +00:00
|
|
|
case COL_REL_TIME:
|
|
|
|
case COL_DELTA_TIME:
|
|
|
|
case COL_DELTA_TIME_DIS:
|
|
|
|
case COL_PACKET_LENGTH:
|
|
|
|
case COL_CUMULATIVE_BYTES:
|
|
|
|
return TRUE;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
default:
|
|
|
|
return FALSE;
|
|
|
|
}
|
2009-07-27 03:34:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-04-03 18:18:50 +00:00
|
|
|
col_fill_in_frame_data(const frame_data *fd, column_info *cinfo, const gint col, const gboolean fill_col_exprs)
|
2009-07-27 03:34:57 +00:00
|
|
|
{
|
2013-06-25 19:38:15 +00:00
|
|
|
switch (cinfo->col_fmt[col]) {
|
|
|
|
case COL_NUMBER:
|
|
|
|
guint32_to_str_buf(fd->num, cinfo->col_buf[col], COL_MAX_LEN);
|
|
|
|
cinfo->col_data[col] = cinfo->col_buf[col];
|
|
|
|
break;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
case COL_CLS_TIME:
|
|
|
|
case COL_ABS_TIME:
|
2013-11-06 20:39:09 +00:00
|
|
|
case COL_ABS_YMD_TIME:
|
|
|
|
case COL_ABS_YDOY_TIME:
|
2013-06-25 19:38:15 +00:00
|
|
|
case COL_UTC_TIME:
|
2013-11-06 20:39:09 +00:00
|
|
|
case COL_UTC_YMD_TIME:
|
|
|
|
case COL_UTC_YDOY_TIME:
|
2013-06-25 19:38:15 +00:00
|
|
|
case COL_REL_TIME:
|
|
|
|
case COL_DELTA_TIME:
|
|
|
|
case COL_DELTA_TIME_DIS:
|
|
|
|
/* TODO: Pass on fill_col_exprs */
|
|
|
|
col_set_fmt_time(fd, cinfo, cinfo->col_fmt[col], col);
|
|
|
|
break;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
case COL_PACKET_LENGTH:
|
|
|
|
guint32_to_str_buf(fd->pkt_len, cinfo->col_buf[col], COL_MAX_LEN);
|
|
|
|
cinfo->col_data[col] = cinfo->col_buf[col];
|
|
|
|
break;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
case COL_CUMULATIVE_BYTES:
|
|
|
|
guint32_to_str_buf(fd->cum_bytes, cinfo->col_buf[col], COL_MAX_LEN);
|
|
|
|
cinfo->col_data[col] = cinfo->col_buf[col];
|
|
|
|
break;
|
2009-09-08 19:00:54 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2009-09-08 19:00:54 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
if (!fill_col_exprs)
|
|
|
|
return;
|
2009-09-08 19:00:54 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
switch (cinfo->col_fmt[col]) {
|
|
|
|
case COL_NUMBER:
|
|
|
|
cinfo->col_expr.col_expr[col] = "frame.number";
|
|
|
|
g_strlcpy(cinfo->col_expr.col_expr_val[col], cinfo->col_buf[col], COL_MAX_LEN);
|
|
|
|
break;
|
2009-09-08 19:00:54 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
case COL_CLS_TIME:
|
|
|
|
case COL_ABS_TIME:
|
2013-11-06 20:39:09 +00:00
|
|
|
case COL_ABS_YMD_TIME:
|
|
|
|
case COL_ABS_YDOY_TIME:
|
2013-06-25 19:38:15 +00:00
|
|
|
case COL_UTC_TIME:
|
2013-11-06 20:39:09 +00:00
|
|
|
case COL_UTC_YMD_TIME:
|
|
|
|
case COL_UTC_YDOY_TIME:
|
2013-06-25 19:38:15 +00:00
|
|
|
case COL_REL_TIME:
|
|
|
|
case COL_DELTA_TIME:
|
|
|
|
case COL_DELTA_TIME_DIS:
|
|
|
|
/* Already handled above */
|
|
|
|
break;
|
2009-09-08 19:00:54 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
case COL_PACKET_LENGTH:
|
|
|
|
cinfo->col_expr.col_expr[col] = "frame.len";
|
|
|
|
g_strlcpy(cinfo->col_expr.col_expr_val[col], cinfo->col_buf[col], COL_MAX_LEN);
|
|
|
|
break;
|
2009-09-08 19:00:54 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
case COL_CUMULATIVE_BYTES:
|
|
|
|
break;
|
2009-09-08 19:00:54 +00:00
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2009-07-27 03:34:57 +00:00
|
|
|
}
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2009-07-27 03:34:57 +00:00
|
|
|
void
|
2010-04-03 18:18:50 +00:00
|
|
|
col_fill_in(packet_info *pinfo, const gboolean fill_col_exprs, const gboolean fill_fd_colums)
|
2009-07-27 03:34:57 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2009-08-10 20:52:56 +00:00
|
|
|
if (!pinfo->cinfo)
|
|
|
|
return;
|
|
|
|
|
2009-07-27 03:34:57 +00:00
|
|
|
for (i = 0; i < pinfo->cinfo->num_cols; i++) {
|
2014-01-06 23:02:32 +00:00
|
|
|
if (col_based_on_frame_data(pinfo->cinfo, i)) {
|
2009-07-27 08:33:26 +00:00
|
|
|
if (fill_fd_colums)
|
2009-09-08 19:00:54 +00:00
|
|
|
col_fill_in_frame_data(pinfo->fd, pinfo->cinfo, i, fill_col_exprs);
|
2014-01-06 23:02:32 +00:00
|
|
|
} else {
|
|
|
|
switch (pinfo->cinfo->col_fmt[i]) {
|
|
|
|
case COL_DEF_SRC:
|
|
|
|
case COL_RES_SRC: /* COL_DEF_SRC is currently just like COL_RES_SRC */
|
|
|
|
col_set_addr(pinfo, i, &pinfo->src, TRUE, fill_col_exprs, TRUE);
|
|
|
|
break;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2014-01-06 23:02:32 +00:00
|
|
|
case COL_UNRES_SRC:
|
|
|
|
col_set_addr(pinfo, i, &pinfo->src, TRUE, fill_col_exprs, FALSE);
|
|
|
|
break;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2014-01-06 23:02:32 +00:00
|
|
|
case COL_DEF_DL_SRC:
|
|
|
|
case COL_RES_DL_SRC:
|
|
|
|
col_set_addr(pinfo, i, &pinfo->dl_src, TRUE, fill_col_exprs, TRUE);
|
|
|
|
break;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2014-01-06 23:02:32 +00:00
|
|
|
case COL_UNRES_DL_SRC:
|
|
|
|
col_set_addr(pinfo, i, &pinfo->dl_src, TRUE, fill_col_exprs, FALSE);
|
|
|
|
break;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2014-01-06 23:02:32 +00:00
|
|
|
case COL_DEF_NET_SRC:
|
|
|
|
case COL_RES_NET_SRC:
|
|
|
|
col_set_addr(pinfo, i, &pinfo->net_src, TRUE, fill_col_exprs, TRUE);
|
|
|
|
break;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2014-01-06 23:02:32 +00:00
|
|
|
case COL_UNRES_NET_SRC:
|
|
|
|
col_set_addr(pinfo, i, &pinfo->net_src, TRUE, fill_col_exprs, FALSE);
|
|
|
|
break;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2014-01-06 23:02:32 +00:00
|
|
|
case COL_DEF_DST:
|
|
|
|
case COL_RES_DST: /* COL_DEF_DST is currently just like COL_RES_DST */
|
|
|
|
col_set_addr(pinfo, i, &pinfo->dst, FALSE, fill_col_exprs, TRUE);
|
|
|
|
break;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2014-01-06 23:02:32 +00:00
|
|
|
case COL_UNRES_DST:
|
|
|
|
col_set_addr(pinfo, i, &pinfo->dst, FALSE, fill_col_exprs, FALSE);
|
|
|
|
break;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2014-01-06 23:02:32 +00:00
|
|
|
case COL_DEF_DL_DST:
|
|
|
|
case COL_RES_DL_DST:
|
|
|
|
col_set_addr(pinfo, i, &pinfo->dl_dst, FALSE, fill_col_exprs, TRUE);
|
|
|
|
break;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2014-01-06 23:02:32 +00:00
|
|
|
case COL_UNRES_DL_DST:
|
|
|
|
col_set_addr(pinfo, i, &pinfo->dl_dst, FALSE, fill_col_exprs, FALSE);
|
|
|
|
break;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2014-01-06 23:02:32 +00:00
|
|
|
case COL_DEF_NET_DST:
|
|
|
|
case COL_RES_NET_DST:
|
|
|
|
col_set_addr(pinfo, i, &pinfo->net_dst, FALSE, fill_col_exprs, TRUE);
|
|
|
|
break;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2014-01-06 23:02:32 +00:00
|
|
|
case COL_UNRES_NET_DST:
|
|
|
|
col_set_addr(pinfo, i, &pinfo->net_dst, FALSE, fill_col_exprs, FALSE);
|
|
|
|
break;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2014-01-06 23:02:32 +00:00
|
|
|
case COL_DEF_SRC_PORT:
|
|
|
|
case COL_RES_SRC_PORT: /* COL_DEF_SRC_PORT is currently just like COL_RES_SRC_PORT */
|
|
|
|
col_set_port(pinfo, i, TRUE, TRUE, fill_col_exprs);
|
|
|
|
break;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2014-01-06 23:02:32 +00:00
|
|
|
case COL_UNRES_SRC_PORT:
|
|
|
|
col_set_port(pinfo, i, FALSE, TRUE, fill_col_exprs);
|
|
|
|
break;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2014-01-06 23:02:32 +00:00
|
|
|
case COL_DEF_DST_PORT:
|
|
|
|
case COL_RES_DST_PORT: /* COL_DEF_DST_PORT is currently just like COL_RES_DST_PORT */
|
|
|
|
col_set_port(pinfo, i, TRUE, FALSE, fill_col_exprs);
|
|
|
|
break;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2014-01-06 23:02:32 +00:00
|
|
|
case COL_UNRES_DST_PORT:
|
|
|
|
col_set_port(pinfo, i, FALSE, FALSE, fill_col_exprs);
|
|
|
|
break;
|
2001-04-01 07:32:35 +00:00
|
|
|
|
2014-01-06 23:02:32 +00:00
|
|
|
case NUM_COL_FMTS: /* keep compiler happy - shouldn't get here */
|
2010-04-30 20:49:41 +00:00
|
|
|
g_assert_not_reached();
|
2014-01-06 23:02:32 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (pinfo->cinfo->col_fmt[i] >= NUM_COL_FMTS) {
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Formatting handled by col_custom_set_edt() (COL_CUSTOM), expert.c
|
|
|
|
* (COL_EXPERT), or individual dissectors.
|
|
|
|
*/
|
|
|
|
break;
|
2010-04-30 20:49:41 +00:00
|
|
|
}
|
2001-04-01 07:32:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-09-06 13:35:27 +00:00
|
|
|
|
2011-04-09 04:33:26 +00:00
|
|
|
/*
|
|
|
|
* Fill in columns if we got an error reading the packet.
|
2014-01-06 23:07:48 +00:00
|
|
|
* We set most columns to "???", fill in columns that don't need data read
|
|
|
|
* from the file, and set the Info column to an error message.
|
2011-04-09 04:33:26 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
col_fill_in_error(column_info *cinfo, frame_data *fdata, const gboolean fill_col_exprs, const gboolean fill_fd_colums)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!cinfo)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < cinfo->num_cols; i++) {
|
2014-01-06 23:02:32 +00:00
|
|
|
if (col_based_on_frame_data(cinfo, i)) {
|
2011-04-09 04:33:26 +00:00
|
|
|
if (fill_fd_colums)
|
|
|
|
col_fill_in_frame_data(fdata, cinfo, i, fill_col_exprs);
|
2014-01-06 23:02:32 +00:00
|
|
|
} else if (cinfo->col_fmt[i] == COL_INFO) {
|
2011-04-09 04:33:26 +00:00
|
|
|
/* XXX - say more than this */
|
|
|
|
cinfo->col_data[i] = "Read error";
|
2014-01-06 23:02:32 +00:00
|
|
|
} else {
|
2011-04-09 04:33:26 +00:00
|
|
|
if (cinfo->col_fmt[i] >= NUM_COL_FMTS) {
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* No dissection was done, and these columns are set as the
|
|
|
|
* result of the dissection, so....
|
|
|
|
*/
|
|
|
|
cinfo->col_data[i] = "???";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-25 19:38:15 +00:00
|
|
|
/*
|
|
|
|
* Editor modelines
|
|
|
|
*
|
|
|
|
* Local Variables:
|
|
|
|
* c-basic-offset: 2
|
|
|
|
* tab-width: 8
|
|
|
|
* indent-tabs-mode: nil
|
|
|
|
* End:
|
|
|
|
*
|
|
|
|
* ex: set shiftwidth=2 tabstop=8 expandtab:
|
|
|
|
* :indentSize=2:tabSize=8:noTabs=true:
|
|
|
|
*/
|