/* catapult_dct2000.c
- *
- * $Id$
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@alumni.rice.edu>
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#ifdef HAVE_CONFIG_H
#include "config.h"
-#endif
#include <errno.h>
#include <string.h>
#include <stdlib.h>
-#include <ctype.h>
#include "wtap-int.h"
#include "file_wrappers.h"
-#include "buffer.h"
#include "catapult_dct2000.h"
#define MAX_FIRST_LINE_LENGTH 200
#define MAX_TIMESTAMP_LINE_LENGTH 100
-#define MAX_LINE_LENGTH 32000
+#define MAX_LINE_LENGTH 65536
+#define MAX_TIMESTAMP_LEN 32
#define MAX_SECONDS_CHARS 16
#define MAX_SUBSECOND_DECIMALS 4
#define MAX_CONTEXT_NAME 64
/*******************************************************************/
-/* Information stored external to a file (wtap) needed for dumping */
+/* Information stored external to a file (wtap) needed for reading and dumping */
typedef struct dct2000_file_externals
{
+ /* Remember the time at the start of capture */
+ time_t start_secs;
+ guint32 start_usecs;
+
+ /*
+ * The following information is needed only for dumping.
+ *
+ * XXX - Wiretap is not *supposed* to require that a packet being
+ * dumped come from a file of the same type that you currently have
+ * open; this should be fixed.
+ */
+
/* Buffer to hold first line, including magic and format number */
gchar firstline[MAX_FIRST_LINE_LENGTH];
gint firstline_length;
/* Hash table to store text prefix data part of displayed packets.
Records (file offset -> line_prefix_info_t)
- N.B. This is only needed for dumping
*/
GHashTable *packet_prefix_table;
} dct2000_file_externals_t;
-/* This global table maps wtap -> dct2000_file_externals_t structs */
-static GHashTable *file_externals_table = NULL;
-
-
-/***********************************************************/
-/* Transient data used for parsing */
-
-/* Buffer to hold a single text line read from the file */
-static gchar linebuff[MAX_LINE_LENGTH];
-
-/* Buffer for separate AAL header */
-static gchar aal_header_chars[AAL_HEADER_CHARS];
-
/* 'Magic number' at start of Catapult DCT2000 .out files. */
static const gchar catapult_dct2000_magic[] = "Session Transcript";
-/* Context name + port that the packet was captured at */
-static gchar context_name[MAX_CONTEXT_NAME];
-static guint8 context_port;
-
-/* The DCT2000 protocol name of the packet, plus variant number */
-static gchar protocol_name[MAX_PROTOCOL_NAME+1];
-static gchar variant_name[MAX_VARIANT_DIGITS+1];
-static gchar outhdr_name[MAX_OUTHDR_NAME+1];
-
-
/************************************************************/
/* Functions called from wiretap core */
static gboolean catapult_dct2000_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
static gboolean catapult_dct2000_seek_read(wtap *wth, gint64 seek_off,
- union wtap_pseudo_header *pseudo_header,
- guchar *pd, int length,
- int *err, gchar **err_info);
+ struct wtap_pkthdr *phdr,
+ Buffer *buf, int *err,
+ gchar **err_info);
static void catapult_dct2000_close(wtap *wth);
static gboolean catapult_dct2000_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
- const union wtap_pseudo_header *pseudo_header,
- const guchar *pd, int *err);
-static gboolean catapult_dct2000_dump_close(wtap_dumper *wdh, int *err);
+ const guint8 *pd, int *err, gchar **err_info);
/************************************************************/
/* Private helper functions */
-static gboolean read_new_line(FILE_T fh, gint64 *offset, gint *length);
-static gboolean parse_line(gint line_length, gint *seconds, gint *useconds,
+static gboolean read_new_line(FILE_T fh, gint64 *offset, gint *length,
+ gchar *buf, size_t bufsize, int *err,
+ gchar **err_info);
+static gboolean parse_line(char *linebuff, gint line_length,
+ gint *seconds, gint *useconds,
long *before_time_offset, long *after_time_offset,
long *data_offset,
gint *data_chars,
packet_direction_t *direction,
- int *encap);
-static int write_stub_header(guchar *frame_buffer, char *timestamp_string,
- packet_direction_t direction, int encap);
-static guchar hex_from_char(gchar c);
-static gchar char_from_hex(guchar hex);
-
-static void set_pseudo_header_info(wtap *wth,
- int pkt_encap,
- gint64 file_offset,
- union wtap_pseudo_header *pseudo_header,
- packet_direction_t direction);
+ int *encap, int *is_comment, int *is_sprint,
+ gchar *aal_header_chars,
+ gchar *context_name, guint8 *context_portp,
+ gchar *protocol_name, gchar *variant_name,
+ gchar *outhdr_name);
+static gboolean process_parsed_line(wtap *wth,
+ dct2000_file_externals_t *file_externals,
+ struct wtap_pkthdr *phdr,
+ Buffer *buf, gint64 file_offset,
+ char *linebuff, long dollar_offset,
+ int seconds, int useconds,
+ gchar *timestamp_string,
+ packet_direction_t direction, int encap,
+ gchar *context_name, guint8 context_port,
+ gchar *protocol_name, gchar *variant_name,
+ gchar *outhdr_name, gchar *aal_header_chars,
+ gboolean is_comment, int data_chars,
+ int *err, gchar **err_info);
+static guint8 hex_from_char(gchar c);
+static void prepare_hex_byte_from_chars_table(void);
+static guint8 hex_byte_from_chars(gchar *c);
+static gchar char_from_hex(guint8 hex);
+
static void set_aal_info(union wtap_pseudo_header *pseudo_header,
- packet_direction_t direction);
+ packet_direction_t direction,
+ gchar *aal_header_chars);
static void set_isdn_info(union wtap_pseudo_header *pseudo_header,
packet_direction_t direction);
static void set_ppp_info(union wtap_pseudo_header *pseudo_header,
packet_direction_t direction);
-static gint wth_equal(gconstpointer v, gconstpointer v2);
-static guint wth_hash_func(gconstpointer v);
static gint packet_offset_equal(gconstpointer v, gconstpointer v2);
static guint packet_offset_hash_func(gconstpointer v);
-static gboolean get_file_time_stamp(time_t *secs, guint32 *usecs);
+static gboolean get_file_time_stamp(gchar *linebuff, time_t *secs, guint32 *usecs);
static gboolean free_line_prefix_info(gpointer key, gpointer value, gpointer user_data);
/********************************************/
/* Open file (for reading) */
/********************************************/
-int catapult_dct2000_open(wtap *wth, int *err, gchar **err_info _U_)
+wtap_open_return_val
+catapult_dct2000_open(wtap *wth, int *err, gchar **err_info)
{
gint64 offset = 0;
time_t timestamp;
guint32 usecs;
gint firstline_length = 0;
dct2000_file_externals_t *file_externals;
+ static gchar linebuff[MAX_LINE_LENGTH];
+ static gboolean hex_byte_table_values_set = FALSE;
/* Clear errno before reading from the file */
errno = 0;
/********************************************************************/
/* First line needs to contain at least as many characters as magic */
- read_new_line(wth->fh, &offset, &firstline_length);
+ if (!read_new_line(wth->fh, &offset, &firstline_length, linebuff,
+ sizeof linebuff, err, err_info)) {
+ if (*err != 0 && *err != WTAP_ERR_SHORT_READ)
+ return WTAP_OPEN_ERROR;
+ return WTAP_OPEN_NOT_MINE;
+ }
if (((size_t)firstline_length < strlen(catapult_dct2000_magic)) ||
- firstline_length >= MAX_FIRST_LINE_LENGTH)
- {
- return 0;
+ firstline_length >= MAX_FIRST_LINE_LENGTH) {
+
+ return WTAP_OPEN_NOT_MINE;
}
/* This file is not for us if it doesn't match our signature */
- if (memcmp(catapult_dct2000_magic, linebuff, strlen(catapult_dct2000_magic)) != 0)
- {
- return 0;
+ if (memcmp(catapult_dct2000_magic, linebuff, strlen(catapult_dct2000_magic)) != 0) {
+ return WTAP_OPEN_NOT_MINE;
}
+ /* Make sure table is ready for use */
+ if (!hex_byte_table_values_set) {
+ prepare_hex_byte_from_chars_table();
+ hex_byte_table_values_set = TRUE;
+ }
/*********************************************************************/
/* Need entry in file_externals table */
- /* Create file externals table if it doesn't yet exist */
- if (file_externals_table == NULL)
- {
- file_externals_table = g_hash_table_new(wth_hash_func, wth_equal);
- }
-
/* Allocate a new file_externals structure for this file */
- file_externals = g_malloc(sizeof(dct2000_file_externals_t));
+ file_externals = g_new(dct2000_file_externals_t,1);
memset((void*)file_externals, '\0', sizeof(dct2000_file_externals_t));
/* Copy this first line into buffer so could write out later */
- strncpy(file_externals->firstline, linebuff, firstline_length);
+ g_strlcpy(file_externals->firstline, linebuff, firstline_length+1);
file_externals->firstline_length = firstline_length;
/***********************************************************/
/* Second line contains file timestamp */
- /* Store this offset in in wth->capture->catapult_dct2000 */
+ /* Store this offset in in file_externals */
- read_new_line(wth->fh, &offset, &(file_externals->secondline_length));
+ if (!read_new_line(wth->fh, &offset, &(file_externals->secondline_length),
+ linebuff, sizeof linebuff, err, err_info)) {
+ g_free(file_externals);
+ if (*err != 0 && *err != WTAP_ERR_SHORT_READ)
+ return WTAP_OPEN_ERROR;
+ return WTAP_OPEN_NOT_MINE;
+ }
if ((file_externals->secondline_length >= MAX_TIMESTAMP_LINE_LENGTH) ||
- (!get_file_time_stamp(×tamp, &usecs)))
- {
+ (!get_file_time_stamp(linebuff, ×tamp, &usecs))) {
+
/* Give up if file time line wasn't valid */
g_free(file_externals);
- return 0;
+ return WTAP_OPEN_NOT_MINE;
}
- /* Allocate struct and fill in timestamp */
- wth->capture.catapult_dct2000 = g_malloc(sizeof(catapult_dct2000_t));
- wth->capture.catapult_dct2000->start_secs = timestamp;
- wth->capture.catapult_dct2000->start_usecs = usecs;
+ /* Fill in timestamp */
+ file_externals->start_secs = timestamp;
+ file_externals->start_usecs = usecs;
/* Copy this second line into buffer so could write out later */
- strncpy(file_externals->secondline, linebuff, file_externals->secondline_length);
+ g_strlcpy(file_externals->secondline, linebuff, file_externals->secondline_length+1);
/************************************************************/
/* File is for us. Fill in details so packets can be read */
/* Set our file type */
- wth->file_type = WTAP_FILE_CATAPULT_DCT2000;
+ wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_CATAPULT_DCT2000;
/* Use our own encapsulation to send all packets to our stub dissector */
wth->file_encap = WTAP_ENCAP_CATAPULT_DCT2000;
wth->subtype_close = catapult_dct2000_close;
/* Choose microseconds (have 4 decimal places...) */
- wth->tsprecision = WTAP_FILE_TSPREC_USEC;
+ wth->file_tsprec = WTAP_TSPREC_USEC;
/***************************************************************/
file_externals->packet_prefix_table =
g_hash_table_new(packet_offset_hash_func, packet_offset_equal);
- /* Add file_externals for this wtap into the global table */
- g_hash_table_insert(file_externals_table,
- (void*)wth, (void*)file_externals);
+ /* Set this wtap to point to the file_externals */
+ wth->priv = (void*)file_externals;
*err = errno;
- return 1;
+ return WTAP_OPEN_MINE;
}
+/* Ugly, but much faster than using g_snprintf! */
+static void write_timestamp_string(char *timestamp_string, int secs, int tenthousandths)
+{
+ int idx = 0;
+
+ /* Secs */
+ if (secs < 10) {
+ timestamp_string[idx++] = ((secs % 10)) + '0';
+ }
+ else if (secs < 100) {
+ timestamp_string[idx++] = ( secs / 10) + '0';
+ timestamp_string[idx++] = ((secs % 10)) + '0';
+ }
+ else if (secs < 1000) {
+ timestamp_string[idx++] = ((secs) / 100) + '0';
+ timestamp_string[idx++] = ((secs % 100)) / 10 + '0';
+ timestamp_string[idx++] = ((secs % 10)) + '0';
+ }
+ else if (secs < 10000) {
+ timestamp_string[idx++] = ((secs) / 1000) + '0';
+ timestamp_string[idx++] = ((secs % 1000)) / 100 + '0';
+ timestamp_string[idx++] = ((secs % 100)) / 10 + '0';
+ timestamp_string[idx++] = ((secs % 10)) + '0';
+ }
+ else if (secs < 100000) {
+ timestamp_string[idx++] = ((secs) / 10000) + '0';
+ timestamp_string[idx++] = ((secs % 10000)) / 1000 + '0';
+ timestamp_string[idx++] = ((secs % 1000)) / 100 + '0';
+ timestamp_string[idx++] = ((secs % 100)) / 10 + '0';
+ timestamp_string[idx++] = ((secs % 10)) + '0';
+ }
+ else if (secs < 1000000) {
+ timestamp_string[idx++] = ((secs) / 100000) + '0';
+ timestamp_string[idx++] = ((secs % 100000)) / 10000 + '0';
+ timestamp_string[idx++] = ((secs % 10000)) / 1000 + '0';
+ timestamp_string[idx++] = ((secs % 1000)) / 100 + '0';
+ timestamp_string[idx++] = ((secs % 100)) / 10 + '0';
+ timestamp_string[idx++] = ((secs % 10)) + '0';
+ }
+ else {
+ g_snprintf(timestamp_string, MAX_TIMESTAMP_LEN, "%d.%04d", secs, tenthousandths);
+ return;
+ }
+
+ timestamp_string[idx++] = '.';
+ timestamp_string[idx++] = ( tenthousandths / 1000) + '0';
+ timestamp_string[idx++] = ((tenthousandths % 1000) / 100) + '0';
+ timestamp_string[idx++] = ((tenthousandths % 100) / 10) + '0';
+ timestamp_string[idx++] = ((tenthousandths % 10)) + '0';
+ timestamp_string[idx++] = '\0';
+}
/**************************************************/
/* Read packet function. */
/* Look for and read the next usable packet */
/* - return TRUE and details if found */
/**************************************************/
-gboolean catapult_dct2000_read(wtap *wth, int *err, gchar **err_info _U_,
- gint64 *data_offset)
+static gboolean
+catapult_dct2000_read(wtap *wth, int *err, gchar **err_info,
+ gint64 *data_offset)
{
- gint64 offset = wth->data_offset;
+ gint64 offset = file_tell(wth->fh);
long dollar_offset, before_time_offset, after_time_offset;
packet_direction_t direction;
int encap;
- /* Find wtap external structure for this wtap */
+ /* Get wtap external structure for this wtap */
dct2000_file_externals_t *file_externals =
- (dct2000_file_externals_t*)g_hash_table_lookup(file_externals_table, wth);
-
- /* There *has* to be an entry for this wth */
- if (!file_externals)
- {
- return FALSE;
- }
+ (dct2000_file_externals_t*)wth->priv;
/* Search for a line containing a usable packet */
- while (1)
- {
+ while (1) {
int line_length, seconds, useconds, data_chars;
+ int is_comment = FALSE;
+ int is_sprint = FALSE;
gint64 this_offset = offset;
+ static gchar linebuff[MAX_LINE_LENGTH+1];
+ gchar aal_header_chars[AAL_HEADER_CHARS];
+ gchar context_name[MAX_CONTEXT_NAME];
+ guint8 context_port = 0;
+ gchar protocol_name[MAX_PROTOCOL_NAME+1];
+ gchar variant_name[MAX_VARIANT_DIGITS+1];
+ gchar outhdr_name[MAX_OUTHDR_NAME+1];
/* Are looking for first packet after 2nd line */
- if (wth->data_offset == 0)
- {
+ if (file_tell(wth->fh) == 0) {
this_offset += (file_externals->firstline_length+1+
file_externals->secondline_length+1);
}
- /* Clear errno before reading from the file */
- errno = 0;
-
/* Read a new line from file into linebuff */
- if (read_new_line(wth->fh, &offset, &line_length) == FALSE)
- {
- /* Get out if no more lines can be read */
+ if (!read_new_line(wth->fh, &offset, &line_length, linebuff,
+ sizeof linebuff, err, err_info)) {
+ if (*err != 0)
+ return FALSE; /* error */
+ /* No more lines can be read, so quit. */
break;
}
/* Try to parse the line as a frame record */
- if (parse_line(line_length, &seconds, &useconds,
+ if (parse_line(linebuff, line_length, &seconds, &useconds,
&before_time_offset, &after_time_offset,
&dollar_offset,
- &data_chars, &direction, &encap))
- {
- guchar *frame_buffer;
- int n;
- int stub_offset = 0;
+ &data_chars, &direction, &encap, &is_comment, &is_sprint,
+ aal_header_chars,
+ context_name, &context_port,
+ protocol_name, variant_name, outhdr_name)) {
line_prefix_info_t *line_prefix_info;
- char timestamp_string[32];
+ char timestamp_string[MAX_TIMESTAMP_LEN+1];
gint64 *pkey = NULL;
- g_snprintf(timestamp_string, 32, "%d.%04d", seconds, useconds/100);
-
- /* All packets go to Catapult DCT2000 stub dissector */
- wth->phdr.pkt_encap = WTAP_ENCAP_CATAPULT_DCT2000;
+ write_timestamp_string(timestamp_string, seconds, useconds/100);
/* Set data_offset to the beginning of the line we're returning.
This will be the seek_off parameter when this frame is re-read.
*/
*data_offset = this_offset;
- /* This is the position in the file where the next _read() will be called from */
- wth->data_offset = this_offset + line_length + 1;
-
- /* Fill in timestamp (capture base + packet offset) */
- wth->phdr.ts.secs = wth->capture.catapult_dct2000->start_secs + seconds;
- if ((wth->capture.catapult_dct2000->start_usecs + useconds) >= 1000000)
- {
- wth->phdr.ts.secs++;
- }
- wth->phdr.ts.nsecs =
- ((wth->capture.catapult_dct2000->start_usecs + useconds) % 1000000) *1000;
-
- /* Get buffer pointer ready */
- buffer_assure_space(wth->frame_buffer,
- strlen(context_name)+1 + /* Context name */
- 1 + /* port */
- strlen(timestamp_string)+1 + /* timestamp */
- strlen(variant_name)+1 + /* variant */
- strlen(outhdr_name)+1 + /* outhdr */
- strlen(protocol_name)+1 + /* Protocol name */
- 1 + /* direction */
- 1 + /* encap */
- (data_chars/2));
- frame_buffer = buffer_start_ptr(wth->frame_buffer);
-
-
- /*********************/
- /* Write stub header */
- stub_offset = write_stub_header(frame_buffer, timestamp_string,
- direction, encap);
-
- /* Binary data length is half bytestring length + stub header */
- wth->phdr.len = data_chars/2 + stub_offset;
- wth->phdr.caplen = data_chars/2 + stub_offset;
-
-
- /*************************/
- /* Copy data into buffer */
- for (n=0; n <= data_chars; n+=2)
- {
- frame_buffer[stub_offset + n/2] =
- (hex_from_char(linebuff[dollar_offset+n]) << 4) |
- hex_from_char(linebuff[dollar_offset+n+1]);
- }
+ if (!process_parsed_line(wth, file_externals,
+ &wth->phdr,
+ wth->frame_buffer, this_offset,
+ linebuff, dollar_offset,
+ seconds, useconds,
+ timestamp_string,
+ direction, encap,
+ context_name, context_port,
+ protocol_name, variant_name,
+ outhdr_name, aal_header_chars,
+ is_comment, data_chars,
+ err, err_info))
+ return FALSE;
/* Store the packet prefix in the hash table */
- line_prefix_info = g_malloc(sizeof(line_prefix_info_t));
+ line_prefix_info = g_new(line_prefix_info_t,1);
/* Create and use buffer for contents before time */
- line_prefix_info->before_time = g_malloc(before_time_offset+1);
- strncpy(line_prefix_info->before_time, linebuff, before_time_offset);
+ line_prefix_info->before_time = (gchar *)g_malloc(before_time_offset+1);
+ memcpy(line_prefix_info->before_time, linebuff, before_time_offset);
line_prefix_info->before_time[before_time_offset] = '\0';
/* Create and use buffer for contents before time.
Do this only if it doesn't correspond to " l ", which is by far the most
common case. */
if (((size_t)(dollar_offset - after_time_offset -1) == strlen(" l ")) &&
- (strncmp(linebuff+after_time_offset, " l ", strlen(" l ")) == 0))
- {
+ (strncmp(linebuff+after_time_offset, " l ", strlen(" l ")) == 0)) {
+
line_prefix_info->after_time = NULL;
}
- else
- {
+ else {
/* Allocate & write buffer for line between timestamp and data */
- line_prefix_info->after_time = g_malloc(dollar_offset - after_time_offset);
- strncpy(line_prefix_info->after_time, linebuff+after_time_offset,
- dollar_offset - after_time_offset);
+ line_prefix_info->after_time = (gchar *)g_malloc(dollar_offset - after_time_offset);
+ memcpy(line_prefix_info->after_time, linebuff+after_time_offset, dollar_offset - after_time_offset);
line_prefix_info->after_time[dollar_offset - after_time_offset-1] = '\0';
}
/* Add packet entry into table */
- pkey = g_malloc(sizeof(pkey));
+ pkey = (gint64 *)g_malloc(sizeof(*pkey));
*pkey = this_offset;
g_hash_table_insert(file_externals->packet_prefix_table, pkey, line_prefix_info);
- /* Set pseudo-header if necessary */
- set_pseudo_header_info(wth, encap, this_offset, &wth->pseudo_header,
- direction);
-
/* OK, we have packet details to return */
- *err = errno;
return TRUE;
}
}
/* No packet details to return... */
- *err = errno;
return FALSE;
}
/**************************************************/
static gboolean
catapult_dct2000_seek_read(wtap *wth, gint64 seek_off,
- union wtap_pseudo_header *pseudo_header, guchar *pd,
- int length, int *err, gchar **err_info)
+ struct wtap_pkthdr *phdr, Buffer *buf,
+ int *err, gchar **err_info)
{
- gint64 offset = wth->data_offset;
+ gint64 offset = 0;
+ int length;
long dollar_offset, before_time_offset, after_time_offset;
+ static gchar linebuff[MAX_LINE_LENGTH+1];
+ gchar aal_header_chars[AAL_HEADER_CHARS];
+ gchar context_name[MAX_CONTEXT_NAME];
+ guint8 context_port = 0;
+ gchar protocol_name[MAX_PROTOCOL_NAME+1];
+ gchar variant_name[MAX_VARIANT_DIGITS+1];
+ gchar outhdr_name[MAX_OUTHDR_NAME+1];
+ int is_comment = FALSE;
+ int is_sprint = FALSE;
packet_direction_t direction;
int encap;
int seconds, useconds, data_chars;
+ /* Get wtap external structure for this wtap */
+ dct2000_file_externals_t *file_externals =
+ (dct2000_file_externals_t*)wth->priv;
+
/* Reset errno */
*err = errno = 0;
/* Seek to beginning of packet */
- if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- {
+ if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1) {
return FALSE;
}
/* Re-read whole line (this really should succeed) */
- if (read_new_line(wth->random_fh, &offset, &length) == FALSE)
- {
+ if (!read_new_line(wth->random_fh, &offset, &length, linebuff,
+ sizeof linebuff, err, err_info)) {
return FALSE;
}
/* Try to parse this line again (should succeed as re-reading...) */
- if (parse_line(length, &seconds, &useconds,
+ if (parse_line(linebuff, length, &seconds, &useconds,
&before_time_offset, &after_time_offset,
&dollar_offset,
- &data_chars, &direction, &encap))
- {
- int n;
- int stub_offset = 0;
- char timestamp_string[32];
- g_snprintf(timestamp_string, 32, "%d.%04d", seconds, useconds/100);
-
- /* Make sure all packets go to catapult dct2000 dissector */
- wth->phdr.pkt_encap = WTAP_ENCAP_CATAPULT_DCT2000;
-
-
- /*********************/
- /* Write stub header */
- stub_offset = write_stub_header((guchar*)pd, timestamp_string,
- direction, encap);
-
-
- /********************************/
- /* Copy packet data into buffer */
- for (n=0; n <= data_chars; n+=2)
- {
- pd[stub_offset + n/2] = (hex_from_char(linebuff[dollar_offset+n]) << 4) |
- hex_from_char(linebuff[dollar_offset+n+1]);
- }
-
- /* Set packet pseudo-header if necessary */
- set_pseudo_header_info(wth, encap, seek_off, pseudo_header, direction);
+ &data_chars, &direction, &encap, &is_comment, &is_sprint,
+ aal_header_chars,
+ context_name, &context_port,
+ protocol_name, variant_name, outhdr_name)) {
+ char timestamp_string[MAX_TIMESTAMP_LEN+1];
+
+ write_timestamp_string(timestamp_string, seconds, useconds/100);
+
+ if (!process_parsed_line(wth, file_externals,
+ phdr, buf, seek_off,
+ linebuff, dollar_offset,
+ seconds, useconds,
+ timestamp_string,
+ direction, encap,
+ context_name, context_port,
+ protocol_name, variant_name,
+ outhdr_name, aal_header_chars,
+ is_comment, data_chars,
+ err, err_info))
+ return FALSE;
*err = errno = 0;
return TRUE;
/***************************************************************************/
/* Free dct2000-specific capture info from file that was open for reading */
/***************************************************************************/
-void catapult_dct2000_close(wtap *wth)
+static void
+catapult_dct2000_close(wtap *wth)
{
- /* Look up externals for this file */
+ /* Get externals for this file */
dct2000_file_externals_t *file_externals =
- (dct2000_file_externals_t*)g_hash_table_lookup(file_externals_table, wth);
-
- /* The entry *has* to be found */
- if (!file_externals)
- {
- return;
- }
+ (dct2000_file_externals_t*)wth->priv;
/* Free up its line prefix values */
g_hash_table_foreach_remove(file_externals->packet_prefix_table,
free_line_prefix_info, NULL);
/* Free up its line prefix table */
g_hash_table_destroy(file_externals->packet_prefix_table);
-
- /* And remove the externals entry from the global table */
- g_hash_table_remove(file_externals_table, (void*)wth);
-
- /* And free up file_externals itself */
- g_free(file_externals);
-
- /* Also free this capture info */
- g_free(wth->capture.catapult_dct2000);
}
/* Dump functions */
/***************************/
+typedef struct {
+ gboolean first_packet_written;
+ nstime_t start_time;
+} dct2000_dump_t;
+
/*****************************************************/
/* The file that we are writing to has been opened. */
/* Set other dump callbacks. */
/*****************************************************/
-gboolean catapult_dct2000_dump_open(wtap_dumper *wdh, gboolean cant_seek _U_, int *err _U_)
+gboolean
+catapult_dct2000_dump_open(wtap_dumper *wdh, int *err _U_)
{
/* Fill in other dump callbacks */
wdh->subtype_write = catapult_dct2000_dump;
- wdh->subtype_close = catapult_dct2000_dump_close;
return TRUE;
}
/* Respond to queries about which encap types we support */
/* writing to. */
/*********************************************************/
-int catapult_dct2000_dump_can_write_encap(int encap)
+int
+catapult_dct2000_dump_can_write_encap(int encap)
{
- switch (encap)
- {
+ switch (encap) {
case WTAP_ENCAP_CATAPULT_DCT2000:
/* We support this */
return 0;
default:
/* But don't write to any other formats... */
- return WTAP_ERR_UNSUPPORTED_ENCAP;
+ return WTAP_ERR_UNWRITABLE_ENCAP;
}
}
/* Write a single packet out to the file */
/*****************************************/
-static gboolean do_fwrite(const void *data, size_t size, size_t count, FILE *stream, int *err_p)
-{
- size_t nwritten;
-
- nwritten = fwrite(data, size, count, stream);
- if (nwritten != count) {
- if (nwritten == 0 && ferror(stream))
- {
- *err_p = errno;
- }
- else
- {
- *err_p = WTAP_ERR_SHORT_WRITE;
- }
-
- return FALSE;
- }
- return TRUE;
-}
-
-gboolean catapult_dct2000_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
- const union wtap_pseudo_header *pseudo_header,
- const guchar *pd, int *err)
+static gboolean
+catapult_dct2000_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
+ const guint8 *pd, int *err, gchar **err_info _U_)
{
+ const union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header;
guint32 n;
line_prefix_info_t *prefix = NULL;
gchar time_string[16];
+ gboolean is_comment;
+ gboolean is_sprint = FALSE;
+ dct2000_dump_t *dct2000;
+ int consecutive_slashes=0;
+ char *p_c;
/******************************************************/
- /* Look up the file_externals structure for this file */
+ /* Get the file_externals structure for this file */
/* Find wtap external structure for this wtap */
dct2000_file_externals_t *file_externals =
- (dct2000_file_externals_t*)g_hash_table_lookup(file_externals_table,
- pseudo_header->dct2000.wth);
+ (dct2000_file_externals_t*)pseudo_header->dct2000.wth->priv;
- if (wdh->dump.dct2000 == NULL)
- {
- /* Allocate the dct2000-specific dump structure */
- wdh->dump.dct2000 = g_malloc(sizeof(catapult_dct2000_t));
+ /* We can only write packet records. */
+ if (phdr->rec_type != REC_TYPE_PACKET) {
+ *err = WTAP_ERR_UNWRITABLE_REC_TYPE;
+ return FALSE;
+ }
+
+ dct2000 = (dct2000_dump_t *)wdh->priv;
+ if (dct2000 == NULL) {
/* Write out saved first line */
- if (! do_fwrite(file_externals->firstline, 1, file_externals->firstline_length, wdh->fh, err))
- {
+ if (!wtap_dump_file_write(wdh, file_externals->firstline,
+ file_externals->firstline_length, err)) {
return FALSE;
}
- if (! do_fwrite("\n", 1, 1, wdh->fh, err))
- {
+ if (!wtap_dump_file_write(wdh, "\n", 1, err)) {
return FALSE;
}
/* Also write out saved second line with timestamp corresponding to the
opening time of the log.
*/
- if (! do_fwrite(file_externals->secondline, 1, file_externals->secondline_length, wdh->fh, err))
- {
+ if (!wtap_dump_file_write(wdh, file_externals->secondline,
+ file_externals->secondline_length, err)) {
return FALSE;
}
- if (! do_fwrite("\n", 1, 1, wdh->fh, err))
- {
+ if (!wtap_dump_file_write(wdh, "\n", 1, err)) {
return FALSE;
}
/* Allocate the dct2000-specific dump structure */
- wdh->dump.dct2000 = g_malloc(sizeof(catapult_dct2000_t));
+ dct2000 = (dct2000_dump_t *)g_malloc(sizeof(dct2000_dump_t));
+ wdh->priv = (void *)dct2000;
/* Copy time of beginning of file */
- wdh->dump.dct2000->start_time.secs =
- pseudo_header->dct2000.wth->capture.catapult_dct2000->start_secs;
- wdh->dump.dct2000->start_time.nsecs =
- (pseudo_header->dct2000.wth->capture.catapult_dct2000->start_usecs * 1000);
+ dct2000->start_time.secs = file_externals->start_secs;
+ dct2000->start_time.nsecs =
+ (file_externals->start_usecs * 1000);
- /* Set flag do don't write header out again */
- wdh->dump.dct2000->first_packet_written = TRUE;
+ /* Set flag so don't write header out again */
+ dct2000->first_packet_written = TRUE;
}
(const void*)&(pseudo_header->dct2000.seek_off));
/* Write out text before timestamp */
- if (! do_fwrite(prefix->before_time, 1, strlen(prefix->before_time), wdh->fh, err))
- {
+ if (!wtap_dump_file_write(wdh, prefix->before_time,
+ strlen(prefix->before_time), err)) {
return FALSE;
}
+ /* Can infer from prefix if this is a comment (whose payload is displayed differently) */
+ /* This is much faster than strstr() for "/////" */
+ p_c = prefix->before_time;
+ while (p_c && (*p_c != '/')) {
+ p_c++;
+ }
+ while (p_c && (*p_c == '/')) {
+ consecutive_slashes++;
+ p_c++;
+ }
+ is_comment = (consecutive_slashes == 5);
+
/* Calculate time of this packet to write, relative to start of dump */
- if (phdr->ts.nsecs >= wdh->dump.dct2000->start_time.nsecs)
- {
- g_snprintf(time_string, 16, "%ld.%04d",
- (long)(phdr->ts.secs - wdh->dump.dct2000->start_time.secs),
- (phdr->ts.nsecs - wdh->dump.dct2000->start_time.nsecs) / 100000);
+ if (phdr->ts.nsecs >= dct2000->start_time.nsecs) {
+ write_timestamp_string(time_string,
+ (int)(phdr->ts.secs - dct2000->start_time.secs),
+ (phdr->ts.nsecs - dct2000->start_time.nsecs) / 100000);
}
- else
- {
- g_snprintf(time_string, 16, "%ld.%04u",
- (long)(phdr->ts.secs - wdh->dump.dct2000->start_time.secs-1),
- ((1000000000 + (phdr->ts.nsecs / 100000)) - (wdh->dump.dct2000->start_time.nsecs / 100000)) % 10000);
+ else {
+ write_timestamp_string(time_string,
+ (int)(phdr->ts.secs - dct2000->start_time.secs-1),
+ ((1000000000 + (phdr->ts.nsecs / 100000)) - (dct2000->start_time.nsecs / 100000)) % 10000);
}
/* Write out the calculated timestamp */
- if (! do_fwrite(time_string, 1, strlen(time_string), wdh->fh, err))
- {
+ if (!wtap_dump_file_write(wdh, time_string, strlen(time_string), err)) {
return FALSE;
}
/* Write out text between timestamp and start of hex data */
- if (prefix->after_time == NULL)
- {
- if (! do_fwrite(" l ", 1, strlen(" l "), wdh->fh, err))
- {
+ if (prefix->after_time == NULL) {
+ if (!wtap_dump_file_write(wdh, " l ", strlen(" l "), err)) {
return FALSE;
}
}
- else
- {
- if (! do_fwrite(prefix->after_time, 1, strlen(prefix->after_time), wdh->fh, err))
- {
+ else {
+ if (!wtap_dump_file_write(wdh, prefix->after_time,
+ strlen(prefix->after_time), err)) {
return FALSE;
}
}
n++;
/* Protocol name */
+ if (is_comment) {
+ is_sprint = (strcmp((const char *)pd+n, "sprint") == 0);
+ }
for (; pd[n] != '\0'; n++);
n++;
/**************************************/
/* Remainder is encapsulated protocol */
- if (! do_fwrite("$", 1, 1, wdh->fh, err))
- {
+ if (!wtap_dump_file_write(wdh, is_sprint ? " " : "$", 1, err)) {
return FALSE;
}
- /* Each binary byte is written out as 2 hex string chars */
- for (; n < phdr->len; n++)
- {
- gchar c[2];
- c[0] = char_from_hex((guchar)(pd[n] >> 4));
- c[1] = char_from_hex((guchar)(pd[n] & 0x0f));
+ if (!is_comment) {
+ /* Each binary byte is written out as 2 hex string chars */
+ for (; n < phdr->len; n++) {
+ gchar c[2];
+ c[0] = char_from_hex((guint8)(pd[n] >> 4));
+ c[1] = char_from_hex((guint8)(pd[n] & 0x0f));
- /* Write both hex chars of byte together */
- if (! do_fwrite(c, 1, 2, wdh->fh, err))
- {
- return FALSE;
+ /* Write both hex chars of byte together */
+ if (!wtap_dump_file_write(wdh, c, 2, err)) {
+ return FALSE;
+ }
+ }
+ }
+ else {
+ for (; n < phdr->len; n++) {
+ char c[1];
+ c[0] = pd[n];
+
+ /* Write both hex chars of byte together */
+ if (!wtap_dump_file_write(wdh, c, 1, err)) {
+ return FALSE;
+ }
}
}
/* End the line */
- if (! do_fwrite("\n", 1, 1, wdh->fh, err))
- {
+ if (!wtap_dump_file_write(wdh, "\n", 1, err)) {
return FALSE;
}
}
-/******************************************************/
-/* Close a file we've been writing to. */
-/******************************************************/
-static gboolean catapult_dct2000_dump_close(wtap_dumper *wdh _U_, int *err _U_)
-{
- return TRUE;
-}
-
-
-
-
/****************************/
/* Private helper functions */
/****************************/
/**********************************************************************/
/* Read a new line from the file, starting at offset. */
-/* - writes data to static var linebuff */
+/* - writes data to its argument linebuff */
/* - on return 'offset' will point to the next position to read from */
/* - return TRUE if this read is successful */
/**********************************************************************/
-gboolean read_new_line(FILE_T fh, gint64 *offset, gint *length)
+static gboolean
+read_new_line(FILE_T fh, gint64 *offset, gint *length,
+ gchar *linebuff, size_t linebuffsize, int *err, gchar **err_info)
{
- char *result;
-
/* Read in a line */
- result = file_gets(linebuff, MAX_LINE_LENGTH, fh);
- if (result == NULL)
- {
- /* No characters found */
+ gint64 pos_before = file_tell(fh);
+
+ if (file_gets(linebuff, (int)linebuffsize - 1, fh) == NULL) {
+ /* No characters found, or error */
+ *err = file_error(fh, err_info);
return FALSE;
}
- /* Set length and offset.. */
- *length = strlen(linebuff);
+ /* Set length (avoiding strlen()) and offset.. */
+ *length = (gint)(file_tell(fh) - pos_before);
*offset = *offset + *length;
/* ...but don't want to include newline in line length */
- if (linebuff[*length-1] == '\n')
- {
+ if (*length > 0 && linebuff[*length-1] == '\n') {
+ linebuff[*length-1] = '\0';
+ *length = *length - 1;
+ }
+ /* Nor do we want '\r' (as will be written when log is created on windows) */
+ if (*length > 0 && linebuff[*length-1] == '\r') {
linebuff[*length-1] = '\0';
*length = *length - 1;
}
/* - data position and length */
/* Return TRUE if this packet looks valid and can be displayed */
/**********************************************************************/
-gboolean parse_line(gint line_length, gint *seconds, gint *useconds,
- long *before_time_offset, long *after_time_offset,
- long *data_offset, gint *data_chars,
- packet_direction_t *direction,
- int *encap)
+static gboolean
+parse_line(gchar *linebuff, gint line_length,
+ gint *seconds, gint *useconds,
+ long *before_time_offset, long *after_time_offset,
+ long *data_offset, gint *data_chars,
+ packet_direction_t *direction,
+ int *encap, int *is_comment, int *is_sprint,
+ gchar *aal_header_chars,
+ gchar *context_name, guint8 *context_portp,
+ gchar *protocol_name, gchar *variant_name,
+ gchar *outhdr_name)
{
int n = 0;
- int port_digits = 0;
+ int port_digits;
char port_number_string[MAX_PORT_DIGITS+1];
int variant_digits = 0;
int variant = 1;
char subsecond_decimals_buff[MAX_SUBSECOND_DECIMALS+1];
int subsecond_decimals_chars;
int skip_first_byte = FALSE;
-
gboolean atm_header_present = FALSE;
+ *is_comment = FALSE;
+ *is_sprint = FALSE;
+
/* Read context name until find '.' */
- for (n=0; linebuff[n] != '.' && (n < MAX_CONTEXT_NAME) && (n+1 < line_length); n++)
- {
- if (!isalnum((guchar)linebuff[n]) && (linebuff[n] != '_'))
- {
+ for (n=0; (n < MAX_CONTEXT_NAME) && (n+1 < line_length) && (linebuff[n] != '.'); n++) {
+ if (linebuff[n] == '/') {
+ context_name[n] = '\0';
+
+ /* If not a comment (/////), not a valid line */
+ if (strncmp(linebuff+n, "/////", 5) != 0) {
+ return FALSE;
+ }
+
+ /* There is no variant, outhdr, etc. Set protocol to be a comment */
+ g_strlcpy(protocol_name, "comment", MAX_PROTOCOL_NAME);
+ *is_comment = TRUE;
+ break;
+ }
+ if (!g_ascii_isalnum(linebuff[n]) && (linebuff[n] != '_') && (linebuff[n] != '-')) {
return FALSE;
}
context_name[n] = linebuff[n];
}
- if (n == MAX_CONTEXT_NAME || (n+1 >= line_length))
- {
+ if (n == MAX_CONTEXT_NAME || (n+1 >= line_length)) {
return FALSE;
}
- /* '.' must follow context name */
- if (linebuff[n] != '.')
- {
- return FALSE;
- }
- context_name[n] = '\0';
- /* Skip it */
- n++;
-
+ /* Reset strings (that won't be set by comments) */
+ variant_name[0] = '\0';
+ outhdr_name[0] = '\0';
+ port_number_string[0] = '\0';
- /* Now read port number */
- for (port_digits = 0;
- (linebuff[n] != '/') && (port_digits <= MAX_PORT_DIGITS) && (n+1 < line_length);
- n++, port_digits++)
- {
- if (!isdigit((guchar)linebuff[n]))
- {
+ if (!(*is_comment)) {
+ /* '.' must follow context name */
+ if (linebuff[n] != '.') {
return FALSE;
}
- port_number_string[port_digits] = linebuff[n];
- }
- if (port_digits > MAX_PORT_DIGITS || (n+1 >= line_length))
- {
- return FALSE;
- }
+ context_name[n] = '\0';
+ /* Skip it */
+ n++;
- /* Slash char must follow port number */
- if (linebuff[n] != '/')
- {
- return FALSE;
- }
- port_number_string[port_digits] = '\0';
- context_port = atoi(port_number_string);
- /* Skip it */
- n++;
+ /* Now read port number */
+ for (port_digits = 0;
+ (linebuff[n] != '/') && (port_digits <= MAX_PORT_DIGITS) && (n+1 < line_length);
+ n++, port_digits++) {
+ if (!g_ascii_isdigit(linebuff[n])) {
+ return FALSE;
+ }
+ port_number_string[port_digits] = linebuff[n];
+ }
+ if (port_digits > MAX_PORT_DIGITS || (n+1 >= line_length)) {
+ return FALSE;
+ }
- /* Now for the protocol name */
- for (protocol_chars = 0;
- (linebuff[n] != '/') && (protocol_chars < MAX_PROTOCOL_NAME) && (n < line_length);
- n++, protocol_chars++)
- {
- if (!isalnum((guchar)linebuff[n]) && linebuff[n] != '_')
+ /* Slash char must follow port number */
+ if (linebuff[n] != '/')
{
return FALSE;
}
- protocol_name[protocol_chars] = linebuff[n];
- }
- if (protocol_chars == MAX_PROTOCOL_NAME || n >= line_length)
- {
- /* If doesn't fit, fail rather than truncate */
- return FALSE;
- }
- protocol_name[protocol_chars] = '\0';
+ port_number_string[port_digits] = '\0';
+ if (port_digits == 1) {
+ *context_portp = port_number_string[0] - '0';
+ }
+ else {
+ *context_portp = atoi(port_number_string);
+ }
+ /* Skip it */
+ n++;
- /* Slash char must follow protocol name */
- if (linebuff[n] != '/')
- {
- return FALSE;
- }
- /* Skip it */
- n++;
+ /* Now for the protocol name */
+ for (protocol_chars = 0;
+ (linebuff[n] != '/') && (protocol_chars < MAX_PROTOCOL_NAME) && (n < line_length);
+ n++, protocol_chars++) {
+ if (!g_ascii_isalnum(linebuff[n]) && linebuff[n] != '_') {
+ return FALSE;
+ }
+ protocol_name[protocol_chars] = linebuff[n];
+ }
+ if (protocol_chars == MAX_PROTOCOL_NAME || n >= line_length) {
+ /* If doesn't fit, fail rather than truncate */
+ return FALSE;
+ }
+ protocol_name[protocol_chars] = '\0';
- /* Following the / is the variant number. No digits indicate 1 */
- for (variant_digits = 0;
- (isdigit((guchar)linebuff[n])) && (variant_digits <= MAX_VARIANT_DIGITS) && (n+1 < line_length);
- n++, variant_digits++)
- {
- if (!isdigit((guchar)linebuff[n]))
- {
+ /* Slash char must follow protocol name */
+ if (linebuff[n] != '/') {
return FALSE;
}
- variant_name[variant_digits] = linebuff[n];
- }
- if (variant_digits > MAX_VARIANT_DIGITS || (n+1 >= line_length))
- {
- return FALSE;
- }
- if (variant_digits > 0)
- {
- variant_name[variant_digits] = '\0';
- variant = atoi(variant_name);
- }
- else
- {
- strcpy(variant_name, "1");
- }
+ /* Skip it */
+ n++;
- /* Outheader values may follow */
- outhdr_name[0] = '\0';
- if (linebuff[n] == ',')
- {
- /* Skip , */
- n++;
+ /* Following the / is the variant number. No digits indicate 1 */
+ for (variant_digits = 0;
+ (g_ascii_isdigit(linebuff[n])) && (variant_digits <= MAX_VARIANT_DIGITS) && (n+1 < line_length);
+ n++, variant_digits++) {
- for (outhdr_chars = 0;
- (isdigit((guchar)linebuff[n]) || linebuff[n] == ',') &&
- (outhdr_chars <= MAX_OUTHDR_NAME) && (n+1 < line_length);
- n++, outhdr_chars++)
- {
- if (!isdigit((guchar)linebuff[n]) && (linebuff[n] != ','))
- {
+ if (!g_ascii_isdigit(linebuff[n])) {
return FALSE;
}
- outhdr_name[outhdr_chars] = linebuff[n];
+ variant_name[variant_digits] = linebuff[n];
}
- if (outhdr_chars > MAX_OUTHDR_NAME || (n+1 >= line_length))
- {
+ if (variant_digits > MAX_VARIANT_DIGITS || (n+1 >= line_length)) {
return FALSE;
}
- /* Terminate (possibly empty) string */
- outhdr_name[outhdr_chars] = '\0';
- }
+
+ if (variant_digits > 0) {
+ variant_name[variant_digits] = '\0';
+ if (variant_digits == 1) {
+ variant = variant_name[0] - '0';
+ }
+ else {
+ variant = atoi(variant_name);
+ }
+ }
+ else {
+ variant_name[0] = '1';
+ variant_name[1] = '\0';
+ }
+ /* Outheader values may follow */
+ outhdr_name[0] = '\0';
+ if (linebuff[n] == ',') {
+ /* Skip , */
+ n++;
+
+ for (outhdr_chars = 0;
+ (g_ascii_isdigit(linebuff[n]) || linebuff[n] == ',') &&
+ (outhdr_chars <= MAX_OUTHDR_NAME) && (n+1 < line_length);
+ n++, outhdr_chars++) {
+
+ if (!g_ascii_isdigit(linebuff[n]) && (linebuff[n] != ',')) {
+ return FALSE;
+ }
+ outhdr_name[outhdr_chars] = linebuff[n];
+ }
+ if (outhdr_chars > MAX_OUTHDR_NAME || (n+1 >= line_length)) {
+ return FALSE;
+ }
+ /* Terminate (possibly empty) string */
+ outhdr_name[outhdr_chars] = '\0';
+ }
+ }
/******************************************************************/
(strcmp(protocol_name, "sctp") == 0) ||
(strcmp(protocol_name, "gre") == 0) ||
(strcmp(protocol_name, "mipv6") == 0) ||
- (strcmp(protocol_name, "igmp") == 0))
- {
+ (strcmp(protocol_name, "igmp") == 0)) {
+
*encap = WTAP_ENCAP_RAW_IP;
}
else
/* FP may be carried over ATM, which has separate atm header to parse */
if ((strcmp(protocol_name, "fp") == 0) ||
- (strcmp(protocol_name, "fp_r4") == 0) ||
- (strcmp(protocol_name, "fp_r5") == 0) ||
- (strcmp(protocol_name, "fp_r6") == 0))
- {
- if ((variant > 256) && (variant % 256 == 3))
- {
+ (strncmp(protocol_name, "fp_r", 4) == 0)) {
+
+ if ((variant > 256) && (variant % 256 == 3)) {
/* FP over udp is contained in IPPrim... */
*encap = 0;
}
- else
- {
+ else {
/* FP over AAL0 or AAL2 */
*encap = WTAP_ENCAP_ATM_PDUS_UNTRUNCATED;
atm_header_present = TRUE;
}
}
- else if (strcmp(protocol_name, "fpiur_r5") == 0)
- {
+ else if (strcmp(protocol_name, "fpiur_r5") == 0) {
/* FP (IuR) over AAL2 */
*encap = WTAP_ENCAP_ATM_PDUS_UNTRUNCATED;
atm_header_present = TRUE;
}
-
else
- if (strcmp(protocol_name, "ppp") == 0)
- {
+ if (strcmp(protocol_name, "ppp") == 0) {
*encap = WTAP_ENCAP_PPP;
}
else
- if (strcmp(protocol_name, "isdn_l3") == 0)
- {
+ if (strcmp(protocol_name, "isdn_l3") == 0) {
/* TODO: find out what this byte means... */
skip_first_byte = TRUE;
*encap = WTAP_ENCAP_ISDN;
}
else
- if (strcmp(protocol_name, "isdn_l2") == 0)
- {
+ if (strcmp(protocol_name, "isdn_l2") == 0) {
*encap = WTAP_ENCAP_ISDN;
}
else
- if (strcmp(protocol_name, "ethernet") == 0)
- {
+ if (strcmp(protocol_name, "ethernet") == 0) {
*encap = WTAP_ENCAP_ETHERNET;
}
else
if ((strcmp(protocol_name, "saalnni_sscop") == 0) ||
- (strcmp(protocol_name, "saaluni_sscop") == 0))
- {
+ (strcmp(protocol_name, "saaluni_sscop") == 0)) {
+
*encap = DCT2000_ENCAP_SSCOP;
}
else
- if (strcmp(protocol_name, "frelay_l2") == 0)
- {
+ if (strcmp(protocol_name, "frelay_l2") == 0) {
*encap = WTAP_ENCAP_FRELAY;
}
else
- if (strcmp(protocol_name, "ss7_mtp2") == 0)
- {
+ if (strcmp(protocol_name, "ss7_mtp2") == 0) {
*encap = DCT2000_ENCAP_MTP2;
}
else
if ((strcmp(protocol_name, "nbap") == 0) ||
(strcmp(protocol_name, "nbap_r4") == 0) ||
- (strncmp(protocol_name, "nbap_sscfuni", strlen("nbap_sscfuni")) == 0))
- {
+ (strncmp(protocol_name, "nbap_sscfuni", strlen("nbap_sscfuni")) == 0)) {
+
/* The entire message in these cases is nbap, so use an encap value. */
*encap = DCT2000_ENCAP_NBAP;
}
- else
- {
+ else {
/* Not a supported board port protocol/encap, but can show as raw data or
in some cases find protocol embedded inside primitive */
*encap = DCT2000_ENCAP_UNHANDLED;
/* Find separate ATM header if necessary */
- if (atm_header_present)
- {
+ if (atm_header_present) {
int header_chars_seen = 0;
/* Scan ahead to the next $ */
for (; (linebuff[n] != '$') && (n+1 < line_length); n++);
/* Skip it */
n++;
- if (n+1 >= line_length)
- {
+ if (n+1 >= line_length) {
return FALSE;
}
/* Read consecutive hex chars into atm header buffer */
for (;
- ((linebuff[n] >= '0') && (linebuff[n] <= '?') &&
- (n < line_length) &&
+ ((n < line_length) &&
+ (linebuff[n] >= '0') && (linebuff[n] <= '?') &&
(header_chars_seen < AAL_HEADER_CHARS));
- n++, header_chars_seen++)
- {
+ n++, header_chars_seen++) {
+
aal_header_chars[header_chars_seen] = linebuff[n];
/* Next 6 characters after '9' are mapped to a->f */
- if (!isdigit((guchar)linebuff[n]))
- {
+ if (!g_ascii_isdigit(linebuff[n])) {
aal_header_chars[header_chars_seen] = 'a' + (linebuff[n] - '9') -1;
}
}
- if (header_chars_seen != AAL_HEADER_CHARS || n >= line_length)
- {
+ if (header_chars_seen != AAL_HEADER_CHARS || n >= line_length) {
return FALSE;
}
}
+ /* Skip next '/' */
+ n++;
- /* Scan ahead to the next space */
- for (; (linebuff[n] != ' ') && (n+1 < line_length); n++);
- if (n+1 >= line_length)
- {
- return FALSE;
+ /* If there is a number, skip all info to next '/'.
+ TODO: for IP encapsulation, should store PDCP ueid, drb in pseudo info
+ and display dct2000 dissector... */
+ if (g_ascii_isdigit(linebuff[n])) {
+ while ((n+1 < line_length) && linebuff[n] != '/') {
+ n++;
+ }
}
- /* Skip it */
- n++;
- /* Next character gives direction of message (must be 's' or 'r') */
- if (linebuff[n] == 's')
- {
- *direction = sent;
+ /* Skip '/' */
+ while ((n+1 < line_length) && linebuff[n] == '/') {
+ n++;
}
- else
- if (linebuff[n] == 'r')
- {
- *direction = received;
+
+ /* Skip a space that may happen here */
+ if ((n+1 < line_length) && linebuff[n] == ' ') {
+ n++;
}
- else
- {
- return FALSE;
+
+ /* Next character gives direction of message (must be 's' or 'r') */
+ if (!(*is_comment)) {
+ if (linebuff[n] == 's') {
+ *direction = sent;
+ }
+ else
+ if (linebuff[n] == 'r') {
+ *direction = received;
+ }
+ else {
+ return FALSE;
+ }
+ /* Skip it */
+ n++;
+ }
+ else {
+ *direction = sent;
}
/* Find and read the timestamp */
/* Now scan to the next digit, which should be the start of the timestamp */
- for (; !isdigit((guchar)linebuff[n]) && (n < line_length); n++);
- if (n >= line_length)
- {
+ /* This will involve skipping " tm " */
+
+ for (; ((linebuff[n] != 't') || (linebuff[n+1] != 'm')) && (n+1 < line_length); n++);
+ if (n >= line_length) {
+ return FALSE;
+ }
+
+ for (; (n < line_length) && !g_ascii_isdigit(linebuff[n]); n++);
+ if (n >= line_length) {
return FALSE;
}
(linebuff[n] != '.') &&
(seconds_chars <= MAX_SECONDS_CHARS) &&
(n < line_length);
- n++, seconds_chars++)
- {
- if (!isdigit((guchar)linebuff[n]))
- {
+ n++, seconds_chars++) {
+
+ if (!g_ascii_isdigit(linebuff[n])) {
/* Found a non-digit before decimal point. Fail */
return FALSE;
}
seconds_buff[seconds_chars] = linebuff[n];
}
- if (seconds_chars > MAX_SECONDS_CHARS || n >= line_length)
- {
+ if (seconds_chars > MAX_SECONDS_CHARS || n >= line_length) {
/* Didn't fit in buffer. Fail rather than use truncated */
return FALSE;
}
*seconds = atoi(seconds_buff);
/* The decimal point must follow the last of the seconds digits */
- if (linebuff[n] != '.')
- {
+ if (linebuff[n] != '.') {
return FALSE;
}
/* Skip it */
(linebuff[n] != ' ') &&
(subsecond_decimals_chars <= MAX_SUBSECOND_DECIMALS) &&
(n < line_length);
- n++, subsecond_decimals_chars++)
- {
- if (!isdigit((guchar)linebuff[n]))
- {
+ n++, subsecond_decimals_chars++) {
+
+ if (!g_ascii_isdigit(linebuff[n])) {
return FALSE;
}
subsecond_decimals_buff[subsecond_decimals_chars] = linebuff[n];
}
- if (subsecond_decimals_chars > MAX_SUBSECOND_DECIMALS || n >= line_length)
- {
+ if (subsecond_decimals_chars > MAX_SUBSECOND_DECIMALS || n >= line_length) {
/* More numbers than expected - give up */
return FALSE;
}
*useconds = atoi(subsecond_decimals_buff) * 100;
/* Space character must follow end of timestamp */
- if (linebuff[n] != ' ')
- {
+ if (linebuff[n] != ' ') {
return FALSE;
}
- *after_time_offset = n;
+ *after_time_offset = n++;
- /* Now skip ahead to find start of data (marked by '$') */
- for (; (linebuff[n] != '$') && (n+1 < line_length); n++);
- if (n+1 >= line_length)
- {
- return FALSE;
+ /* If we have a string message, it could either be a comment (with '$') or
+ a sprint line (no '$') */
+ if (*is_comment) {
+ if (strncmp(linebuff+n, "l $", 3) != 0) {
+ *is_sprint = TRUE;
+ g_strlcpy(protocol_name, "sprint", MAX_PROTOCOL_NAME);
+ }
+ }
+
+ if (!(*is_sprint)) {
+ /* Now skip ahead to find start of data (marked by '$') */
+ for (; (linebuff[n] != '$') && (linebuff[n] != '\'') && (n+1 < line_length); n++);
+ if ((linebuff[n] == '\'') || (n+1 >= line_length)) {
+ return FALSE;
+ }
+ /* Skip it */
+ n++;
}
- /* Skip it */
- n++;
/* Set offset to data start within line */
*data_offset = n;
*data_chars = line_length - n;
/* May need to skip first byte (2 hex string chars) */
- if (skip_first_byte)
- {
+ if (skip_first_byte) {
*data_offset += 2;
*data_chars -= 2;
}
-
return TRUE;
}
-/*****************************************************************/
-/* Write the stub info to the data buffer while reading a packet */
-/*****************************************************************/
-int write_stub_header(guchar *frame_buffer, char *timestamp_string,
- packet_direction_t direction, int encap)
+/***********************************/
+/* Process results of parse_line() */
+/***********************************/
+static gboolean
+process_parsed_line(wtap *wth, dct2000_file_externals_t *file_externals,
+ struct wtap_pkthdr *phdr,
+ Buffer *buf, gint64 file_offset,
+ char *linebuff, long dollar_offset,
+ int seconds, int useconds, gchar *timestamp_string,
+ packet_direction_t direction, int encap,
+ gchar *context_name, guint8 context_port,
+ gchar *protocol_name, gchar *variant_name,
+ gchar *outhdr_name, gchar *aal_header_chars,
+ gboolean is_comment, int data_chars,
+ int *err, gchar **err_info)
{
+ int n;
int stub_offset = 0;
-
- strcpy((char*)frame_buffer, context_name);
- stub_offset += (strlen(context_name) + 1);
+ gsize length;
+ guint8 *frame_buffer;
+
+ phdr->rec_type = REC_TYPE_PACKET;
+ phdr->presence_flags = WTAP_HAS_TS;
+
+ /* Make sure all packets go to Catapult DCT2000 dissector */
+ phdr->pkt_encap = WTAP_ENCAP_CATAPULT_DCT2000;
+
+ /* Fill in timestamp (capture base + packet offset) */
+ phdr->ts.secs = file_externals->start_secs + seconds;
+ if ((file_externals->start_usecs + useconds) >= 1000000) {
+ phdr->ts.secs++;
+ }
+ phdr->ts.nsecs =
+ ((file_externals->start_usecs + useconds) % 1000000) *1000;
+
+ /*
+ * Calculate the length of the stub info and the packet data.
+ * The packet data length is half bytestring length.
+ */
+ phdr->caplen = (guint)strlen(context_name)+1 + /* Context name */
+ 1 + /* port */
+ (guint)strlen(timestamp_string)+1 + /* timestamp */
+ (guint)strlen(variant_name)+1 + /* variant */
+ (guint)strlen(outhdr_name)+1 + /* outhdr */
+ (guint)strlen(protocol_name)+1 + /* Protocol name */
+ 1 + /* direction */
+ 1 + /* encap */
+ (is_comment ? data_chars : (data_chars/2));
+ if (phdr->caplen > WTAP_MAX_PACKET_SIZE) {
+ /*
+ * Probably a corrupt capture file; return an error,
+ * so that our caller doesn't blow up trying to allocate
+ * space for an immensely-large packet.
+ */
+ *err = WTAP_ERR_BAD_FILE;
+ *err_info = g_strdup_printf("catapult dct2000: File has %u-byte packet, bigger than maximum of %u",
+ phdr->caplen, WTAP_MAX_PACKET_SIZE);
+ return FALSE;
+ }
+ phdr->len = phdr->caplen;
+
+ /*****************************/
+ /* Get the data buffer ready */
+ ws_buffer_assure_space(buf, phdr->caplen);
+ frame_buffer = ws_buffer_start_ptr(buf);
+
+ /******************************************/
+ /* Write the stub info to the data buffer */
+
+ /* Context name */
+ length = g_strlcpy((char*)frame_buffer, context_name, MAX_CONTEXT_NAME+1);
+ stub_offset += (int)(length + 1);
/* Context port number */
frame_buffer[stub_offset] = context_port;
stub_offset++;
/* Timestamp within file */
- strcpy((char*)&frame_buffer[stub_offset], timestamp_string);
- stub_offset += (strlen(timestamp_string) + 1);
+ length = g_strlcpy((char*)&frame_buffer[stub_offset], timestamp_string, MAX_TIMESTAMP_LEN+1);
+ stub_offset += (int)(length + 1);
/* Protocol name */
- strcpy((char*)&frame_buffer[stub_offset], protocol_name);
- stub_offset += (strlen(protocol_name) + 1);
+ length = g_strlcpy((char*)&frame_buffer[stub_offset], protocol_name, MAX_PROTOCOL_NAME+1);
+ stub_offset += (int)(length + 1);
/* Protocol variant number (as string) */
- strcpy((void*)&frame_buffer[stub_offset], variant_name);
- stub_offset += (strlen(variant_name) + 1);
+ length = g_strlcpy((gchar*)&frame_buffer[stub_offset], variant_name, MAX_VARIANT_DIGITS+1);
+ stub_offset += (int)(length + 1);
/* Outhdr */
- strcpy((char*)&frame_buffer[stub_offset], outhdr_name);
- stub_offset += (strlen(outhdr_name) + 1);
+ length = g_strlcpy((char*)&frame_buffer[stub_offset], outhdr_name, MAX_OUTHDR_NAME+1);
+ stub_offset += (int)(length + 1);
/* Direction */
frame_buffer[stub_offset] = direction;
frame_buffer[stub_offset] = (guint8)encap;
stub_offset++;
- return stub_offset;
-}
-
+ if (!is_comment) {
+ /***********************************************************/
+ /* Copy packet data into buffer, converting from ascii hex */
+ for (n=0; n < data_chars; n+=2) {
+ frame_buffer[stub_offset + n/2] =
+ hex_byte_from_chars(linebuff+dollar_offset+n);
+ }
+ }
+ else {
+ /***********************************************************/
+ /* Copy packet data into buffer, just copying ascii chars */
+ for (n=0; n < data_chars; n++) {
+ frame_buffer[stub_offset + n] = linebuff[dollar_offset+n];
+ }
+ }
-/**************************************************************/
-/* Set pseudo-header info depending upon packet encapsulation */
-/**************************************************************/
-void set_pseudo_header_info(wtap *wth,
- int pkt_encap,
- gint64 file_offset,
- union wtap_pseudo_header *pseudo_header,
- packet_direction_t direction)
-{
- pseudo_header->dct2000.seek_off = file_offset;
- pseudo_header->dct2000.wth = wth;
+ /*****************************************/
+ /* Set packet pseudo-header if necessary */
+ phdr->pseudo_header.dct2000.seek_off = file_offset;
+ phdr->pseudo_header.dct2000.wth = wth;
- switch (pkt_encap)
- {
+ switch (encap) {
case WTAP_ENCAP_ATM_PDUS_UNTRUNCATED:
- set_aal_info(pseudo_header, direction);
+ set_aal_info(&phdr->pseudo_header, direction, aal_header_chars);
break;
case WTAP_ENCAP_ISDN:
- set_isdn_info(pseudo_header, direction);
+ set_isdn_info(&phdr->pseudo_header, direction);
break;
case WTAP_ENCAP_PPP:
- set_ppp_info(pseudo_header, direction);
+ set_ppp_info(&phdr->pseudo_header, direction);
break;
default:
/* Other supported types don't need to set anything here... */
break;
}
-}
+ return TRUE;
+}
/*********************************************/
/* Fill in atm pseudo-header with known info */
/*********************************************/
-void set_aal_info(union wtap_pseudo_header *pseudo_header, packet_direction_t direction)
+static void
+set_aal_info(union wtap_pseudo_header *pseudo_header,
+ packet_direction_t direction,
+ gchar *aal_header_chars)
{
/* 'aal_head_chars' has this format (for AAL2 at least):
Global Flow Control (4 bits) | VPI (8 bits) | VCI (16 bits) |
/* vpi is 8 bits (2nd & 3rd nibble) */
pseudo_header->dct2000.inner_pseudo_header.atm.vpi =
- ((hex_from_char(aal_header_chars[1]) << 4) |
- hex_from_char(aal_header_chars[2]));
+ hex_byte_from_chars(aal_header_chars+1);
/* vci is next 16 bits */
pseudo_header->dct2000.inner_pseudo_header.atm.vci =
/* cid is usually last byte. Unless last char is not hex digit, in which
case cid is derived from last char in ascii */
- if (isalnum((guchar)aal_header_chars[11]))
- {
+ if (g_ascii_isalnum(aal_header_chars[11])) {
pseudo_header->dct2000.inner_pseudo_header.atm.aal2_cid =
- ((hex_from_char(aal_header_chars[10]) << 4) |
- hex_from_char(aal_header_chars[11]));
+ hex_byte_from_chars(aal_header_chars+10);
}
- else
- {
+ else {
pseudo_header->dct2000.inner_pseudo_header.atm.aal2_cid =
- (int)aal_header_chars[11] - 48;
+ (int)aal_header_chars[11] - '0';
}
-
}
/**********************************************/
/* Fill in isdn pseudo-header with known info */
/**********************************************/
-void set_isdn_info(union wtap_pseudo_header *pseudo_header,
- packet_direction_t direction)
+static void
+set_isdn_info(union wtap_pseudo_header *pseudo_header,
+ packet_direction_t direction)
{
/* This field is used to set the 'Source' and 'Destination' columns to
'User' or 'Network'. If we assume that we're simulating the network,
/*********************************************/
/* Fill in ppp pseudo-header with known info */
/*********************************************/
-static void set_ppp_info(union wtap_pseudo_header *pseudo_header,
- packet_direction_t direction)
+static void
+set_ppp_info(union wtap_pseudo_header *pseudo_header,
+ packet_direction_t direction)
{
/* Set direction. */
pseudo_header->dct2000.inner_pseudo_header.p2p.sent = (direction == sent);
/********************************************************/
/* Return hex nibble equivalent of hex string character */
/********************************************************/
-guchar hex_from_char(gchar c)
+static guint8
+hex_from_char(gchar c)
{
- if ((c >= '0') && (c <= '9'))
- {
+ if ((c >= '0') && (c <= '9')) {
return c - '0';
}
- if ((c >= 'a') && (c <= 'f'))
- {
+ if ((c >= 'a') && (c <= 'f')) {
return 0x0a + (c - 'a');
}
}
+
+/* Table allowing fast lookup from a pair of ascii hex characters to a guint8 */
+static guint8 s_tableValues[256][256];
+
+/* Prepare table values so ready so don't need to check inside hex_byte_from_chars() */
+static void prepare_hex_byte_from_chars_table(void)
+{
+ guchar hex_char_array[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+ 'a', 'b', 'c', 'd', 'e', 'f' };
+
+ gint i, j;
+ for (i=0; i < 16; i++) {
+ for (j=0; j < 16; j++) {
+ s_tableValues[hex_char_array[i]][hex_char_array[j]] = i*16 + j;
+ }
+ }
+}
+
+/* Extract and return a byte value from 2 ascii hex chars, starting from the given pointer */
+static guint8 hex_byte_from_chars(gchar *c)
+{
+ /* Return value from quick table lookup */
+ return s_tableValues[(unsigned char)c[0]][(unsigned char)c[1]];
+}
+
+
+
/********************************************************/
/* Return character corresponding to hex nibble value */
/********************************************************/
-gchar char_from_hex(guchar hex)
+static gchar
+char_from_hex(guint8 hex)
{
- static char hex_lookup[16] =
+ static const char hex_lookup[16] =
{ '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
- if (hex > 15)
- {
+ if (hex > 15) {
return '?';
}
return hex_lookup[hex];
}
-/***************************************************/
-/* Equality function for file_externals hash table */
-/***************************************************/
-gint wth_equal(gconstpointer v, gconstpointer v2)
-{
- return (v == v2);
-}
-
-/***********************************************/
-/* Hash function for file_externals hash table */
-/***********************************************/
-guint wth_hash_func(gconstpointer v)
-{
- return (guint)(unsigned long)v;
-}
-
-
/***********************************************/
/* Equality test for packet prefix hash tables */
/***********************************************/
-gint packet_offset_equal(gconstpointer v, gconstpointer v2)
+static gint
+packet_offset_equal(gconstpointer v, gconstpointer v2)
{
/* Dereferenced pointers must have same gint64 offset value */
return (*(const gint64*)v == *(const gint64*)v2);
/********************************************/
/* Hash function for packet-prefix hash table */
/********************************************/
-guint packet_offset_hash_func(gconstpointer v)
+static guint
+packet_offset_hash_func(gconstpointer v)
{
- /* Use low-order bits of git64 offset value */
+ /* Use low-order bits of gint64 offset value */
return (guint)(*(const gint64*)v);
}
/* Set secs and usecs as output */
/* Return FALSE if no valid time can be read */
/************************************************************************/
-gboolean get_file_time_stamp(time_t *secs, guint32 *usecs)
+static gboolean
+get_file_time_stamp(gchar *linebuff, time_t *secs, guint32 *usecs)
{
- int n;
struct tm tm;
#define MAX_MONTH_LETTERS 9
char month[MAX_MONTH_LETTERS+1];
int scan_found;
/* If line longer than expected, file is probably not correctly formatted */
- if (strlen(linebuff) > MAX_TIMESTAMP_LINE_LENGTH)
- {
+ if (strlen(linebuff) > MAX_TIMESTAMP_LINE_LENGTH) {
return FALSE;
}
- /**************************************************************/
- /* First is month. Read until get a space following the month */
- for (n=0; (linebuff[n] != ' ') && (n < MAX_MONTH_LETTERS); n++)
- {
- month[n] = linebuff[n];
+ /********************************************************/
+ /* Scan for all fields */
+ scan_found = sscanf(linebuff, "%9s %2d, %4d %2d:%2d:%2d.%4u",
+ month, &day, &year, &hour, &minute, &second, usecs);
+ if (scan_found != 7) {
+ /* Give up if not all found */
+ return FALSE;
}
- month[n] = '\0';
if (strcmp(month, "January" ) == 0) tm.tm_mon = 0;
else if (strcmp(month, "February" ) == 0) tm.tm_mon = 1;
else if (strcmp(month, "October" ) == 0) tm.tm_mon = 9;
else if (strcmp(month, "November" ) == 0) tm.tm_mon = 10;
else if (strcmp(month, "December" ) == 0) tm.tm_mon = 11;
- else
- {
+ else {
/* Give up if not found a properly-formatted date */
return FALSE;
}
- /* Skip space char */
- n++;
-
- /********************************************************/
- /* Scan for remaining numerical fields */
- scan_found = sscanf(linebuff+n, "%d, %d %d:%d:%d.%u",
- &day, &year, &hour, &minute, &second, usecs);
- if (scan_found != 6)
- {
- /* Give up if not all found */
- return FALSE;
- }
/******************************************************/
/* Fill in remaining fields and return it in a time_t */
}
/* Free the data allocated inside a line_prefix_info_t */
-gboolean free_line_prefix_info(gpointer key, gpointer value,
- gpointer user_data _U_)
+static gboolean
+free_line_prefix_info(gpointer key, gpointer value,
+ gpointer user_data _U_)
{
line_prefix_info_t *info = (line_prefix_info_t*)value;
/* Free the strings inside */
g_free(info->before_time);
- if (info->after_time)
- {
+ if (info->after_time) {
g_free(info->after_time);
}
return TRUE;
}
+/*
+ * Editor modelines - http://www.wireshark.org/tools/modelines.html
+ *
+ * Local variables:
+ * c-basic-offset: 4
+ * tab-width: 8
+ * indent-tabs-mode: nil
+ * End:
+ *
+ * vi: set shiftwidth=4 tabstop=8 expandtab:
+ * :indentSize=4:tabSize=8:noTabs=true:
+ */
git.samba.org / metze / wireshark / wip.git / blobdiff