/* file.c
* File I/O routines
*
- * $Id: file.c,v 1.212 2000/08/24 09:16:39 guy Exp $
+ * $Id: file.c,v 1.213 2000/09/07 05:33:49 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
progbar = create_progress_dlg(load_msg, "Stop", &stop_flag);
g_free(load_msg);
- while ((data_offset = wtap_read(cf->wth, err)) > 0) {
+ while ((wtap_read(cf->wth, err, &data_offset))) {
/* Update the progress bar, but do it only N_PROGBAR_UPDATES times;
when we update it, we have to run the GTK+ main loop to get it
to repaint what's pending, and doing so may involve an "ioctl()"
gtk_clist_freeze(GTK_CLIST(packet_list));
- while (to_read != 0 && (data_offset = wtap_read(cf->wth, err)) > 0) {
+ while (to_read != 0 && (wtap_read(cf->wth, err, &data_offset))) {
if (cf->state == FILE_READ_ABORTED) {
/* Well, the user decided to exit Ethereal. Break out of the
loop, and let the code below (which is called even if there
gtk_clist_freeze(GTK_CLIST(packet_list));
- while ((data_offset = wtap_read(cf->wth, err)) > 0) {
+ while ((wtap_read(cf->wth, err, &data_offset))) {
if (cf->state == FILE_READ_ABORTED) {
/* Well, the user decided to abort the read. Break out of the
loop, and let the code below (which is called even if there
/* ascend.c
*
- * $Id: ascend.c,v 1.17 2000/08/11 13:32:37 deniel Exp $
+ * $Id: ascend.c,v 1.18 2000/09/07 05:34:07 gram Exp $
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@xiexie.org>
#define ASCEND_W1_SIZE (sizeof ascend_w1magic / sizeof ascend_w1magic[0])
#define ASCEND_W2_SIZE (sizeof ascend_w2magic / sizeof ascend_w2magic[0])
-static int ascend_read(wtap *wth, int *err);
+static gboolean ascend_read(wtap *wth, int *err, int *data_offset);
static int ascend_seek_read (wtap *wth, int seek_off,
union wtap_pseudo_header *pseudo_header, guint8 *pd, int len);
static void ascend_close(wtap *wth);
}
/* Read the next packet; called from wtap_loop(). */
-static int ascend_read(wtap *wth, int *err)
+static gboolean ascend_read(wtap *wth, int *err, int *data_offset)
{
int offset;
guint8 *buf = buffer_start_ptr(wth->frame_buffer);
wth->capture.ascend->seek_add = 0;
offset = ascend_seek(wth, ASCEND_MAX_SEEK);
if (offset < 1) {
- return 0;
+ return FALSE;
}
if (! parse_ascend(wth->fh, buf, &wth->pseudo_header.ascend, &header, 0)) {
*err = WTAP_ERR_BAD_RECORD;
- return -1;
+ return FALSE;
}
buffer_assure_space(wth->frame_buffer, wth->snapshot_length);
wth->phdr.pkt_encap = wth->file_encap;
wth->data_offset = offset;
- return offset;
+ *data_offset = offset;
+ return TRUE;
}
static int ascend_seek_read (wtap *wth, int seek_off,
/* csids.c
*
- * $Id: csids.c,v 1.3 2000/08/31 16:44:47 gram Exp $
+ * $Id: csids.c,v 1.4 2000/09/07 05:34:07 gram Exp $
*
* Copyright (c) 2000 by Mike Hall <mlh@io.com>
* Copyright (c) 2000 by Cisco Systems
*
*/
-static int csids_read(wtap *wth, int *err);
+static gboolean csids_read(wtap *wth, int *err, int *data_offset);
static int csids_seek_read(wtap *wth, int seek_off,
union wtap_pseudo_header *pseudo_header, guint8 *pd, int len);
}
/* Find the next packet and parse it; called from wtap_loop(). */
-static int csids_read(wtap *wth, int *err)
+static gboolean csids_read(wtap *wth, int *err, int *data_offset)
{
guint8 *buf;
int bytesRead = 0;
struct csids_header hdr;
- int packet_offset = wth->data_offset;
+
+ *data_offset = wth->data_offset;
bytesRead = file_read( &hdr, 1, sizeof( struct csids_header) , wth->fh );
if( bytesRead != sizeof( struct csids_header) ) {
*err = file_error( wth->fh );
- if( *err != 0 ) {
- return -1;
- } else {
- return 0;
- }
+ return FALSE;
}
hdr.seconds = pntohl(&hdr.seconds);
hdr.caplen = pntohs(&hdr.caplen);
bytesRead = file_read( buf, 1, hdr.caplen, wth->fh );
if( bytesRead != hdr.caplen ) {
*err = file_error( wth->fh );
- if( *err != 0 ) {
- return -1;
- }
+ return FALSE;
}
wth->data_offset += hdr.caplen;
*(++swap) = BSWAP16(*swap); /* ip flags and fragoff */
}
- /* This is a hack to fix the fact that have to atleast return 1
- * or we stop processing. csids has no file header. We recover from
- * this hack in csids_seek_read by checking the seek_off == 1 and
- * setting it back to 0.
- */
- return packet_offset ? packet_offset : 1;
+ return TRUE;
}
/* Used to read packets in random-access fashion */
int bytesRead = 0;
struct csids_header hdr;
- /* hack to fix a problem with the way error checking is done. If the
- * the return value from csids_read is 0 for the first packet, then
- * we stop there. So I return 1. But that messes up the offset for
- * the seek_off on this call. So if seek_off is 1 then make it 0 and
- * if it is not 1 leave it alone. --mlh
- */
- int real_seek_off = seek_off;
- if( real_seek_off == 1 ) {
- real_seek_off = 0;
- }
-
- file_seek(wth->random_fh, real_seek_off , SEEK_SET);
+ file_seek(wth->random_fh, seek_off , SEEK_SET);
bytesRead = file_read( &hdr, 1, sizeof( struct csids_header) , wth->random_fh );
if( bytesRead != sizeof( struct csids_header) ) {
/* i4btrace.c
*
- * $Id: i4btrace.c,v 1.9 2000/08/25 21:25:37 gram Exp $
+ * $Id: i4btrace.c,v 1.10 2000/09/07 05:34:08 gram Exp $
*
* Wiretap Library
* Copyright (c) 1999 by Bert Driehuis <driehuis@playbeing.org>
#include "buffer.h"
#include "i4b_trace.h"
-static int i4btrace_read(wtap *wth, int *err);
+static gboolean i4btrace_read(wtap *wth, int *err, int *data_offset);
static int i4btrace_seek_read(wtap *wth, int seek_off,
union wtap_pseudo_header *pseudo_header, u_char *pd, int length);
static int i4b_read_rec_header(FILE_T fh, i4b_trace_hdr_t *hdr, int *err);
#define V120SABME "\010\001\177"
/* Read the next packet */
-static int i4btrace_read(wtap *wth, int *err)
+static gboolean i4btrace_read(wtap *wth, int *err, int *data_offset)
{
- int record_offset;
int ret;
i4b_trace_hdr_t hdr;
guint16 length;
void *bufp;
/* Read record header. */
- record_offset = wth->data_offset;
+ *data_offset = wth->data_offset;
ret = i4b_read_rec_header(wth->fh, &hdr, err);
if (ret <= 0) {
/* Read error or EOF */
- return ret;
+ return FALSE;
}
wth->data_offset += sizeof hdr;
i4b_byte_swap_header(wth, &hdr);
length = hdr.length - sizeof(hdr);
if (length == 0)
- return 0;
+ return FALSE;
wth->phdr.len = length;
wth->phdr.caplen = length;
buffer_assure_space(wth->frame_buffer, length);
bufp = buffer_start_ptr(wth->frame_buffer);
if (i4b_read_rec_data(wth->fh, bufp, length, err) < 0)
- return -1; /* Read error */
+ return FALSE; /* Read error */
wth->data_offset += length;
/*
wth->phdr.pkt_encap = WTAP_ENCAP_NULL;
}
- /*
- * XXX - there is no file header for i4btrace files, so the
- * first record begins at the beginning of the file, hence
- * its offset is 0.
- *
- * Unfortunately, a return value of 0 means "end of file".
- *
- * Therefore, we return the record offset + 1, and compensate
- * for that in "i4btrace_seek_read()".
- */
- return record_offset + 1;
+ return TRUE;
}
static int
int err; /* XXX - return this */
i4b_trace_hdr_t hdr;
- /*
- * We subtract 1 because we added 1 before returning the record
- * offset in "i4btrace_read()"; see the comment above.
- */
- file_seek(wth->random_fh, seek_off - 1, SEEK_SET);
+ file_seek(wth->random_fh, seek_off, SEEK_SET);
/* Read record header. */
ret = i4b_read_rec_header(wth->random_fh, &hdr, &err);
/* iptrace.c
*
- * $Id: iptrace.c,v 1.30 2000/08/25 21:25:37 gram Exp $
+ * $Id: iptrace.c,v 1.31 2000/09/07 05:34:09 gram Exp $
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@xiexie.org>
#include "buffer.h"
#include "iptrace.h"
-static int iptrace_read_1_0(wtap *wth, int *err);
+static gboolean iptrace_read_1_0(wtap *wth, int *err, int *data_offset);
static int iptrace_seek_read_1_0(wtap *wth, int seek_off,
union wtap_pseudo_header *pseudo_header, u_char *pd, int packet_size);
-static int iptrace_read_2_0(wtap *wth, int *err);
+
+static gboolean iptrace_read_2_0(wtap *wth, int *err, int *data_offset);
static int iptrace_seek_read_2_0(wtap *wth, int seek_off,
union wtap_pseudo_header *pseudo_header, u_char *pd, int packet_size);
+
static int iptrace_read_rec_header(FILE_T fh, guint8 *header, int header_len,
int *err);
static int iptrace_read_rec_data(FILE_T fh, guint8 *data_ptr, int packet_size,
} iptrace_1_0_phdr;
/* Read the next packet */
-static int iptrace_read_1_0(wtap *wth, int *err)
+static gboolean iptrace_read_1_0(wtap *wth, int *err, int *data_offset)
{
- int record_offset;
int ret;
guint32 packet_size;
guint8 header[30];
iptrace_1_0_phdr pkt_hdr;
/* Read the descriptor data */
- record_offset = wth->data_offset;
+ *data_offset = wth->data_offset;
ret = iptrace_read_rec_header(wth->fh, header, 30, err);
if (ret <= 0) {
/* Read error or EOF */
- return ret;
+ return FALSE;
}
wth->data_offset += 30;
buffer_assure_space( wth->frame_buffer, packet_size );
data_ptr = buffer_start_ptr( wth->frame_buffer );
if (iptrace_read_rec_data(wth->fh, data_ptr, packet_size, err) < 0)
- return -1; /* Read error */
+ return FALSE; /* Read error */
wth->data_offset += packet_size;
wth->phdr.len = packet_size;
g_message("iptrace: interface type IFT=0x%02x unknown or unsupported",
pkt_hdr.if_type);
*err = WTAP_ERR_UNSUPPORTED_ENCAP;
- return -1;
+ return FALSE;
}
if ( wth->phdr.pkt_encap == WTAP_ENCAP_ATM_SNIFFER ) {
wth->file_encap = WTAP_ENCAP_PER_PACKET;
}
- return record_offset;
+ return TRUE;
}
static int iptrace_seek_read_1_0(wtap *wth, int seek_off,
} iptrace_2_0_phdr;
/* Read the next packet */
-static int iptrace_read_2_0(wtap *wth, int *err)
+static gboolean iptrace_read_2_0(wtap *wth, int *err, int *data_offset)
{
- int record_offset;
int ret;
guint32 packet_size;
guint8 header[40];
iptrace_2_0_phdr pkt_hdr;
/* Read the descriptor data */
- record_offset = wth->data_offset;
+ *data_offset = wth->data_offset;
ret = iptrace_read_rec_header(wth->fh, header, 40, err);
if (ret <= 0) {
/* Read error or EOF */
- return ret;
+ return FALSE;
}
wth->data_offset += 40;
buffer_assure_space( wth->frame_buffer, packet_size );
data_ptr = buffer_start_ptr( wth->frame_buffer );
if (iptrace_read_rec_data(wth->fh, data_ptr, packet_size, err) < 0)
- return -1; /* Read error */
+ return FALSE; /* Read error */
wth->data_offset += packet_size;
/* AIX saves time in nsec, not usec. It's easier to make iptrace
g_message("iptrace: interface type IFT=0x%02x unknown or unsupported",
pkt_hdr.if_type);
*err = WTAP_ERR_UNSUPPORTED_ENCAP;
- return -1;
+ return FALSE;
}
if ( wth->phdr.pkt_encap == WTAP_ENCAP_ATM_SNIFFER ) {
wth->file_encap = WTAP_ENCAP_PER_PACKET;
}
- return record_offset;
+ return TRUE;
}
static int iptrace_seek_read_2_0(wtap *wth, int seek_off,
/* lanalyzer.c
*
- * $Id: lanalyzer.c,v 1.24 2000/08/25 21:25:38 gram Exp $
+ * $Id: lanalyzer.c,v 1.25 2000/09/07 05:34:10 gram Exp $
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@xiexie.org>
#define BOARD_325 226 /* LANalyzer 325 (Ethernet) */
#define BOARD_325TR 227 /* LANalyzer 325TR (Token-ring) */
-static int lanalyzer_read(wtap *wth, int *err);
+static gboolean lanalyzer_read(wtap *wth, int *err, int *data_offset);
static void lanalyzer_close(wtap *wth);
int lanalyzer_open(wtap *wth, int *err)
#define DESCRIPTOR_LEN 32
/* Read the next packet */
-static int lanalyzer_read(wtap *wth, int *err)
+static gboolean lanalyzer_read(wtap *wth, int *err, int *data_offset)
{
int packet_size = 0;
int bytes_read;
char LE_record_length[2];
guint16 record_type, record_length;
gchar descriptor[DESCRIPTOR_LEN];
- int data_offset;
guint16 time_low, time_med, time_high, true_size;
double t;
bytes_read = file_read(LE_record_type, 1, 2, wth->fh);
if (bytes_read != 2) {
*err = file_error(wth->fh);
- if (*err != 0)
- return -1;
- if (bytes_read != 0) {
+ if (*err == 0 && bytes_read != 0) {
*err = WTAP_ERR_SHORT_READ;
- return -1;
}
- return 0;
+ return FALSE;
}
wth->data_offset += 2;
bytes_read = file_read(LE_record_length, 1, 2, wth->fh);
*err = file_error(wth->fh);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return -1;
+ return FALSE;
}
wth->data_offset += 2;
g_message("lanalyzer: record type %u seen after trace summary record",
record_type);
*err = WTAP_ERR_BAD_RECORD;
- return -1;
+ return FALSE;
}
else {
packet_size = record_length - DESCRIPTOR_LEN;
*err = file_error(wth->fh);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return -1;
+ return FALSE;
}
wth->data_offset += DESCRIPTOR_LEN;
/* Read the packet data */
buffer_assure_space(wth->frame_buffer, packet_size);
- data_offset = wth->data_offset;
+ *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);
*err = file_error(wth->fh);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return -1;
+ return FALSE;
}
wth->data_offset += packet_size;
wth->phdr.caplen = packet_size;
wth->phdr.pkt_encap = wth->file_encap;
- return data_offset;
+ return TRUE;
}
static void
/* libpcap.c
*
- * $Id: libpcap.c,v 1.38 2000/08/25 06:25:21 guy Exp $
+ * $Id: libpcap.c,v 1.39 2000/09/07 05:34:11 gram Exp $
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@xiexie.org>
#define BIT_SWAPPED_MAC_ADDRS
#endif
-static int libpcap_read(wtap *wth, int *err);
+static gboolean libpcap_read(wtap *wth, int *err, int *data_offset);
static void adjust_header(wtap *wth, struct pcaprec_hdr *hdr);
static void libpcap_close(wtap *wth);
static gboolean libpcap_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
}
/* Read the next packet */
-static int libpcap_read(wtap *wth, int *err)
+static gboolean libpcap_read(wtap *wth, int *err, int *data_offset)
{
guint packet_size;
int bytes_to_read, bytes_read;
struct pcaprec_ss990915_hdr hdr;
- int data_offset;
/* Read record header. */
errno = WTAP_ERR_CANT_READ;
bytes_read = file_read(&hdr, 1, bytes_to_read, wth->fh);
if (bytes_read != bytes_to_read) {
*err = file_error(wth->fh);
- if (*err != 0)
- return -1;
- if (bytes_read != 0) {
+ if (*err == 0 && bytes_read != 0) {
*err = WTAP_ERR_SHORT_READ;
- return -1;
}
- return 0;
+ return FALSE;
}
wth->data_offset += bytes_read;
g_message("pcap: File has %u-byte packet, bigger than maximum of %u",
packet_size, WTAP_MAX_PACKET_SIZE);
*err = WTAP_ERR_BAD_RECORD;
- return -1;
+ return FALSE;
}
buffer_assure_space(wth->frame_buffer, packet_size);
- data_offset = wth->data_offset;
+ *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);
*err = file_error(wth->fh);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return -1;
+ return FALSE;
}
wth->data_offset += packet_size;
wth->phdr.len = hdr.hdr.orig_len;
wth->phdr.pkt_encap = wth->file_encap;
- return data_offset;
+ return TRUE;
}
static void
/* netmon.c
*
- * $Id: netmon.c,v 1.32 2000/08/25 21:25:39 gram Exp $
+ * $Id: netmon.c,v 1.33 2000/09/07 05:34:12 gram Exp $
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@xiexie.org>
guint32 incl_len; /* number of octets captured in file */
};
-static int netmon_read(wtap *wth, int *err);
+static gboolean netmon_read(wtap *wth, int *err, int *data_offset);
static void netmon_close(wtap *wth);
static gboolean netmon_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
const union wtap_pseudo_header *pseudo_header, const u_char *pd, int *err);
}
/* Read the next packet */
-static int netmon_read(wtap *wth, int *err)
+static gboolean netmon_read(wtap *wth, int *err, int *data_offset)
{
netmon_t *netmon = wth->capture.netmon;
guint32 packet_size = 0;
struct netmonrec_2_x_hdr hdr_2_x;
} hdr;
int hdr_size = 0;
- int data_offset;
+ int rec_offset;
time_t secs;
guint32 usecs;
double t;
not there already (seeking to the current position
may still cause a seek and a read of the underlying file,
so we don't want to do it unconditionally). */
- data_offset = netmon->frame_table[netmon->current_frame];
- if (wth->data_offset != data_offset) {
- wth->data_offset = data_offset;
+ rec_offset = netmon->frame_table[netmon->current_frame];
+ if (wth->data_offset != rec_offset) {
+ wth->data_offset = rec_offset;
file_seek(wth->fh, wth->data_offset, SEEK_SET);
}
netmon->current_frame++;
bytes_read = file_read(&hdr, 1, hdr_size, wth->fh);
if (bytes_read != hdr_size) {
*err = file_error(wth->fh);
- if (*err != 0)
- return -1;
- if (bytes_read != 0) {
+ if (*err == 0 && bytes_read != 0) {
*err = WTAP_ERR_SHORT_READ;
- return -1;
}
- return 0;
+ return FALSE;
}
wth->data_offset += hdr_size;
g_message("netmon: File has %u-byte packet, bigger than maximum of %u",
packet_size, WTAP_MAX_PACKET_SIZE);
*err = WTAP_ERR_BAD_RECORD;
- return -1;
+ return FALSE;
}
buffer_assure_space(wth->frame_buffer, packet_size);
- data_offset = wth->data_offset;
+ *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);
*err = file_error(wth->fh);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return -1;
+ return FALSE;
}
wth->data_offset += packet_size;
}
wth->phdr.pkt_encap = wth->file_encap;
- return data_offset;
+ return TRUE;
}
static void
/* nettl.c
*
- * $Id: nettl.c,v 1.15 2000/08/25 21:25:40 gram Exp $
+ * $Id: nettl.c,v 1.16 2000/09/07 05:34:13 gram Exp $
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@xiexie.org>
/* header is followed by data and once again the total length (2 bytes) ! */
-static int nettl_read(wtap *wth, int *err);
+static gboolean nettl_read(wtap *wth, int *err, int *data_offset);
static int nettl_seek_read(wtap *wth, int seek_off,
union wtap_pseudo_header *pseudo_header, u_char *pd, int length);
static int nettl_read_rec_header(wtap *wth, FILE_T fh,
}
/* Read the next packet */
-static int nettl_read(wtap *wth, int *err)
+static gboolean nettl_read(wtap *wth, int *err, int *data_offset)
{
- int record_offset;
int ret;
/* Read record header. */
- record_offset = wth->data_offset;
+ *data_offset = wth->data_offset;
ret = nettl_read_rec_header(wth, wth->fh, &wth->phdr, &wth->pseudo_header,
err);
if (ret <= 0) {
/* Read error or EOF */
- return ret;
+ return FALSE;
}
wth->data_offset += ret;
buffer_assure_space(wth->frame_buffer, wth->phdr.caplen);
if (nettl_read_rec_data(wth->fh, buffer_start_ptr(wth->frame_buffer),
wth->phdr.caplen, err) < 0)
- return -1; /* Read error */
+ return FALSE; /* Read error */
wth->data_offset += wth->phdr.caplen;
- return record_offset;
+ return TRUE;
}
static int
/* netxray.c
*
- * $Id: netxray.c,v 1.30 2000/08/25 21:25:40 gram Exp $
+ * $Id: netxray.c,v 1.31 2000/09/07 05:34:14 gram Exp $
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@xiexie.org>
guint32 xxx[7]; /* unknown */
};
-static int netxray_read(wtap *wth, int *err);
+static gboolean netxray_read(wtap *wth, int *err, int *data_offset);
static void netxray_close(wtap *wth);
static gboolean netxray_dump_1_1(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
const union wtap_pseudo_header *pseudo_header, const u_char *pd, int *err);
}
/* Read the next packet */
-static int netxray_read(wtap *wth, int *err)
+static gboolean netxray_read(wtap *wth, int *err, int *data_offset)
{
guint32 packet_size;
int bytes_read;
struct netxrayrec_2_x_hdr hdr_2_x;
} hdr;
int hdr_size = 0;
- int data_offset;
double t;
reread:
/* Have we reached the end of the packet data? */
if (wth->data_offset == wth->capture.netxray->end_offset) {
/* Yes. */
- return 0;
+ return FALSE;
}
/* Read record header. */
switch (wth->capture.netxray->version_major) {
if (bytes_read != hdr_size) {
*err = file_error(wth->fh);
if (*err != 0)
- return -1;
+ return FALSE;
if (bytes_read != 0) {
*err = WTAP_ERR_SHORT_READ;
- return -1;
+ return FALSE;
}
/* We're at EOF. Wrap? */
}
/* We've already wrapped - don't wrap again. */
- return 0;
+ return FALSE;
}
wth->data_offset += hdr_size;
packet_size = pletohs(&hdr.hdr_1_x.incl_len);
buffer_assure_space(wth->frame_buffer, packet_size);
- data_offset = wth->data_offset;
+ *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);
*err = file_error(wth->fh);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return -1;
+ return FALSE;
}
wth->data_offset += packet_size;
wth->phdr.len = pletohs(&hdr.hdr_1_x.orig_len);
wth->phdr.pkt_encap = wth->file_encap;
- return data_offset;
+ return TRUE;
}
static void
/* ngsniffer.c
*
- * $Id: ngsniffer.c,v 1.50 2000/08/25 21:25:41 gram Exp $
+ * $Id: ngsniffer.c,v 1.51 2000/09/07 05:34:16 gram Exp $
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@xiexie.org>
static double Usec[] = { 15.0, 0.838096, 15.0, 0.5, 2.0, 1.0, 0.1 };
static int skip_header_records(wtap *wth, int *err, gint16 version);
-static int ngsniffer_read(wtap *wth, int *err);
+static gboolean ngsniffer_read(wtap *wth, int *err, int *data_offset);
static int ngsniffer_seek_read(wtap *wth, int seek_off,
union wtap_pseudo_header *pseudo_header, u_char *pd, int packet_size);
static int ngsniffer_read_rec_header(wtap *wth, gboolean is_random,
}
/* Read the next packet */
-static int ngsniffer_read(wtap *wth, int *err)
+static gboolean ngsniffer_read(wtap *wth, int *err, int *data_offset)
{
- int record_offset;
int ret;
guint16 type, length;
struct frame2_rec frame2;
/*
* Read the record header.
*/
- record_offset = wth->data_offset;
+ *data_offset = wth->data_offset;
ret = ngsniffer_read_rec_header(wth, FALSE, &type, &length,
err);
if (ret <= 0) {
/* Read error or EOF */
- return ret;
+ return FALSE;
}
wth->data_offset += 6;
*/
g_message("ngsniffer: REC_FRAME2 record in an ATM Sniffer file");
*err = WTAP_ERR_BAD_RECORD;
- return -1;
+ return FALSE;
}
/* Read the f_frame2_struct */
ret = ngsniffer_read_frame2(wth, FALSE, &frame2, err);
if (ret < 0) {
/* Read error */
- return ret;
+ return FALSE;
}
wth->data_offset += sizeof frame2;
time_low = pletohs(&frame2.time_low);
*/
g_message("ngsniffer: REC_FRAME4 record in a non-ATM Sniffer file");
*err = WTAP_ERR_BAD_RECORD;
- return -1;
+ return FALSE;
}
/* Read the f_frame4_struct */
/*
* End of file. Return an EOF indication.
*/
- return 0;
+ return FALSE;
default:
break; /* unknown type, skip it */
buffer_assure_space(wth->frame_buffer, length);
pd = buffer_start_ptr(wth->frame_buffer);
if (ngsniffer_read_rec_data(wth, FALSE, pd, length, err) < 0)
- return -1; /* Read error */
+ return FALSE; /* Read error */
wth->data_offset += length;
if (wth->file_encap == WTAP_ENCAP_UNKNOWN) {
wth->phdr.ts.tv_usec = (unsigned long)((t-(double)(wth->phdr.ts.tv_sec))
*1.0e6);
wth->phdr.pkt_encap = wth->file_encap;
- return record_offset;
+ return TRUE;
}
static int ngsniffer_seek_read(wtap *wth, int seek_off,
/* radcom.c
*
- * $Id: radcom.c,v 1.25 2000/08/25 21:25:42 gram Exp $
+ * $Id: radcom.c,v 1.26 2000/09/07 05:34:18 gram Exp $
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@xiexie.org>
char xxw[9]; /* unknown */
};
-static int radcom_read(wtap *wth, int *err);
+static gboolean radcom_read(wtap *wth, int *err, int *data_offset);
static int radcom_seek_read(wtap *wth, int seek_off,
union wtap_pseudo_header *pseudo_header, u_char *pd, int length);
static int radcom_read_rec_header(FILE_T fh, struct radcomrec_hdr *hdr,
}
/* Read the next packet */
-static int radcom_read(wtap *wth, int *err)
+static gboolean radcom_read(wtap *wth, int *err, int *data_offset)
{
- int record_offset;
int ret;
struct radcomrec_hdr hdr;
guint16 length;
char fcs[2];
/* Read record header. */
- record_offset = wth->data_offset;
+ *data_offset = wth->data_offset;
ret = radcom_read_rec_header(wth->fh, &hdr, err);
if (ret <= 0) {
/* Read error or EOF */
- return ret;
+ return FALSE;
}
wth->data_offset += sizeof hdr;
length = pletohs(&hdr.length);
- if (length == 0) return 0;
+ if (length == 0) return FALSE;
if (wth->file_encap == WTAP_ENCAP_LAPB)
length -= 2; /* FCS */
buffer_assure_space(wth->frame_buffer, length);
if (radcom_read_rec_data(wth->fh,
buffer_start_ptr(wth->frame_buffer), length, err) < 0)
- return -1; /* Read error */
+ return FALSE; /* Read error */
wth->data_offset += length;
wth->phdr.pkt_encap = wth->file_encap;
*err = file_error(wth->fh);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return -1;
+ return FALSE;
}
wth->data_offset += sizeof fcs;
}
- return record_offset;
+ return TRUE;
}
static int
/* snoop.c
*
- * $Id: snoop.c,v 1.29 2000/07/26 00:20:06 guy Exp $
+ * $Id: snoop.c,v 1.30 2000/09/07 05:34:19 gram Exp $
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@xiexie.org>
guint32 ts_usec; /* timestamp microseconds */
};
-static int snoop_read(wtap *wth, int *err);
+static gboolean snoop_read(wtap *wth, int *err, int *data_offset);
static int snoop_seek_read(wtap *wth, int seek_off,
union wtap_pseudo_header *pseudo_header, u_char *pd, int length);
static int snoop_read_atm_pseudoheader(FILE_T fh,
}
/* Read the next packet */
-static int snoop_read(wtap *wth, int *err)
+static gboolean snoop_read(wtap *wth, int *err, int *data_offset)
{
guint32 rec_size;
guint32 packet_size;
guint32 orig_size;
- int data_offset;
int bytes_read;
struct snooprec_hdr hdr;
char padbuf[4];
bytes_read = file_read(&hdr, 1, sizeof hdr, wth->fh);
if (bytes_read != sizeof hdr) {
*err = file_error(wth->fh);
- if (*err != 0)
- return -1;
- if (bytes_read != 0) {
+ if (*err == 0 && bytes_read != 0) {
*err = WTAP_ERR_SHORT_READ;
- return -1;
}
- return 0;
+ return FALSE;
}
wth->data_offset += sizeof hdr;
g_message("snoop: File has %u-byte packet, bigger than maximum of %u",
packet_size, WTAP_MAX_PACKET_SIZE);
*err = WTAP_ERR_BAD_RECORD;
- return -1;
+ return FALSE;
}
- data_offset = wth->data_offset;
+ *data_offset = wth->data_offset;
/*
* If this is an ATM packet, the first four bytes are the
g_message("snoop: atmsnoop file has a %u-byte packet, too small to have even an ATM pseudo-header\n",
packet_size);
*err = WTAP_ERR_BAD_RECORD;
- return -1;
+ return FALSE;
}
if (snoop_read_atm_pseudoheader(wth->fh, &wth->pseudo_header,
err) < 0)
- return -1; /* Read error */
+ return FALSE; /* Read error */
/*
* Don't count the pseudo-header as part of the packet.
buffer_assure_space(wth->frame_buffer, packet_size);
if (snoop_read_rec_data(wth->fh, buffer_start_ptr(wth->frame_buffer),
packet_size, err) < 0)
- return -1; /* Read error */
+ return FALSE; /* Read error */
wth->data_offset += packet_size;
wth->phdr.ts.tv_sec = ntohl(hdr.ts_sec);
*err = file_error(wth->fh);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return -1;
+ return FALSE;
}
wth->data_offset += bytes_read;
padbytes -= bytes_read;
}
- return data_offset;
+ return TRUE;
}
static int
/* toshiba.c
*
- * $Id: toshiba.c,v 1.11 2000/05/19 23:07:03 gram Exp $
+ * $Id: toshiba.c,v 1.12 2000/09/07 05:34:20 gram Exp $
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@xiexie.org>
static const char toshiba_rec_magic[] = { '[', 'N', 'o', '.' };
#define TOSHIBA_REC_MAGIC_SIZE (sizeof toshiba_rec_magic / sizeof toshiba_rec_magic[0])
-static int toshiba_read(wtap *wth, int *err);
+static gboolean toshiba_read(wtap *wth, int *err, int *data_offset);
static int toshiba_seek_read(wtap *wth, int seek_off,
union wtap_pseudo_header *pseudo_header, guint8 *pd, int len);
static gboolean parse_single_hex_dump_line(char* rec, guint8 *buf, int byte_offset);
}
/* Find the next packet and parse it; called from wtap_loop(). */
-static int toshiba_read(wtap *wth, int *err)
+static gboolean toshiba_read(wtap *wth, int *err, int *data_offset)
{
int offset = 0;
guint8 *buf;
/* Find the next packet */
offset = toshiba_seek_next_packet(wth);
if (offset < 1) {
- return 0;
+ return FALSE;
}
/* Parse the header */
parse_toshiba_hex_dump(wth->fh, pkt_len, buf, err);
wth->data_offset = offset;
- return offset;
+ *data_offset = offset;
+ return TRUE;
}
/* Used to read packets in random-access fashion */
/* wtap-int.h
*
- * $Id: wtap-int.h,v 1.7 2000/08/25 21:25:43 gram Exp $
+ * $Id: wtap-int.h,v 1.8 2000/09/07 05:34:21 gram Exp $
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@xiexie.org>
gboolean byteswapped;
} csids_t;
-typedef int (*subtype_read_func)(struct wtap*, int*);
+typedef int (*subtype_read_func)(struct wtap*, int*, int*);
typedef int (*subtype_seek_read_func)(struct wtap*, int, union wtap_pseudo_header*,
guint8*, int);
struct wtap {
/* wtap.c
*
- * $Id: wtap.c,v 1.46 2000/08/19 18:31:23 deniel Exp $
+ * $Id: wtap.c,v 1.47 2000/09/07 05:34:22 gram Exp $
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@xiexie.org>
#include "file_wrappers.h"
#include "buffer.h"
-FILE* wtap_file(wtap *wth)
+FILE*
+wtap_file(wtap *wth)
{
return wth->fh;
}
-int wtap_fd(wtap *wth)
+int
+wtap_fd(wtap *wth)
{
return wth->fd;
}
-int wtap_file_type(wtap *wth)
+int
+wtap_file_type(wtap *wth)
{
return wth->file_type;
}
-int wtap_snapshot_length(wtap *wth)
+int
+wtap_snapshot_length(wtap *wth)
{
return wth->snapshot_length;
}
-int wtap_file_encap(wtap *wth)
+int
+wtap_file_encap(wtap *wth)
{
return wth->file_encap;
}
};
/* Name that should be somewhat descriptive. */
-const char *wtap_encap_string(int encap)
+const char
+*wtap_encap_string(int encap)
{
if (encap < 0 || encap >= WTAP_NUM_ENCAP_TYPES)
return NULL;
}
/* Name to use in, say, a command-line flag specifying the type. */
-const char *wtap_encap_short_string(int encap)
+const char
+*wtap_encap_short_string(int encap)
{
if (encap < 0 || encap >= WTAP_NUM_ENCAP_TYPES)
return NULL;
}
/* Translate a short name to a capture file type. */
-int wtap_short_string_to_encap(const char *short_name)
+int
+wtap_short_string_to_encap(const char *short_name)
{
int encap;
};
#define WTAP_ERRLIST_SIZE (sizeof wtap_errlist / sizeof wtap_errlist[0])
-const char *wtap_strerror(int err)
+const char
+*wtap_strerror(int err)
{
static char errbuf[128];
int wtap_errlist_index;
Instead, if the subtype has a "sequential close" function, we call it,
to free up stuff used only by the sequential side. */
-void wtap_sequential_close(wtap *wth)
+void
+wtap_sequential_close(wtap *wth)
{
if (wth->subtype_sequential_close != NULL)
(*wth->subtype_sequential_close)(wth);
}
}
-void wtap_close(wtap *wth)
+void
+wtap_close(wtap *wth)
{
wtap_sequential_close(wth);
g_free(wth);
}
-int wtap_read(wtap *wth, int *err)
+gboolean
+wtap_read(wtap *wth, int *err, int *data_offset)
{
- return wth->subtype_read(wth, err);
+ return wth->subtype_read(wth, err, data_offset);
}
-struct wtap_pkthdr *wtap_phdr(wtap *wth)
+struct wtap_pkthdr*
+wtap_phdr(wtap *wth)
{
return &wth->phdr;
}
-union wtap_pseudo_header *wtap_pseudoheader(wtap *wth)
+union wtap_pseudo_header*
+wtap_pseudoheader(wtap *wth)
{
return &wth->pseudo_header;
}
-guint8 *wtap_buf_ptr(wtap *wth)
+guint8*
+wtap_buf_ptr(wtap *wth)
{
return buffer_start_ptr(wth->frame_buffer);
}
-int wtap_loop(wtap *wth, int count, wtap_handler callback, u_char* user,
- int *err)
+gboolean
+wtap_loop(wtap *wth, int count, wtap_handler callback, u_char* user, int *err)
{
- int data_offset, loop = 0;
+ int data_offset, loop = 0;
- /* Start be clearing error flag */
+ /* Start by clearing error flag */
*err = 0;
- while ((data_offset = wtap_read(wth, err)) > 0) {
+ while ( (wtap_read(wth, err, &data_offset)) ) {
callback(user, &wth->phdr, data_offset,
&wth->pseudo_header, buffer_start_ptr(wth->frame_buffer));
if (count > 0 && ++loop >= count)
break;
}
- if (data_offset < 0)
- return FALSE; /* failure */
- else
+
+ if (*err == 0)
return TRUE; /* success */
+ else
+ return FALSE; /* failure */
}
-int wtap_seek_read(wtap *wth, int seek_off,
+int
+wtap_seek_read(wtap *wth, int seek_off,
union wtap_pseudo_header *pseudo_header, guint8 *pd, int len)
{
return wth->subtype_seek_read(wth, seek_off, pseudo_header, pd, len);
/* wtap.h
*
- * $Id: wtap.h,v 1.77 2000/08/11 13:32:37 deniel Exp $
+ * $Id: wtap.h,v 1.78 2000/09/07 05:34:23 gram Exp $
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@xiexie.org>
* a negative number, indicating the type of error, on other failures.
*/
struct wtap* wtap_open_offline(const char *filename, int *err, gboolean do_random);
-int wtap_loop(wtap *wth, int, wtap_handler, u_char*, int*);
-int wtap_read(wtap *wth, int *err);
+
+/* Returns TRUE if entire loop-reading was successful. If read failure
+ * happened, FALSE is returned and err is set. */
+gboolean wtap_loop(wtap *wth, int, wtap_handler, u_char*, int *err);
+
+/* Returns TRUE if read was successful. FALSE if failure. data_offset is
+ * set the the offset in the file where the data for the read packet is
+ * located. */
+gboolean wtap_read(wtap *wth, int *err, int *data_offset);
+
struct wtap_pkthdr *wtap_phdr(wtap *wth);
union wtap_pseudo_header *wtap_pseudoheader(wtap *wth);
guint8 *wtap_buf_ptr(wtap *wth);
git.samba.org / obnox / wireshark / wip.git / commitdiff