2001-12-04 22:28:19 +00:00
|
|
|
/* visual.c
|
|
|
|
* File read and write routines for Visual Networks cap files.
|
|
|
|
* Copyright (c) 2001, Tom Nisbet tnisbet@visualnetworks.com
|
|
|
|
*
|
2004-07-18 00:24:25 +00:00
|
|
|
* $Id$
|
2001-12-04 22:28:19 +00:00
|
|
|
*
|
|
|
|
* Wiretap Library
|
|
|
|
* Copyright (c) 1998 by Gilbert Ramirez <gram@alumni.rice.edu>
|
2002-08-28 20:30:45 +00:00
|
|
|
*
|
2001-12-04 22:28:19 +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:30:45 +00:00
|
|
|
*
|
2001-12-04 22:28:19 +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:30:45 +00:00
|
|
|
*
|
2001-12-04 22:28:19 +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
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "config.h"
|
|
|
|
#endif
|
|
|
|
#include <errno.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include "wtap-int.h"
|
|
|
|
#include "file_wrappers.h"
|
|
|
|
#include "buffer.h"
|
|
|
|
#include "visual.h"
|
|
|
|
|
|
|
|
/*
|
2007-08-23 22:11:39 +00:00
|
|
|
* A Visual Networks traffic capture file contains three sections. The
|
2001-12-04 22:28:19 +00:00
|
|
|
* first is a 192 octet file header. This is followed by the captured
|
2007-08-23 22:11:39 +00:00
|
|
|
* packet header, and for ATM captures, there is an additional atm packet header.
|
|
|
|
* The data follows the packet header. The last section is the packet index block.
|
2001-12-04 22:28:19 +00:00
|
|
|
* The index block contains one 4 octet pointer for each captured packet.
|
|
|
|
* The first packet index is (4 * num_pkts) octets from the end of the file
|
|
|
|
* and the last index is in the last four octets of the file.
|
|
|
|
*
|
2007-08-23 22:11:39 +00:00
|
|
|
* All integer and time values are stored in little-endian format, except for
|
|
|
|
* the ATM Packet Header, which is stored in network byte order.
|
|
|
|
*
|
|
|
|
* [ File Header ]
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* [ Packet Header 1 ] [(opt) ATM Packet Header] [ Data ]
|
|
|
|
* ...
|
|
|
|
* [ Packet Header n ] [(opt) ATM Packet Header] [ Data ]
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* [ Index Block 1 ] ... [ Index Block n ]
|
2001-12-04 22:28:19 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/* Capture file header, INCLUDING the magic number, is 192 bytes. */
|
|
|
|
#define CAPTUREFILE_HEADER_SIZE 192
|
|
|
|
|
|
|
|
/* Magic number for Visual Networks traffic capture files. */
|
|
|
|
static const char visual_magic[] = {
|
|
|
|
5, 'V', 'N', 'F'
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2007-08-23 22:11:39 +00:00
|
|
|
/* Visual File Header (minus magic number). */
|
|
|
|
/* This structure is used to extract information */
|
2001-12-04 22:28:19 +00:00
|
|
|
struct visual_file_hdr
|
|
|
|
{
|
|
|
|
guint32 num_pkts; /* Number of packets in the file */
|
|
|
|
guint32 start_time; /* Capture start time in PC format */
|
|
|
|
guint16 media_type; /* IANA ifType of packet source */
|
|
|
|
guint16 max_length; /* Max allowable stored packet length */
|
|
|
|
guint16 file_flags; /* File type flags */
|
|
|
|
/* Bit 0 indicates indexes present */
|
|
|
|
guint16 file_version; /* Version number of this file format */
|
|
|
|
guint32 media_speed; /* ifSpeed of packet source in bits/sec. */
|
|
|
|
guint16 media_param; /* Media-specific extra parameter. */
|
|
|
|
char RESERVED_[102]; /* MUST BE ALL ZEROS FOR FUTURE COMPATABILITY */
|
|
|
|
char description[64]; /* File description (null terminated) */
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/* Packet status bits */
|
|
|
|
#define PS_LONG 0x01
|
|
|
|
#define PS_SHORT 0x02
|
|
|
|
#define PS_ERRORED 0x04
|
|
|
|
#define PS_1ST_AFTER_DROP 0x08
|
|
|
|
#define PS_APPROX_ORDER 0x10
|
|
|
|
#define PS_SENT 0x40
|
|
|
|
#define PS_ABORTED 0x80
|
|
|
|
|
2007-08-23 22:11:39 +00:00
|
|
|
/* Visual Packet Header */
|
|
|
|
/* This structure is used to extract information */
|
2001-12-04 22:28:19 +00:00
|
|
|
struct visual_pkt_hdr
|
|
|
|
{
|
|
|
|
guint32 ts_delta; /* Time stamp - msecs since start of capture */
|
|
|
|
guint16 orig_len; /* Actual length of packet */
|
|
|
|
guint16 incl_len; /* Number of octets captured in file */
|
|
|
|
guint32 status; /* Packet status flags (media specific) */
|
|
|
|
guint8 encap_hint; /* Encapsulation type hint */
|
|
|
|
guint8 encap_skip; /* Number of bytes to skip before decoding */
|
|
|
|
char RESERVED_[6]; /* RESERVED - must be zero */
|
|
|
|
};
|
|
|
|
|
2007-08-23 22:11:39 +00:00
|
|
|
/* Optional Visual ATM Packet Header */
|
|
|
|
/* This structure is used to extract information */
|
|
|
|
struct visual_atm_hdr
|
|
|
|
{
|
|
|
|
guint16 vpi; /* 4 bits of zeros; 12 bits of ATM VPI */
|
|
|
|
guint16 vci; /* ATM VCI */
|
|
|
|
guint8 info; /* 4 bits version; 3 bits unused-zero; 1 bit direction */
|
|
|
|
guint8 category; /* indicates type of traffic. 4 bits of status + 4 bits of type */
|
|
|
|
guint16 cell_count; /* number of cells that make up this pdu */
|
|
|
|
guint32 data_length; /* PDU data length for AAL-5 PDUs, all others - cellcount * 48 */
|
|
|
|
guint32 ts_secs; /* seonds value of sysUpTime when the last cell of this PDU was captured */
|
|
|
|
guint32 ts_nsec; /* nanoseonds value of sysUpTime when the last cell of this PDU was captured */
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
/* visual_atm_hdr info bit definitions */
|
|
|
|
#define FROM_NETWORK 0x01
|
|
|
|
#define ATM_VER_MASK 0xf0 /* Not currently displayed */
|
|
|
|
|
|
|
|
/* visual_atm_hdr category definitions */
|
|
|
|
/* High nibble - not currently displayed */
|
|
|
|
#define VN_INCOMPLETE 0x40
|
|
|
|
#define VN_BAD_CRC 0x80
|
|
|
|
#define VN_CAT_STAT_MASK 0xf0
|
|
|
|
/* Low nibble */
|
|
|
|
#define VN_UNKNOWN 0x00
|
|
|
|
#define VN_AAL1 0x01
|
|
|
|
#define VN_AAL2 0x02
|
|
|
|
#define VN_AAL34 0x03
|
|
|
|
#define VN_O191 0x04
|
|
|
|
#define VN_AAL5 0x05
|
|
|
|
#define VN_OAM 0x0a
|
|
|
|
#define VN_RM 0x0b
|
|
|
|
#define VN_IDLE 0x0c
|
|
|
|
#define VN_CAT_TYPE_MASK 0x0f
|
|
|
|
|
2001-12-04 22:28:19 +00:00
|
|
|
|
|
|
|
/* Additional information for reading Visual files */
|
|
|
|
struct visual_read_info
|
|
|
|
{
|
|
|
|
guint32 num_pkts; /* Number of pkts in the file */
|
|
|
|
guint32 current_pkt; /* Next packet to be read */
|
|
|
|
double start_time; /* Capture start time in microseconds */
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/* Additional information for writing Visual files */
|
|
|
|
struct visual_write_info
|
|
|
|
{
|
|
|
|
unsigned start_time; /* Capture start time in seconds */
|
|
|
|
int index_table_index; /* Index of the next index entry */
|
|
|
|
int index_table_size; /* Allocated size of the index table */
|
|
|
|
guint32 * index_table; /* File offsets for the packets */
|
|
|
|
guint32 next_offset; /* Offset of next packet */
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/* Local functions to handle file reads and writes */
|
Have the Wiretap open, read, and seek-and-read routines return, in
addition to an error code, an error info string, for
WTAP_ERR_UNSUPPORTED, WTAP_ERR_UNSUPPORTED_ENCAP, and
WTAP_ERR_BAD_RECORD errors. Replace the error messages logged with
"g_message()" for those errors with g_strdup()ed or g_strdup_printf()ed
strings returned as the error info string, and change the callers of
those routines to, for those errors, put the info string into the
printed message or alert box for the error.
Add messages for cases where those errors were returned without printing
an additional message.
Nobody uses the error code from "cf_read()" - "cf_read()" puts up the
alert box itself for failures; get rid of the error code, so it just
returns a success/failure indication.
Rename "file_read_error_message()" to "cf_read_error_message()", as it
handles read errors from Wiretap, and have it take an error info string
as an argument. (That handles a lot of the work of putting the info
string into the error message.)
Make some variables in "ascend-grammar.y" static.
Check the return value of "erf_read_header()" in "erf_seek_read()".
Get rid of an unused #define in "i4btrace.c".
svn path=/trunk/; revision=9852
2004-01-25 21:55:17 +00:00
|
|
|
static gboolean visual_read(wtap *wth, int *err, gchar **err_info,
|
2006-11-05 22:46:44 +00:00
|
|
|
gint64 *data_offset);
|
2001-12-04 22:28:19 +00:00
|
|
|
static void visual_close(wtap *wth);
|
2006-11-05 22:46:44 +00:00
|
|
|
static gboolean visual_seek_read(wtap *wth, gint64 seek_off,
|
2002-07-29 06:09:59 +00:00
|
|
|
union wtap_pseudo_header *pseudo_header, guchar *pd, int packet_size,
|
Have the Wiretap open, read, and seek-and-read routines return, in
addition to an error code, an error info string, for
WTAP_ERR_UNSUPPORTED, WTAP_ERR_UNSUPPORTED_ENCAP, and
WTAP_ERR_BAD_RECORD errors. Replace the error messages logged with
"g_message()" for those errors with g_strdup()ed or g_strdup_printf()ed
strings returned as the error info string, and change the callers of
those routines to, for those errors, put the info string into the
printed message or alert box for the error.
Add messages for cases where those errors were returned without printing
an additional message.
Nobody uses the error code from "cf_read()" - "cf_read()" puts up the
alert box itself for failures; get rid of the error code, so it just
returns a success/failure indication.
Rename "file_read_error_message()" to "cf_read_error_message()", as it
handles read errors from Wiretap, and have it take an error info string
as an argument. (That handles a lot of the work of putting the info
string into the error message.)
Make some variables in "ascend-grammar.y" static.
Check the return value of "erf_read_header()" in "erf_seek_read()".
Get rid of an unused #define in "i4btrace.c".
svn path=/trunk/; revision=9852
2004-01-25 21:55:17 +00:00
|
|
|
int *err, gchar **err_info);
|
2003-10-01 07:11:49 +00:00
|
|
|
static void visual_set_pseudo_header(int encap, struct visual_pkt_hdr *vpkt_hdr,
|
2007-08-23 22:11:39 +00:00
|
|
|
struct visual_atm_hdr *vatm_hdr, union wtap_pseudo_header *pseudo_header);
|
2001-12-04 22:28:19 +00:00
|
|
|
static gboolean visual_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
|
2002-07-29 06:09:59 +00:00
|
|
|
const union wtap_pseudo_header *pseudo_header, const guchar *pd, int *err);
|
2001-12-04 22:28:19 +00:00
|
|
|
static gboolean visual_dump_close(wtap_dumper *wdh, int *err);
|
2002-05-04 10:00:18 +00:00
|
|
|
static void visual_dump_free(wtap_dumper *wdh);
|
2001-12-04 22:28:19 +00:00
|
|
|
|
|
|
|
|
|
|
|
/* Open a file for reading */
|
Have the Wiretap open, read, and seek-and-read routines return, in
addition to an error code, an error info string, for
WTAP_ERR_UNSUPPORTED, WTAP_ERR_UNSUPPORTED_ENCAP, and
WTAP_ERR_BAD_RECORD errors. Replace the error messages logged with
"g_message()" for those errors with g_strdup()ed or g_strdup_printf()ed
strings returned as the error info string, and change the callers of
those routines to, for those errors, put the info string into the
printed message or alert box for the error.
Add messages for cases where those errors were returned without printing
an additional message.
Nobody uses the error code from "cf_read()" - "cf_read()" puts up the
alert box itself for failures; get rid of the error code, so it just
returns a success/failure indication.
Rename "file_read_error_message()" to "cf_read_error_message()", as it
handles read errors from Wiretap, and have it take an error info string
as an argument. (That handles a lot of the work of putting the info
string into the error message.)
Make some variables in "ascend-grammar.y" static.
Check the return value of "erf_read_header()" in "erf_seek_read()".
Get rid of an unused #define in "i4btrace.c".
svn path=/trunk/; revision=9852
2004-01-25 21:55:17 +00:00
|
|
|
int visual_open(wtap *wth, int *err, gchar **err_info)
|
2001-12-04 22:28:19 +00:00
|
|
|
{
|
|
|
|
int bytes_read;
|
|
|
|
char magic[sizeof visual_magic];
|
|
|
|
struct visual_file_hdr vfile_hdr;
|
|
|
|
struct visual_read_info * visual;
|
|
|
|
int encap;
|
|
|
|
|
|
|
|
/* Check the magic string at the start of the file */
|
|
|
|
errno = WTAP_ERR_CANT_READ;
|
|
|
|
bytes_read = file_read(magic, 1, sizeof magic, wth->fh);
|
|
|
|
if (bytes_read != sizeof magic)
|
|
|
|
{
|
|
|
|
*err = file_error(wth->fh);
|
|
|
|
if (*err != 0)
|
|
|
|
return -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (memcmp(magic, visual_magic, sizeof visual_magic) != 0)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Read the rest of the file header. */
|
|
|
|
errno = WTAP_ERR_CANT_READ;
|
|
|
|
bytes_read = file_read(&vfile_hdr, 1, sizeof vfile_hdr, wth->fh);
|
|
|
|
if (bytes_read != sizeof vfile_hdr)
|
|
|
|
{
|
|
|
|
*err = file_error(wth->fh);
|
|
|
|
if (*err != 0)
|
|
|
|
return -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Verify the file version is known */
|
|
|
|
vfile_hdr.file_version = pletohs(&vfile_hdr.file_version);
|
|
|
|
if (vfile_hdr.file_version != 1)
|
|
|
|
{
|
|
|
|
*err = WTAP_ERR_UNSUPPORTED;
|
Have the Wiretap open, read, and seek-and-read routines return, in
addition to an error code, an error info string, for
WTAP_ERR_UNSUPPORTED, WTAP_ERR_UNSUPPORTED_ENCAP, and
WTAP_ERR_BAD_RECORD errors. Replace the error messages logged with
"g_message()" for those errors with g_strdup()ed or g_strdup_printf()ed
strings returned as the error info string, and change the callers of
those routines to, for those errors, put the info string into the
printed message or alert box for the error.
Add messages for cases where those errors were returned without printing
an additional message.
Nobody uses the error code from "cf_read()" - "cf_read()" puts up the
alert box itself for failures; get rid of the error code, so it just
returns a success/failure indication.
Rename "file_read_error_message()" to "cf_read_error_message()", as it
handles read errors from Wiretap, and have it take an error info string
as an argument. (That handles a lot of the work of putting the info
string into the error message.)
Make some variables in "ascend-grammar.y" static.
Check the return value of "erf_read_header()" in "erf_seek_read()".
Get rid of an unused #define in "i4btrace.c".
svn path=/trunk/; revision=9852
2004-01-25 21:55:17 +00:00
|
|
|
*err_info = g_strdup_printf("visual: file version %u unsupported", vfile_hdr.file_version);
|
2001-12-04 22:28:19 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Translate the encapsulation type. Note that a file with media
|
|
|
|
type 22 may contain Cisco HDLC or PPP over HDLC. This will
|
|
|
|
get sorted out after the first packet is read. */
|
|
|
|
switch (pletohs(&vfile_hdr.media_type))
|
|
|
|
{
|
2003-01-31 01:02:14 +00:00
|
|
|
case 6:
|
|
|
|
encap = WTAP_ENCAP_ETHERNET;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 9:
|
|
|
|
encap = WTAP_ENCAP_TOKEN_RING;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 16:
|
|
|
|
encap = WTAP_ENCAP_LAPB;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 22:
|
2007-03-31 22:38:10 +00:00
|
|
|
case 118:
|
2003-10-25 07:17:28 +00:00
|
|
|
encap = WTAP_ENCAP_CHDLC_WITH_PHDR;
|
2003-01-31 01:02:14 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 32:
|
|
|
|
encap = WTAP_ENCAP_FRELAY_WITH_PHDR;
|
|
|
|
break;
|
|
|
|
|
2007-08-23 22:11:39 +00:00
|
|
|
case 37:
|
|
|
|
encap = WTAP_ENCAP_ATM_PDUS;
|
|
|
|
break;
|
|
|
|
|
2001-12-04 22:28:19 +00:00
|
|
|
default:
|
|
|
|
*err = WTAP_ERR_UNSUPPORTED_ENCAP;
|
Have the Wiretap open, read, and seek-and-read routines return, in
addition to an error code, an error info string, for
WTAP_ERR_UNSUPPORTED, WTAP_ERR_UNSUPPORTED_ENCAP, and
WTAP_ERR_BAD_RECORD errors. Replace the error messages logged with
"g_message()" for those errors with g_strdup()ed or g_strdup_printf()ed
strings returned as the error info string, and change the callers of
those routines to, for those errors, put the info string into the
printed message or alert box for the error.
Add messages for cases where those errors were returned without printing
an additional message.
Nobody uses the error code from "cf_read()" - "cf_read()" puts up the
alert box itself for failures; get rid of the error code, so it just
returns a success/failure indication.
Rename "file_read_error_message()" to "cf_read_error_message()", as it
handles read errors from Wiretap, and have it take an error info string
as an argument. (That handles a lot of the work of putting the info
string into the error message.)
Make some variables in "ascend-grammar.y" static.
Check the return value of "erf_read_header()" in "erf_seek_read()".
Get rid of an unused #define in "i4btrace.c".
svn path=/trunk/; revision=9852
2004-01-25 21:55:17 +00:00
|
|
|
*err_info = g_strdup_printf("visual: network type %u unknown or unsupported",
|
|
|
|
vfile_hdr.media_type);
|
2001-12-04 22:28:19 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Fill in the wiretap struct with data from the file header */
|
|
|
|
wth->file_type = WTAP_FILE_VISUAL_NETWORKS;
|
|
|
|
wth->file_encap = encap;
|
|
|
|
wth->snapshot_length = pletohs(&vfile_hdr.max_length);
|
|
|
|
|
|
|
|
/* Save the pointer to the beginning of the packet data so
|
|
|
|
that the later seek_reads work correctly. */
|
|
|
|
wth->data_offset = CAPTUREFILE_HEADER_SIZE;
|
|
|
|
|
|
|
|
/* Set up the pointers to the handlers for this file type */
|
|
|
|
wth->subtype_read = visual_read;
|
|
|
|
wth->subtype_seek_read = visual_seek_read;
|
|
|
|
wth->subtype_close = visual_close;
|
2007-08-23 22:11:39 +00:00
|
|
|
wth->tsprecision = WTAP_FILE_TSPREC_USEC;
|
2001-12-04 22:28:19 +00:00
|
|
|
|
|
|
|
/* Add Visual-specific information to the wiretap struct for later use. */
|
|
|
|
visual = g_malloc(sizeof(struct visual_read_info));
|
|
|
|
wth->capture.generic = visual;
|
|
|
|
visual->num_pkts = pletohl(&vfile_hdr.num_pkts);
|
|
|
|
visual->start_time = ((double) pletohl(&vfile_hdr.start_time)) * 1000000;
|
|
|
|
visual->current_pkt = 1;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Read the next available packet from the file. This is called
|
|
|
|
in a loop to sequentially read the entire file one time. After
|
|
|
|
the file has been read once, any Future access to the packets is
|
|
|
|
done through seek_read. */
|
Have the Wiretap open, read, and seek-and-read routines return, in
addition to an error code, an error info string, for
WTAP_ERR_UNSUPPORTED, WTAP_ERR_UNSUPPORTED_ENCAP, and
WTAP_ERR_BAD_RECORD errors. Replace the error messages logged with
"g_message()" for those errors with g_strdup()ed or g_strdup_printf()ed
strings returned as the error info string, and change the callers of
those routines to, for those errors, put the info string into the
printed message or alert box for the error.
Add messages for cases where those errors were returned without printing
an additional message.
Nobody uses the error code from "cf_read()" - "cf_read()" puts up the
alert box itself for failures; get rid of the error code, so it just
returns a success/failure indication.
Rename "file_read_error_message()" to "cf_read_error_message()", as it
handles read errors from Wiretap, and have it take an error info string
as an argument. (That handles a lot of the work of putting the info
string into the error message.)
Make some variables in "ascend-grammar.y" static.
Check the return value of "erf_read_header()" in "erf_seek_read()".
Get rid of an unused #define in "i4btrace.c".
svn path=/trunk/; revision=9852
2004-01-25 21:55:17 +00:00
|
|
|
static gboolean visual_read(wtap *wth, int *err, gchar **err_info,
|
2006-11-05 22:46:44 +00:00
|
|
|
gint64 *data_offset)
|
2001-12-04 22:28:19 +00:00
|
|
|
{
|
|
|
|
struct visual_read_info *visual = wth->capture.generic;
|
|
|
|
guint32 packet_size = 0;
|
|
|
|
int bytes_read;
|
|
|
|
struct visual_pkt_hdr vpkt_hdr;
|
2007-08-23 22:11:39 +00:00
|
|
|
struct visual_atm_hdr vatm_hdr;
|
2001-12-04 22:28:19 +00:00
|
|
|
int phdr_size = sizeof(vpkt_hdr);
|
2007-08-23 22:11:39 +00:00
|
|
|
int ahdr_size = sizeof(vatm_hdr);
|
2001-12-04 22:28:19 +00:00
|
|
|
time_t secs;
|
|
|
|
guint32 usecs;
|
2007-03-31 22:38:10 +00:00
|
|
|
guint8 *buf;
|
2001-12-04 22:28:19 +00:00
|
|
|
double t;
|
|
|
|
|
|
|
|
/* Check for the end of the packet data. Note that a check for file EOF
|
|
|
|
will not work because there are index values stored after the last
|
|
|
|
packet's data. */
|
2002-08-28 20:30:45 +00:00
|
|
|
if (visual->current_pkt > visual->num_pkts)
|
2001-12-04 22:28:19 +00:00
|
|
|
{
|
|
|
|
*err = 0; /* it's just an EOF, not an error */
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
visual->current_pkt++;
|
|
|
|
|
|
|
|
/* Read the packet header. */
|
|
|
|
errno = WTAP_ERR_CANT_READ;
|
|
|
|
bytes_read = file_read(&vpkt_hdr, 1, phdr_size, wth->fh);
|
2002-08-28 20:30:45 +00:00
|
|
|
if (bytes_read != phdr_size)
|
2001-12-04 22:28:19 +00:00
|
|
|
{
|
|
|
|
*err = file_error(wth->fh);
|
2002-08-28 20:30:45 +00:00
|
|
|
if (*err == 0 && bytes_read != 0)
|
2001-12-04 22:28:19 +00:00
|
|
|
{
|
|
|
|
*err = WTAP_ERR_SHORT_READ;
|
|
|
|
}
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
wth->data_offset += phdr_size;
|
|
|
|
|
2007-08-23 22:11:39 +00:00
|
|
|
/* Get the included length of data. This includes extra headers + payload */
|
2001-12-04 22:28:19 +00:00
|
|
|
packet_size = pletohs(&vpkt_hdr.incl_len);
|
2007-08-23 22:11:39 +00:00
|
|
|
|
|
|
|
/* Check for additional ATM packet header */
|
|
|
|
if (wth->file_encap == WTAP_ENCAP_ATM_PDUS)
|
|
|
|
{
|
|
|
|
/* Read the atm packet header. */
|
|
|
|
errno = WTAP_ERR_CANT_READ;
|
|
|
|
bytes_read = file_read(&vatm_hdr, 1, ahdr_size, wth->fh);
|
|
|
|
if (bytes_read != ahdr_size)
|
|
|
|
{
|
|
|
|
*err = file_error(wth->fh);
|
|
|
|
if (*err == 0 && bytes_read != 0)
|
|
|
|
{
|
|
|
|
*err = WTAP_ERR_SHORT_READ;
|
|
|
|
}
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
wth->data_offset += ahdr_size;
|
|
|
|
|
|
|
|
/* Remove ATM header from length of included bytes in capture, as
|
|
|
|
this header was appended by the processor doing the packet reassembly,
|
|
|
|
and was not transmitted across the wire */
|
|
|
|
packet_size -= ahdr_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Read the packet data. */
|
2002-08-28 20:30:45 +00:00
|
|
|
if (packet_size > WTAP_MAX_PACKET_SIZE)
|
2001-12-04 22:28:19 +00:00
|
|
|
{
|
|
|
|
/* Probably a corrupt capture file; don't blow up trying
|
|
|
|
to allocate space for an immensely-large packet. */
|
|
|
|
*err = WTAP_ERR_BAD_RECORD;
|
Have the Wiretap open, read, and seek-and-read routines return, in
addition to an error code, an error info string, for
WTAP_ERR_UNSUPPORTED, WTAP_ERR_UNSUPPORTED_ENCAP, and
WTAP_ERR_BAD_RECORD errors. Replace the error messages logged with
"g_message()" for those errors with g_strdup()ed or g_strdup_printf()ed
strings returned as the error info string, and change the callers of
those routines to, for those errors, put the info string into the
printed message or alert box for the error.
Add messages for cases where those errors were returned without printing
an additional message.
Nobody uses the error code from "cf_read()" - "cf_read()" puts up the
alert box itself for failures; get rid of the error code, so it just
returns a success/failure indication.
Rename "file_read_error_message()" to "cf_read_error_message()", as it
handles read errors from Wiretap, and have it take an error info string
as an argument. (That handles a lot of the work of putting the info
string into the error message.)
Make some variables in "ascend-grammar.y" static.
Check the return value of "erf_read_header()" in "erf_seek_read()".
Get rid of an unused #define in "i4btrace.c".
svn path=/trunk/; revision=9852
2004-01-25 21:55:17 +00:00
|
|
|
*err_info = g_strdup_printf("visual: File has %u-byte packet, bigger than maximum of %u",
|
|
|
|
packet_size, WTAP_MAX_PACKET_SIZE);
|
2001-12-04 22:28:19 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
buffer_assure_space(wth->frame_buffer, packet_size);
|
|
|
|
*data_offset = wth->data_offset;
|
|
|
|
errno = WTAP_ERR_CANT_READ;
|
|
|
|
bytes_read = file_read(buffer_start_ptr(wth->frame_buffer), 1,
|
|
|
|
packet_size, wth->fh);
|
|
|
|
|
2002-08-28 20:30:45 +00:00
|
|
|
if (bytes_read != (int) packet_size)
|
2001-12-04 22:28:19 +00:00
|
|
|
{
|
|
|
|
*err = file_error(wth->fh);
|
|
|
|
if (*err == 0)
|
|
|
|
*err = WTAP_ERR_SHORT_READ;
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
wth->data_offset += packet_size;
|
|
|
|
|
|
|
|
/* Set the packet time and length. */
|
|
|
|
t = visual->start_time;
|
|
|
|
t += ((double)pletohl(&vpkt_hdr.ts_delta))*1000;
|
|
|
|
secs = (time_t)(t/1000000);
|
|
|
|
usecs = (guint32)(t - secs*1000000);
|
2005-08-24 21:31:56 +00:00
|
|
|
wth->phdr.ts.secs = secs;
|
|
|
|
wth->phdr.ts.nsecs = usecs * 1000;
|
2007-08-23 22:11:39 +00:00
|
|
|
|
|
|
|
/* Most visual capture types include FCS checks in the original length value, but
|
|
|
|
* but don't include the FCS as part of the payload or captured length.
|
|
|
|
* This causes the RTP audio payload save to fail since then captured len != orig len.
|
|
|
|
* Adjusting the original length to remove the FCS bytes we counted based
|
|
|
|
* on the file encapsualtion type.
|
|
|
|
*
|
|
|
|
* Only downside to this fix is throughput calculations will be slightly lower
|
|
|
|
* as they won't include the FCS bytes.
|
|
|
|
*/
|
|
|
|
|
2001-12-04 22:28:19 +00:00
|
|
|
wth->phdr.caplen = packet_size;
|
|
|
|
wth->phdr.len = pletohs(&vpkt_hdr.orig_len);
|
|
|
|
|
2007-08-23 22:11:39 +00:00
|
|
|
switch (wth->file_encap)
|
|
|
|
{
|
|
|
|
case WTAP_ENCAP_ETHERNET:
|
|
|
|
wth->phdr.len -= 4;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WTAP_ENCAP_FRELAY_WITH_PHDR:
|
|
|
|
case WTAP_ENCAP_CHDLC_WITH_PHDR:
|
|
|
|
case WTAP_ENCAP_LAPB:
|
|
|
|
wth->phdr.len -= 2;
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* ATM original length doesn't include any FCS. Do nothing. */
|
|
|
|
case WTAP_ENCAP_ATM_PDUS:
|
|
|
|
/* Not sure about token ring. Just leaving alone for now. */
|
|
|
|
case WTAP_ENCAP_TOKEN_RING:
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Sanity check */
|
|
|
|
if (wth->phdr.len < wth->phdr.caplen)
|
|
|
|
{
|
|
|
|
wth->phdr.len = wth->phdr.caplen;
|
|
|
|
}
|
|
|
|
|
2003-10-01 07:11:49 +00:00
|
|
|
/* Set the pseudo_header. */
|
2007-08-23 22:11:39 +00:00
|
|
|
visual_set_pseudo_header(wth->file_encap, &vpkt_hdr, &vatm_hdr, &wth->pseudo_header);
|
2001-12-04 22:28:19 +00:00
|
|
|
|
|
|
|
/* Fill in the encapsulation. Visual files have a media type in the
|
|
|
|
file header and an encapsulation type in each packet header. Files
|
|
|
|
with a media type of HDLC can be either Cisco EtherType or PPP. */
|
2007-03-31 22:38:10 +00:00
|
|
|
if (wth->file_encap == WTAP_ENCAP_CHDLC_WITH_PHDR)
|
|
|
|
{
|
|
|
|
/* examine first two octets to verify encapsulation */
|
|
|
|
buf = buffer_start_ptr(wth->frame_buffer);
|
|
|
|
if ((0xff == buf[0]) && (0x03 == buf[1]))
|
|
|
|
{
|
|
|
|
/* It is actually PPP */
|
|
|
|
wth->phdr.pkt_encap = WTAP_ENCAP_PPP_WITH_PHDR;
|
|
|
|
}
|
|
|
|
}
|
2001-12-04 22:28:19 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Close a file opened for reading. */
|
|
|
|
static void visual_close(wtap *wth)
|
|
|
|
{
|
|
|
|
/* Free the info allocated by a Visual file reader. */
|
|
|
|
if (wth->capture.generic)
|
|
|
|
g_free(wth->capture.generic);
|
|
|
|
wth->capture.generic = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Read packet data for random access.
|
|
|
|
This gets the packet data and rebuilds the pseudo header so that
|
|
|
|
the direction flag works. */
|
2006-11-05 22:46:44 +00:00
|
|
|
static gboolean visual_seek_read (wtap *wth, gint64 seek_off,
|
Have the Wiretap open, read, and seek-and-read routines return, in
addition to an error code, an error info string, for
WTAP_ERR_UNSUPPORTED, WTAP_ERR_UNSUPPORTED_ENCAP, and
WTAP_ERR_BAD_RECORD errors. Replace the error messages logged with
"g_message()" for those errors with g_strdup()ed or g_strdup_printf()ed
strings returned as the error info string, and change the callers of
those routines to, for those errors, put the info string into the
printed message or alert box for the error.
Add messages for cases where those errors were returned without printing
an additional message.
Nobody uses the error code from "cf_read()" - "cf_read()" puts up the
alert box itself for failures; get rid of the error code, so it just
returns a success/failure indication.
Rename "file_read_error_message()" to "cf_read_error_message()", as it
handles read errors from Wiretap, and have it take an error info string
as an argument. (That handles a lot of the work of putting the info
string into the error message.)
Make some variables in "ascend-grammar.y" static.
Check the return value of "erf_read_header()" in "erf_seek_read()".
Get rid of an unused #define in "i4btrace.c".
svn path=/trunk/; revision=9852
2004-01-25 21:55:17 +00:00
|
|
|
union wtap_pseudo_header *pseudo_header, guint8 *pd, int len,
|
|
|
|
int *err, gchar **err_info _U_)
|
2001-12-04 22:28:19 +00:00
|
|
|
{
|
|
|
|
struct visual_pkt_hdr vpkt_hdr;
|
2007-08-23 22:11:39 +00:00
|
|
|
struct visual_atm_hdr vatm_hdr;
|
2001-12-04 22:28:19 +00:00
|
|
|
int phdr_size = sizeof(vpkt_hdr);
|
2007-08-23 22:11:39 +00:00
|
|
|
int ahdr_size = sizeof(vatm_hdr);
|
2001-12-04 22:28:19 +00:00
|
|
|
int bytes_read;
|
2007-08-23 22:11:39 +00:00
|
|
|
int header_size;
|
2001-12-04 22:28:19 +00:00
|
|
|
|
2007-08-23 22:11:39 +00:00
|
|
|
/* Get the size of the visual packet header to skip */
|
|
|
|
header_size = sizeof(struct visual_pkt_hdr);
|
|
|
|
|
|
|
|
/* If ATM capture, need to skip over visual ATM packet header too */
|
|
|
|
if (wth->file_encap == WTAP_ENCAP_ATM_PDUS)
|
|
|
|
{
|
|
|
|
header_size += sizeof(struct visual_atm_hdr);
|
|
|
|
}
|
|
|
|
|
2001-12-04 22:28:19 +00:00
|
|
|
/* Seek to the packet header */
|
2007-08-23 22:11:39 +00:00
|
|
|
if (file_seek(wth->random_fh, seek_off - header_size,
|
2002-06-07 07:27:35 +00:00
|
|
|
SEEK_SET, err) == -1)
|
2002-03-05 08:40:27 +00:00
|
|
|
return FALSE;
|
2001-12-04 22:28:19 +00:00
|
|
|
|
|
|
|
/* Read the packet header to get the status flags. */
|
|
|
|
errno = WTAP_ERR_CANT_READ;
|
|
|
|
bytes_read = file_read(&vpkt_hdr, 1, phdr_size, wth->random_fh);
|
2002-03-05 05:58:41 +00:00
|
|
|
if (bytes_read != phdr_size) {
|
|
|
|
*err = file_error(wth->random_fh);
|
|
|
|
if (*err == 0)
|
|
|
|
*err = WTAP_ERR_SHORT_READ;
|
2002-03-05 08:40:27 +00:00
|
|
|
return FALSE;
|
2002-03-05 05:58:41 +00:00
|
|
|
}
|
2007-08-23 22:11:39 +00:00
|
|
|
|
|
|
|
/* Check for additional ATM packet header */
|
|
|
|
if (wth->file_encap == WTAP_ENCAP_ATM_PDUS)
|
|
|
|
{
|
|
|
|
/* Read the atm packet header */
|
|
|
|
errno = WTAP_ERR_CANT_READ;
|
|
|
|
bytes_read = file_read(&vatm_hdr, 1, ahdr_size, wth->random_fh);
|
|
|
|
if (bytes_read != ahdr_size)
|
|
|
|
{
|
|
|
|
*err = file_error(wth->fh);
|
|
|
|
if (*err == 0 && bytes_read != 0)
|
|
|
|
{
|
|
|
|
*err = WTAP_ERR_SHORT_READ;
|
|
|
|
}
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
}
|
2001-12-04 22:28:19 +00:00
|
|
|
|
|
|
|
/* Read the packet data. */
|
|
|
|
errno = WTAP_ERR_CANT_READ;
|
|
|
|
bytes_read = file_read(pd, sizeof(guint8), len, wth->random_fh);
|
2002-03-05 05:58:41 +00:00
|
|
|
if (bytes_read != len) {
|
|
|
|
if (*err == 0)
|
|
|
|
*err = WTAP_ERR_SHORT_READ;
|
2002-03-05 08:40:27 +00:00
|
|
|
return FALSE;
|
2002-03-05 05:58:41 +00:00
|
|
|
}
|
2001-12-04 22:28:19 +00:00
|
|
|
|
2003-10-01 07:11:49 +00:00
|
|
|
/* Set the pseudo_header. */
|
2007-08-23 22:11:39 +00:00
|
|
|
visual_set_pseudo_header(wth->file_encap, &vpkt_hdr, &vatm_hdr, pseudo_header);
|
2003-10-01 07:11:49 +00:00
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void visual_set_pseudo_header(int encap, struct visual_pkt_hdr *vpkt_hdr,
|
2007-08-23 22:11:39 +00:00
|
|
|
struct visual_atm_hdr *vatm_hdr, union wtap_pseudo_header *pseudo_header)
|
2003-10-01 07:11:49 +00:00
|
|
|
{
|
|
|
|
guint32 packet_status;
|
|
|
|
|
2001-12-04 22:28:19 +00:00
|
|
|
/* Set status flags. The only status currently supported for all
|
|
|
|
encapsulations is direction. This either goes in the p2p or the
|
|
|
|
X.25 pseudo header. It would probably be better to move this up
|
|
|
|
into the phdr. */
|
2003-10-01 07:11:49 +00:00
|
|
|
packet_status = pletohl(&vpkt_hdr->status);
|
|
|
|
switch (encap)
|
2001-12-04 22:28:19 +00:00
|
|
|
{
|
2003-10-01 07:11:49 +00:00
|
|
|
case WTAP_ENCAP_ETHERNET:
|
|
|
|
/* XXX - is there an FCS in the frame? */
|
|
|
|
pseudo_header->eth.fcs_len = -1;
|
|
|
|
break;
|
|
|
|
|
2003-10-25 07:17:28 +00:00
|
|
|
case WTAP_ENCAP_CHDLC_WITH_PHDR:
|
2001-12-04 22:28:19 +00:00
|
|
|
case WTAP_ENCAP_PPP_WITH_PHDR:
|
|
|
|
pseudo_header->p2p.sent = (packet_status & PS_SENT) ? TRUE : FALSE;
|
|
|
|
break;
|
|
|
|
|
2003-01-31 01:02:14 +00:00
|
|
|
case WTAP_ENCAP_FRELAY_WITH_PHDR:
|
2001-12-04 22:28:19 +00:00
|
|
|
case WTAP_ENCAP_LAPB:
|
2003-10-01 07:11:49 +00:00
|
|
|
pseudo_header->x25.flags =
|
|
|
|
(packet_status & PS_SENT) ? 0x00 : FROM_DCE;
|
2001-12-04 22:28:19 +00:00
|
|
|
break;
|
2007-08-23 22:11:39 +00:00
|
|
|
|
|
|
|
case WTAP_ENCAP_ATM_PDUS:
|
|
|
|
/* Set defaults */
|
|
|
|
pseudo_header->atm.type = TRAF_UNKNOWN;
|
|
|
|
pseudo_header->atm.subtype = TRAF_ST_UNKNOWN;
|
|
|
|
pseudo_header->atm.aal5t_len = 0;
|
|
|
|
|
|
|
|
/* Next two items not supported. Defaulting to zero */
|
|
|
|
pseudo_header->atm.aal5t_u2u = 0;
|
|
|
|
pseudo_header->atm.aal5t_chksum = 0;
|
|
|
|
|
|
|
|
/* Flags appear only to convey that packet is a raw cell. Set to 0 */
|
|
|
|
pseudo_header->atm.flags = 0;
|
|
|
|
|
|
|
|
/* Not supported. Defaulting to zero */
|
|
|
|
pseudo_header->atm.aal2_cid = 0;
|
|
|
|
|
|
|
|
switch(vatm_hdr->category & VN_CAT_TYPE_MASK )
|
|
|
|
{
|
|
|
|
case VN_AAL1:
|
|
|
|
pseudo_header->atm.aal = AAL_1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VN_AAL2:
|
|
|
|
pseudo_header->atm.aal = AAL_2;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VN_AAL34:
|
|
|
|
pseudo_header->atm.aal = AAL_3_4;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VN_AAL5:
|
|
|
|
pseudo_header->atm.aal = AAL_5;
|
|
|
|
pseudo_header->atm.type = TRAF_LLCMX;
|
|
|
|
pseudo_header->atm.aal5t_len = pntohl(&vatm_hdr->data_length);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VN_OAM:
|
|
|
|
/* Marking next 3 as OAM versus unknown */
|
|
|
|
case VN_O191:
|
|
|
|
case VN_IDLE:
|
|
|
|
case VN_RM:
|
|
|
|
pseudo_header->atm.aal = AAL_OAMCELL;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VN_UNKNOWN:
|
|
|
|
default:
|
|
|
|
pseudo_header->atm.aal = AAL_UNKNOWN;
|
|
|
|
break;
|
|
|
|
|
|
|
|
}
|
|
|
|
pseudo_header->atm.vpi = pntohs(&vatm_hdr->vpi) & 0x0FFF;
|
|
|
|
pseudo_header->atm.vci = pntohs(&vatm_hdr->vci);
|
|
|
|
pseudo_header->atm.cells = pntohs(&vatm_hdr->cell_count);
|
|
|
|
|
|
|
|
/* Using bit value of 1 (DCE -> DTE) to indicate From Network */
|
|
|
|
pseudo_header->atm.channel = vatm_hdr->info & FROM_NETWORK;
|
|
|
|
|
|
|
|
break;
|
2001-12-04 22:28:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-08-28 20:30:45 +00:00
|
|
|
/* Check for media types that may be written in Visual file format.
|
2001-12-04 22:28:19 +00:00
|
|
|
Returns 0 if the specified encapsulation type is supported,
|
|
|
|
an error indication otherwise. */
|
2002-02-27 08:57:25 +00:00
|
|
|
int visual_dump_can_write_encap(int encap)
|
2001-12-04 22:28:19 +00:00
|
|
|
{
|
|
|
|
/* Per-packet encapsulations aren't supported. */
|
|
|
|
if (encap == WTAP_ENCAP_PER_PACKET)
|
|
|
|
return WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED;
|
|
|
|
|
|
|
|
/* Check for supported encapsulation types */
|
|
|
|
switch (encap)
|
|
|
|
{
|
|
|
|
case WTAP_ENCAP_ETHERNET:
|
|
|
|
case WTAP_ENCAP_TOKEN_RING:
|
|
|
|
case WTAP_ENCAP_LAPB:
|
2003-10-25 07:17:28 +00:00
|
|
|
case WTAP_ENCAP_CHDLC_WITH_PHDR:
|
2003-01-31 01:02:14 +00:00
|
|
|
case WTAP_ENCAP_FRELAY_WITH_PHDR:
|
2001-12-04 22:28:19 +00:00
|
|
|
case WTAP_ENCAP_PPP:
|
|
|
|
case WTAP_ENCAP_PPP_WITH_PHDR:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return WTAP_ERR_UNSUPPORTED_ENCAP;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Open a file for writing.
|
|
|
|
Returns TRUE on success, FALSE on failure; sets "*err" to an
|
|
|
|
error code on failure */
|
2002-07-16 07:15:09 +00:00
|
|
|
gboolean visual_dump_open(wtap_dumper *wdh, gboolean cant_seek, int *err)
|
2001-12-04 22:28:19 +00:00
|
|
|
{
|
|
|
|
struct visual_write_info *visual;
|
|
|
|
|
2002-07-16 07:15:09 +00:00
|
|
|
/* We can't fill in some fields in the header until all the packets
|
|
|
|
have been written, so we can't write to a pipe. */
|
|
|
|
if (cant_seek) {
|
|
|
|
*err = WTAP_ERR_CANT_WRITE_TO_PIPE;
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2001-12-04 22:28:19 +00:00
|
|
|
/* Set the write routines for a visual file. */
|
|
|
|
wdh->subtype_write = visual_dump;
|
|
|
|
wdh->subtype_close = visual_dump_close;
|
|
|
|
|
|
|
|
/* Create a struct to hold file information for the duration
|
|
|
|
of the write */
|
|
|
|
visual = g_malloc(sizeof(struct visual_write_info));
|
|
|
|
wdh->dump.opaque = visual;
|
|
|
|
visual->index_table_index = 0;
|
|
|
|
visual->index_table_size = 1024;
|
|
|
|
visual->index_table = 0;
|
|
|
|
visual->next_offset = CAPTUREFILE_HEADER_SIZE;
|
|
|
|
|
|
|
|
/* All of the fields in the file header aren't known yet so
|
|
|
|
just skip over it for now. It will be created after all
|
|
|
|
of the packets have been written. */
|
2002-03-04 00:25:35 +00:00
|
|
|
if (fseek(wdh->fh, CAPTUREFILE_HEADER_SIZE, SEEK_SET) == -1) {
|
|
|
|
*err = errno;
|
|
|
|
return FALSE;
|
|
|
|
}
|
2001-12-04 22:28:19 +00:00
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Write a packet to a Visual dump file.
|
|
|
|
Returns TRUE on success, FALSE on failure. */
|
|
|
|
static gboolean visual_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
|
2002-07-29 06:09:59 +00:00
|
|
|
const union wtap_pseudo_header *pseudo_header, const guchar *pd, int *err)
|
2001-12-04 22:28:19 +00:00
|
|
|
{
|
|
|
|
struct visual_write_info * visual = wdh->dump.opaque;
|
|
|
|
struct visual_pkt_hdr vpkt_hdr;
|
|
|
|
size_t hdr_size = sizeof vpkt_hdr;
|
|
|
|
size_t nwritten;
|
|
|
|
unsigned delta_msec;
|
|
|
|
guint32 packet_status;
|
|
|
|
|
|
|
|
/* If the visual structure was never allocated then nothing useful
|
|
|
|
can be done. */
|
|
|
|
if (visual == 0)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
/* Zero out unused and reserved fields in the packet header. */
|
|
|
|
memset(&vpkt_hdr, 0, hdr_size);
|
|
|
|
|
|
|
|
/* Visual UpTime capture files have a capture start time in the
|
|
|
|
file header. Each packet has a capture time (in msec) relative
|
|
|
|
to the file start time. Use the time of the first packet as the
|
|
|
|
file start time. */
|
2002-08-28 20:30:45 +00:00
|
|
|
if (visual->index_table_index == 0)
|
2001-12-04 22:28:19 +00:00
|
|
|
{
|
|
|
|
/* This is the first packet. Save its start time as the file time. */
|
2007-03-21 01:32:50 +00:00
|
|
|
visual->start_time = (guint32) phdr->ts.secs;
|
2001-12-04 22:28:19 +00:00
|
|
|
|
|
|
|
/* Initialize the index table */
|
|
|
|
visual->index_table = g_malloc(1024 * sizeof *visual->index_table);
|
|
|
|
visual->index_table_size = 1024;
|
|
|
|
}
|
2002-08-28 20:30:45 +00:00
|
|
|
|
2001-12-04 22:28:19 +00:00
|
|
|
/* Calculate milliseconds since capture start. */
|
2005-08-24 21:31:56 +00:00
|
|
|
delta_msec = phdr->ts.nsecs / 1000000;
|
2007-03-21 01:32:50 +00:00
|
|
|
delta_msec += ( (guint32) phdr->ts.secs - visual->start_time) * 1000;
|
2001-12-04 22:28:19 +00:00
|
|
|
vpkt_hdr.ts_delta = htolel(delta_msec);
|
|
|
|
|
|
|
|
/* Fill in the length fields. */
|
|
|
|
vpkt_hdr.orig_len = htoles(phdr->len);
|
|
|
|
vpkt_hdr.incl_len = htoles(phdr->caplen);
|
|
|
|
|
|
|
|
/* Fill in the encapsulation hint for the file's media type. */
|
|
|
|
switch (wdh->encap)
|
|
|
|
{
|
|
|
|
case WTAP_ENCAP_ETHERNET: /* Ethernet */
|
2002-08-28 20:30:45 +00:00
|
|
|
vpkt_hdr.encap_hint = 2;
|
2001-12-04 22:28:19 +00:00
|
|
|
break;
|
|
|
|
case WTAP_ENCAP_TOKEN_RING: /* Token Ring */
|
2002-08-28 20:30:45 +00:00
|
|
|
vpkt_hdr.encap_hint = 3;
|
2001-12-04 22:28:19 +00:00
|
|
|
break;
|
|
|
|
case WTAP_ENCAP_PPP: /* PPP */
|
|
|
|
case WTAP_ENCAP_PPP_WITH_PHDR:
|
2002-08-28 20:30:45 +00:00
|
|
|
vpkt_hdr.encap_hint = 14;
|
2001-12-04 22:28:19 +00:00
|
|
|
break;
|
2003-10-25 07:17:28 +00:00
|
|
|
case WTAP_ENCAP_CHDLC_WITH_PHDR: /* HDLC Router */
|
2002-08-28 20:30:45 +00:00
|
|
|
vpkt_hdr.encap_hint = 13;
|
2001-12-04 22:28:19 +00:00
|
|
|
break;
|
2003-01-31 01:02:14 +00:00
|
|
|
case WTAP_ENCAP_FRELAY_WITH_PHDR: /* Frame Relay Auto-detect */
|
2002-08-28 20:30:45 +00:00
|
|
|
vpkt_hdr.encap_hint = 12;
|
2001-12-04 22:28:19 +00:00
|
|
|
break;
|
|
|
|
case WTAP_ENCAP_LAPB: /* Unknown */
|
|
|
|
default:
|
|
|
|
vpkt_hdr.encap_hint = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set status flags. The only status currently supported for all
|
|
|
|
encapsulations is direction. This either goes in the p2p or the
|
|
|
|
X.25 pseudo header. It would probably be better to move this up
|
|
|
|
into the phdr. */
|
|
|
|
packet_status = 0;
|
|
|
|
switch (wdh->encap)
|
|
|
|
{
|
2003-10-25 07:17:28 +00:00
|
|
|
case WTAP_ENCAP_CHDLC_WITH_PHDR:
|
2001-12-04 22:28:19 +00:00
|
|
|
packet_status |= (pseudo_header->p2p.sent ? PS_SENT : 0x00);
|
|
|
|
break;
|
|
|
|
|
2003-01-31 01:02:14 +00:00
|
|
|
case WTAP_ENCAP_FRELAY_WITH_PHDR:
|
2001-12-04 22:28:19 +00:00
|
|
|
case WTAP_ENCAP_LAPB:
|
2002-04-09 08:15:04 +00:00
|
|
|
packet_status |=
|
|
|
|
((pseudo_header->x25.flags & FROM_DCE) ? 0x00 : PS_SENT);
|
2001-12-04 22:28:19 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
vpkt_hdr.status = htolel(packet_status);
|
|
|
|
|
|
|
|
/* Write the packet header. */
|
|
|
|
nwritten = fwrite(&vpkt_hdr, 1, hdr_size, wdh->fh);
|
2002-08-28 20:30:45 +00:00
|
|
|
if (nwritten != hdr_size)
|
2001-12-04 22:28:19 +00:00
|
|
|
{
|
|
|
|
if (nwritten == 0 && ferror(wdh->fh))
|
|
|
|
*err = errno;
|
|
|
|
else
|
|
|
|
*err = WTAP_ERR_SHORT_WRITE;
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Write the packet data */
|
|
|
|
nwritten = fwrite(pd, 1, phdr->caplen, wdh->fh);
|
2002-08-28 20:30:45 +00:00
|
|
|
if (nwritten != phdr->caplen)
|
2001-12-04 22:28:19 +00:00
|
|
|
{
|
|
|
|
if (nwritten == 0 && ferror(wdh->fh))
|
|
|
|
*err = errno;
|
|
|
|
else
|
|
|
|
*err = WTAP_ERR_SHORT_WRITE;
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Store the frame offset in the index table. */
|
2002-08-28 20:30:45 +00:00
|
|
|
if (visual->index_table_index >= visual->index_table_size)
|
2001-12-04 22:28:19 +00:00
|
|
|
{
|
|
|
|
/* End of table reached. Reallocate with a larger size */
|
|
|
|
visual->index_table_size *= 2;
|
|
|
|
visual->index_table = g_realloc(visual->index_table,
|
|
|
|
visual->index_table_size * sizeof *visual->index_table);
|
|
|
|
}
|
|
|
|
visual->index_table[visual->index_table_index] = htolel(visual->next_offset);
|
|
|
|
|
|
|
|
/* Update the table index and offset for the next frame. */
|
|
|
|
visual->index_table_index++;
|
|
|
|
visual->next_offset += hdr_size + phdr->caplen;
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Finish writing to a dump file.
|
|
|
|
Returns TRUE on success, FALSE on failure. */
|
|
|
|
static gboolean visual_dump_close(wtap_dumper *wdh, int *err)
|
|
|
|
{
|
|
|
|
struct visual_write_info * visual = wdh->dump.opaque;
|
|
|
|
size_t n_to_write;
|
|
|
|
size_t nwritten;
|
|
|
|
struct visual_file_hdr vfile_hdr;
|
|
|
|
const char *magicp;
|
|
|
|
size_t magic_size;
|
|
|
|
|
|
|
|
/* If the visual structure was never allocated then nothing useful
|
|
|
|
can be done. */
|
|
|
|
if (visual == 0)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
/* Write out the frame table at the end of the file. */
|
|
|
|
if (visual->index_table)
|
|
|
|
{
|
|
|
|
/* Write the index table to the file. */
|
|
|
|
n_to_write = visual->index_table_index * sizeof *visual->index_table;
|
|
|
|
nwritten = fwrite(visual->index_table, 1, n_to_write, wdh->fh);
|
2002-08-28 20:30:45 +00:00
|
|
|
if (nwritten != n_to_write)
|
2001-12-04 22:28:19 +00:00
|
|
|
{
|
2002-05-04 10:00:18 +00:00
|
|
|
if (err != NULL)
|
|
|
|
{
|
|
|
|
if (nwritten == 0 && ferror(wdh->fh))
|
|
|
|
*err = errno;
|
|
|
|
else
|
|
|
|
*err = WTAP_ERR_SHORT_WRITE;
|
|
|
|
}
|
2001-12-04 22:28:19 +00:00
|
|
|
visual_dump_free(wdh);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Write the magic number at the start of the file. */
|
|
|
|
fseek(wdh->fh, 0, SEEK_SET);
|
|
|
|
magicp = visual_magic;
|
|
|
|
magic_size = sizeof visual_magic;
|
|
|
|
nwritten = fwrite(magicp, 1, magic_size, wdh->fh);
|
|
|
|
if (nwritten != magic_size)
|
|
|
|
{
|
2002-05-04 10:00:18 +00:00
|
|
|
if (err != NULL)
|
|
|
|
{
|
|
|
|
if (nwritten == 0 && ferror(wdh->fh))
|
|
|
|
*err = errno;
|
|
|
|
else
|
|
|
|
*err = WTAP_ERR_SHORT_WRITE;
|
|
|
|
}
|
2001-12-04 22:28:19 +00:00
|
|
|
visual_dump_free(wdh);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize the file header with zeroes for the reserved fields. */
|
|
|
|
memset(&vfile_hdr, '\0', sizeof vfile_hdr);
|
|
|
|
vfile_hdr.num_pkts = htolel(visual->index_table_index);
|
|
|
|
vfile_hdr.start_time = htolel(visual->start_time);
|
|
|
|
vfile_hdr.max_length = htoles(65535);
|
|
|
|
vfile_hdr.file_flags = htoles(1); /* indexes are present */
|
|
|
|
vfile_hdr.file_version = htoles(1);
|
2006-05-28 15:56:15 +00:00
|
|
|
strcpy(vfile_hdr.description, "Wireshark file");
|
2001-12-04 22:28:19 +00:00
|
|
|
|
|
|
|
/* Translate the encapsulation type */
|
|
|
|
switch (wdh->encap)
|
|
|
|
{
|
2003-01-31 01:02:14 +00:00
|
|
|
case WTAP_ENCAP_ETHERNET:
|
|
|
|
vfile_hdr.media_type = htoles(6);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WTAP_ENCAP_TOKEN_RING:
|
|
|
|
vfile_hdr.media_type = htoles(9);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WTAP_ENCAP_LAPB:
|
|
|
|
vfile_hdr.media_type = htoles(16);
|
|
|
|
break;
|
|
|
|
|
2001-12-04 22:28:19 +00:00
|
|
|
case WTAP_ENCAP_PPP: /* PPP is differentiated from CHDLC in PktHdr */
|
|
|
|
case WTAP_ENCAP_PPP_WITH_PHDR:
|
2003-10-25 07:17:28 +00:00
|
|
|
case WTAP_ENCAP_CHDLC_WITH_PHDR:
|
2003-01-31 01:02:14 +00:00
|
|
|
vfile_hdr.media_type = htoles(22);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WTAP_ENCAP_FRELAY_WITH_PHDR:
|
|
|
|
vfile_hdr.media_type = htoles(32);
|
|
|
|
break;
|
2001-12-04 22:28:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Write the file header following the magic bytes. */
|
|
|
|
nwritten = fwrite(&vfile_hdr, 1, sizeof vfile_hdr, wdh->fh);
|
2002-08-28 20:30:45 +00:00
|
|
|
if (nwritten != sizeof vfile_hdr)
|
2001-12-04 22:28:19 +00:00
|
|
|
{
|
2002-05-04 10:00:18 +00:00
|
|
|
if (err != NULL)
|
|
|
|
{
|
|
|
|
if (nwritten == 0 && ferror(wdh->fh))
|
|
|
|
*err = errno;
|
|
|
|
else
|
|
|
|
*err = WTAP_ERR_SHORT_WRITE;
|
|
|
|
}
|
2001-12-04 22:28:19 +00:00
|
|
|
visual_dump_free(wdh);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Deallocate the file write data */
|
|
|
|
visual_dump_free(wdh);
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Free the memory allocated by a visual file writer. */
|
|
|
|
static void visual_dump_free(wtap_dumper *wdh)
|
|
|
|
{
|
|
|
|
struct visual_write_info * visual = wdh->dump.opaque;
|
|
|
|
|
|
|
|
if (visual)
|
|
|
|
{
|
|
|
|
/* Free the index table memory. */
|
|
|
|
if (visual->index_table)
|
|
|
|
g_free(visual->index_table);
|
|
|
|
|
|
|
|
/* Free the write file info struct. */
|
|
|
|
g_free(visual);
|
|
|
|
wdh->dump.opaque = 0;
|
|
|
|
}
|
|
|
|
}
|