process_cap_file(wtap *wth, const char *filename)
{
int status = 0;
+ int rec_type;
int err;
gchar *err_info;
gint64 size;
cf_info.encap_counts = g_new0(int,WTAP_NUM_ENCAP_TYPES);
/* Tally up data that we need to parse through the file to find */
- while (wtap_read(wth, &err, &err_info, &data_offset)) {
- phdr = wtap_phdr(wth);
- if (phdr->presence_flags & WTAP_HAS_TS) {
- prev_time = cur_time;
- cur_time = nstime_to_sec(&phdr->ts);
- if (packet == 0) {
- start_time = cur_time;
- stop_time = cur_time;
- prev_time = cur_time;
- }
- if (cur_time < prev_time) {
- order = NOT_IN_ORDER;
- }
- if (cur_time < start_time) {
- start_time = cur_time;
- }
- if (cur_time > stop_time) {
- stop_time = cur_time;
+ while ((rec_type = wtap_read(wth, &err, &err_info, &data_offset)) != -1) {
+ if (rec_type == REC_TYPE_PACKET) {
+ phdr = wtap_phdr(wth);
+ if (phdr->presence_flags & WTAP_HAS_TS) {
+ prev_time = cur_time;
+ cur_time = nstime_to_sec(&phdr->ts);
+ if (packet == 0) {
+ start_time = cur_time;
+ stop_time = cur_time;
+ prev_time = cur_time;
+ }
+ if (cur_time < prev_time) {
+ order = NOT_IN_ORDER;
+ }
+ if (cur_time < start_time) {
+ start_time = cur_time;
+ }
+ if (cur_time > stop_time) {
+ stop_time = cur_time;
+ }
+ } else {
+ have_times = FALSE; /* at least one packet has no time stamp */
+ if (order != NOT_IN_ORDER)
+ order = ORDER_UNKNOWN;
}
- } else {
- have_times = FALSE; /* at least one packet has no time stamp */
- if (order != NOT_IN_ORDER)
- order = ORDER_UNKNOWN;
- }
- bytes+=phdr->len;
- packet++;
-
- /* If caplen < len for a rcd, then presumably */
- /* 'Limit packet capture length' was done for this rcd. */
- /* Keep track as to the min/max actual snapshot lengths */
- /* seen for this file. */
- if (phdr->caplen < phdr->len) {
- if (phdr->caplen < snaplen_min_inferred)
- snaplen_min_inferred = phdr->caplen;
- if (phdr->caplen > snaplen_max_inferred)
- snaplen_max_inferred = phdr->caplen;
- }
+ bytes+=phdr->len;
+ packet++;
+
+ /* If caplen < len for a rcd, then presumably */
+ /* 'Limit packet capture length' was done for this rcd. */
+ /* Keep track as to the min/max actual snapshot lengths */
+ /* seen for this file. */
+ if (phdr->caplen < phdr->len) {
+ if (phdr->caplen < snaplen_min_inferred)
+ snaplen_min_inferred = phdr->caplen;
+ if (phdr->caplen > snaplen_max_inferred)
+ snaplen_max_inferred = phdr->caplen;
+ }
- /* Per-packet encapsulation */
- if (wtap_file_encap(wth) == WTAP_ENCAP_PER_PACKET) {
- if ((phdr->pkt_encap > 0) && (phdr->pkt_encap < WTAP_NUM_ENCAP_TYPES)) {
- cf_info.encap_counts[phdr->pkt_encap] += 1;
- } else {
- fprintf(stderr, "capinfos: Unknown per-packet encapsulation: %d [frame number: %d]\n", phdr->pkt_encap, packet);
+ /* Per-packet encapsulation */
+ if (wtap_file_encap(wth) == WTAP_ENCAP_PER_PACKET) {
+ if ((phdr->pkt_encap > 0) && (phdr->pkt_encap < WTAP_NUM_ENCAP_TYPES)) {
+ cf_info.encap_counts[phdr->pkt_encap] += 1;
+ } else {
+ fprintf(stderr, "capinfos: Unknown per-packet encapsulation: %d [frame number: %d]\n", phdr->pkt_encap, packet);
+ }
}
}
}
-/* capture child tells us we have new packets to read */
+/* capture child tells us we have new records to read */
void
-capture_input_new_packets(capture_session *cap_session, int to_read)
+capture_input_new_records(capture_session *cap_session, int to_read)
{
capture_options *capture_opts = cap_session->capture_opts;
int err;
#endif
if(capture_opts->show_info)
- capture_info_new_packets(to_read);
+ capture_info_new_records(to_read);
}
}
-/* new packets arrived */
-void capture_info_new_packets(int to_read)
+/* new records arrived */
+void capture_info_new_records(int to_read)
{
+ int rec_type;
+ int packets_read = 0;
int err;
gchar *err_info;
gint64 data_offset;
const guchar *buf;
- info_data.ui.new_packets = to_read;
-
/*g_warning("new packets: %u", to_read);*/
while (to_read > 0) {
wtap_cleareof(info_data.wtap);
- if (wtap_read(info_data.wtap, &err, &err_info, &data_offset)) {
- phdr = wtap_phdr(info_data.wtap);
- pseudo_header = &phdr->pseudo_header;
- wtap_linktype = phdr->pkt_encap;
- buf = wtap_buf_ptr(info_data.wtap);
+ if ((rec_type = wtap_read(info_data.wtap, &err, &err_info, &data_offset)) != -1) {
+ if (rec_type == REC_TYPE_PACKET) {
+ phdr = wtap_phdr(info_data.wtap);
+ pseudo_header = &phdr->pseudo_header;
+ wtap_linktype = phdr->pkt_encap;
+ buf = wtap_buf_ptr(info_data.wtap);
- capture_info_packet(&info_data.counts, wtap_linktype, buf, phdr->caplen, pseudo_header);
+ capture_info_packet(&info_data.counts, wtap_linktype, buf, phdr->caplen, pseudo_header);
+ packets_read++;
- /*g_warning("new packet");*/
+ /*g_warning("new packet");*/
+ }
to_read--;
}
}
+ info_data.ui.new_packets = packets_read;
capture_info_ui_update(&info_data.ui);
}
/* new file arrived - (eventually close old wtap), open wtap */
extern gboolean capture_info_new_file(const char *new_filename);
-/* new packets arrived - read from wtap, count */
-extern void capture_info_new_packets(int to_read);
+/* new records arrived - read from wtap, count */
+extern void capture_info_new_records(int to_read);
/* close the info - close wtap, destroy dialog */
extern void capture_info_close(void);
case SP_PACKET_COUNT:
npackets = atoi(buffer);
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_input_cb: new packets %u", npackets);
- capture_input_new_packets(cap_session, npackets);
+ capture_input_new_records(cap_session, npackets);
break;
case SP_ERROR_MSG:
/* convert primary message */
capture_input_new_file(capture_session *cap_session, gchar *new_file);
/**
- * Capture child told us we have new packets to read.
+ * Capture child told us we have new records to read.
*/
extern void
-capture_input_new_packets(capture_session *cap_session, int to_read);
+capture_input_new_records(capture_session *cap_session, int to_read);
/**
* Capture child told us how many dropped packets it counted.
int i, j, err;
gchar *err_info;
int opt;
-
+ int rec_type;
char *p;
guint32 snaplen = 0; /* No limit */
chop_t chop = {0, 0, 0, 0, 0, 0}; /* No chop */
}
}
- while (wtap_read(wth, &err, &err_info, &data_offset)) {
- read_count++;
-
- phdr = wtap_phdr(wth);
- buf = wtap_buf_ptr(wth);
-
- if (nstime_is_unset(&block_start)) { /* should only be the first packet */
- block_start.secs = phdr->ts.secs;
- block_start.nsecs = phdr->ts.nsecs;
-
- if (split_packet_count > 0 || secs_per_block > 0) {
- if (!fileset_extract_prefix_suffix(argv[optind+1], &fprefix, &fsuffix))
- exit(2);
-
- filename = fileset_get_filename_by_pattern(block_cnt++, &phdr->ts, fprefix, fsuffix);
- } else {
- filename = g_strdup(argv[optind+1]);
- }
+ while ((rec_type = wtap_read(wth, &err, &err_info, &data_offset)) != -1) {
+ if (rec_type == REC_TYPE_PACKET) {
+ read_count++;
- /* If we don't have an application name add Editcap */
- if (shb_hdr->shb_user_appl == NULL) {
- shb_hdr->shb_user_appl = "Editcap " VERSION;
- }
-
- pdh = wtap_dump_open_ng(filename, out_file_type_subtype, out_frame_type,
- snaplen ? MIN(snaplen, wtap_snapshot_length(wth)) : wtap_snapshot_length(wth),
- FALSE /* compressed */, shb_hdr, idb_inf, &err);
-
- if (pdh == NULL) {
- fprintf(stderr, "editcap: Can't open or create %s: %s\n",
- filename, wtap_strerror(err));
- exit(2);
- }
- }
+ phdr = wtap_phdr(wth);
+ buf = wtap_buf_ptr(wth);
- g_assert(filename);
+ if (nstime_is_unset(&block_start)) { /* should only be the first packet */
+ block_start.secs = phdr->ts.secs;
+ block_start.nsecs = phdr->ts.nsecs;
- if (secs_per_block > 0) {
- while ((phdr->ts.secs - block_start.secs > secs_per_block)
- || (phdr->ts.secs - block_start.secs == secs_per_block
- && phdr->ts.nsecs >= block_start.nsecs )) { /* time for the next file */
+ if (split_packet_count > 0 || secs_per_block > 0) {
+ if (!fileset_extract_prefix_suffix(argv[optind+1], &fprefix, &fsuffix))
+ exit(2);
- if (!wtap_dump_close(pdh, &err)) {
- fprintf(stderr, "editcap: Error writing to %s: %s\n",
- filename, wtap_strerror(err));
- exit(2);
+ filename = fileset_get_filename_by_pattern(block_cnt++, &phdr->ts, fprefix, fsuffix);
+ } else {
+ filename = g_strdup(argv[optind+1]);
}
- block_start.secs = block_start.secs + secs_per_block; /* reset for next interval */
- g_free(filename);
- filename = fileset_get_filename_by_pattern(block_cnt++, &phdr->ts, fprefix, fsuffix);
- g_assert(filename);
- if (verbose)
- fprintf(stderr, "Continuing writing in file %s\n", filename);
+ /* If we don't have an application name add Editcap */
+ if (shb_hdr->shb_user_appl == NULL) {
+ shb_hdr->shb_user_appl = "Editcap " VERSION;
+ }
pdh = wtap_dump_open_ng(filename, out_file_type_subtype, out_frame_type,
snaplen ? MIN(snaplen, wtap_snapshot_length(wth)) : wtap_snapshot_length(wth),
exit(2);
}
}
- }
-
- if (split_packet_count > 0) {
- /* time for the next file? */
- if (written_count > 0 && written_count % split_packet_count == 0) {
- if (!wtap_dump_close(pdh, &err)) {
- fprintf(stderr, "editcap: Error writing to %s: %s\n",
- filename, wtap_strerror(err));
- exit(2);
- }
- g_free(filename);
- filename = fileset_get_filename_by_pattern(block_cnt++, &phdr->ts, fprefix, fsuffix);
- g_assert(filename);
+ g_assert(filename);
- if (verbose)
- fprintf(stderr, "Continuing writing in file %s\n", filename);
+ if (secs_per_block > 0) {
+ while ((phdr->ts.secs - block_start.secs > secs_per_block)
+ || (phdr->ts.secs - block_start.secs == secs_per_block
+ && phdr->ts.nsecs >= block_start.nsecs )) { /* time for the next file */
- pdh = wtap_dump_open_ng(filename, out_file_type_subtype, out_frame_type,
- snaplen ? MIN(snaplen, wtap_snapshot_length(wth)) : wtap_snapshot_length(wth),
- FALSE /* compressed */, shb_hdr, idb_inf, &err);
- if (pdh == NULL) {
- fprintf(stderr, "editcap: Can't open or create %s: %s\n",
- filename, wtap_strerror(err));
- exit(2);
+ if (!wtap_dump_close(pdh, &err)) {
+ fprintf(stderr, "editcap: Error writing to %s: %s\n",
+ filename, wtap_strerror(err));
+ exit(2);
+ }
+ block_start.secs = block_start.secs + secs_per_block; /* reset for next interval */
+ g_free(filename);
+ filename = fileset_get_filename_by_pattern(block_cnt++, &phdr->ts, fprefix, fsuffix);
+ g_assert(filename);
+
+ if (verbose)
+ fprintf(stderr, "Continuing writing in file %s\n", filename);
+
+ pdh = wtap_dump_open_ng(filename, out_file_type_subtype, out_frame_type,
+ snaplen ? MIN(snaplen, wtap_snapshot_length(wth)) : wtap_snapshot_length(wth),
+ FALSE /* compressed */, shb_hdr, idb_inf, &err);
+
+ if (pdh == NULL) {
+ fprintf(stderr, "editcap: Can't open or create %s: %s\n",
+ filename, wtap_strerror(err));
+ exit(2);
+ }
}
}
- }
-
- if (check_startstop)
- ts_okay = check_timestamp(wth);
-
- if (ts_okay && ((!selected(count) && !keep_em)
- || (selected(count) && keep_em))) {
- if (verbose && !dup_detect && !dup_detect_by_time)
- fprintf(stderr, "Packet: %u\n", count);
+ if (split_packet_count > 0) {
+ /* time for the next file? */
+ if (written_count > 0 && written_count % split_packet_count == 0) {
+ if (!wtap_dump_close(pdh, &err)) {
+ fprintf(stderr, "editcap: Error writing to %s: %s\n",
+ filename, wtap_strerror(err));
+ exit(2);
+ }
- /* We simply write it, perhaps after truncating it; we could
- * do other things, like modify it. */
+ g_free(filename);
+ filename = fileset_get_filename_by_pattern(block_cnt++, &phdr->ts, fprefix, fsuffix);
+ g_assert(filename);
- phdr = wtap_phdr(wth);
+ if (verbose)
+ fprintf(stderr, "Continuing writing in file %s\n", filename);
- if (snaplen != 0) {
- if (phdr->caplen > snaplen) {
- snap_phdr = *phdr;
- snap_phdr.caplen = snaplen;
- phdr = &snap_phdr;
- }
- if (adjlen && phdr->len > snaplen) {
- snap_phdr = *phdr;
- snap_phdr.len = snaplen;
- phdr = &snap_phdr;
+ pdh = wtap_dump_open_ng(filename, out_file_type_subtype, out_frame_type,
+ snaplen ? MIN(snaplen, wtap_snapshot_length(wth)) : wtap_snapshot_length(wth),
+ FALSE /* compressed */, shb_hdr, idb_inf, &err);
+ if (pdh == NULL) {
+ fprintf(stderr, "editcap: Can't open or create %s: %s\n",
+ filename, wtap_strerror(err));
+ exit(2);
+ }
}
}
- /* CHOP */
- snap_phdr = *phdr;
- handle_chopping(chop, &snap_phdr, phdr, &buf, adjlen);
- phdr = &snap_phdr;
+ if (check_startstop)
+ ts_okay = check_timestamp(wth);
+
+ if (ts_okay && ((!selected(count) && !keep_em)
+ || (selected(count) && keep_em))) {
+
+ if (verbose && !dup_detect && !dup_detect_by_time)
+ fprintf(stderr, "Packet: %u\n", count);
+
+ /* We simply write it, perhaps after truncating it; we could
+ * do other things, like modify it. */
- /* Do we adjust timestamps to ensure strict chronological
- * order? */
- if (do_strict_time_adjustment) {
- if (previous_time.secs || previous_time.nsecs) {
- if (!strict_time_adj.is_negative) {
- nstime_t current;
- nstime_t delta;
+ phdr = wtap_phdr(wth);
- current.secs = phdr->ts.secs;
- current.nsecs = phdr->ts.nsecs;
+ if (snaplen != 0) {
+ if (phdr->caplen > snaplen) {
+ snap_phdr = *phdr;
+ snap_phdr.caplen = snaplen;
+ phdr = &snap_phdr;
+ }
+ if (adjlen && phdr->len > snaplen) {
+ snap_phdr = *phdr;
+ snap_phdr.len = snaplen;
+ phdr = &snap_phdr;
+ }
+ }
- nstime_delta(&delta, ¤t, &previous_time);
+ /* CHOP */
+ snap_phdr = *phdr;
+ handle_chopping(chop, &snap_phdr, phdr, &buf, adjlen);
+ phdr = &snap_phdr;
- if (delta.secs < 0 || delta.nsecs < 0) {
+ /* Do we adjust timestamps to ensure strict chronological
+ * order? */
+ if (do_strict_time_adjustment) {
+ if (previous_time.secs || previous_time.nsecs) {
+ if (!strict_time_adj.is_negative) {
+ nstime_t current;
+ nstime_t delta;
+
+ current.secs = phdr->ts.secs;
+ current.nsecs = phdr->ts.nsecs;
+
+ nstime_delta(&delta, ¤t, &previous_time);
+
+ if (delta.secs < 0 || delta.nsecs < 0) {
+ /*
+ * A negative delta indicates that the current packet
+ * has an absolute timestamp less than the previous packet
+ * that it is being compared to. This is NOT a normal
+ * situation since trace files usually have packets in
+ * chronological order (oldest to newest).
+ */
+ /* fprintf(stderr, "++out of order, need to adjust this packet!\n"); */
+ snap_phdr = *phdr;
+ snap_phdr.ts.secs = previous_time.secs + strict_time_adj.tv.tv_sec;
+ snap_phdr.ts.nsecs = previous_time.nsecs;
+ if (snap_phdr.ts.nsecs + strict_time_adj.tv.tv_usec * 1000 > ONE_MILLION * 1000) {
+ /* carry */
+ snap_phdr.ts.secs++;
+ snap_phdr.ts.nsecs += (strict_time_adj.tv.tv_usec - ONE_MILLION) * 1000;
+ } else {
+ snap_phdr.ts.nsecs += strict_time_adj.tv.tv_usec * 1000;
+ }
+ phdr = &snap_phdr;
+ }
+ } else {
/*
- * A negative delta indicates that the current packet
- * has an absolute timestamp less than the previous packet
- * that it is being compared to. This is NOT a normal
- * situation since trace files usually have packets in
- * chronological order (oldest to newest).
+ * A negative strict time adjustment is requested.
+ * Unconditionally set each timestamp to previous
+ * packet's timestamp plus delta.
*/
- /* fprintf(stderr, "++out of order, need to adjust this packet!\n"); */
snap_phdr = *phdr;
snap_phdr.ts.secs = previous_time.secs + strict_time_adj.tv.tv_sec;
snap_phdr.ts.nsecs = previous_time.nsecs;
}
phdr = &snap_phdr;
}
- } else {
- /*
- * A negative strict time adjustment is requested.
- * Unconditionally set each timestamp to previous
- * packet's timestamp plus delta.
- */
- snap_phdr = *phdr;
- snap_phdr.ts.secs = previous_time.secs + strict_time_adj.tv.tv_sec;
- snap_phdr.ts.nsecs = previous_time.nsecs;
- if (snap_phdr.ts.nsecs + strict_time_adj.tv.tv_usec * 1000 > ONE_MILLION * 1000) {
+ }
+ previous_time.secs = phdr->ts.secs;
+ previous_time.nsecs = phdr->ts.nsecs;
+ }
+
+ /* assume that if the frame's tv_sec is 0, then
+ * the timestamp isn't supported */
+ if (phdr->ts.secs > 0 && time_adj.tv.tv_sec != 0) {
+ snap_phdr = *phdr;
+ if (time_adj.is_negative)
+ snap_phdr.ts.secs -= time_adj.tv.tv_sec;
+ else
+ snap_phdr.ts.secs += time_adj.tv.tv_sec;
+ phdr = &snap_phdr;
+ }
+
+ /* assume that if the frame's tv_sec is 0, then
+ * the timestamp isn't supported */
+ if (phdr->ts.secs > 0 && time_adj.tv.tv_usec != 0) {
+ snap_phdr = *phdr;
+ if (time_adj.is_negative) { /* subtract */
+ if (snap_phdr.ts.nsecs/1000 < time_adj.tv.tv_usec) { /* borrow */
+ snap_phdr.ts.secs--;
+ snap_phdr.ts.nsecs += ONE_MILLION * 1000;
+ }
+ snap_phdr.ts.nsecs -= time_adj.tv.tv_usec * 1000;
+ } else { /* add */
+ if (snap_phdr.ts.nsecs + time_adj.tv.tv_usec * 1000 > ONE_MILLION * 1000) {
/* carry */
snap_phdr.ts.secs++;
- snap_phdr.ts.nsecs += (strict_time_adj.tv.tv_usec - ONE_MILLION) * 1000;
+ snap_phdr.ts.nsecs += (time_adj.tv.tv_usec - ONE_MILLION) * 1000;
} else {
- snap_phdr.ts.nsecs += strict_time_adj.tv.tv_usec * 1000;
+ snap_phdr.ts.nsecs += time_adj.tv.tv_usec * 1000;
}
- phdr = &snap_phdr;
}
+ phdr = &snap_phdr;
}
- previous_time.secs = phdr->ts.secs;
- previous_time.nsecs = phdr->ts.nsecs;
- }
-
- /* assume that if the frame's tv_sec is 0, then
- * the timestamp isn't supported */
- if (phdr->ts.secs > 0 && time_adj.tv.tv_sec != 0) {
- snap_phdr = *phdr;
- if (time_adj.is_negative)
- snap_phdr.ts.secs -= time_adj.tv.tv_sec;
- else
- snap_phdr.ts.secs += time_adj.tv.tv_sec;
- phdr = &snap_phdr;
- }
- /* assume that if the frame's tv_sec is 0, then
- * the timestamp isn't supported */
- if (phdr->ts.secs > 0 && time_adj.tv.tv_usec != 0) {
- snap_phdr = *phdr;
- if (time_adj.is_negative) { /* subtract */
- if (snap_phdr.ts.nsecs/1000 < time_adj.tv.tv_usec) { /* borrow */
- snap_phdr.ts.secs--;
- snap_phdr.ts.nsecs += ONE_MILLION * 1000;
- }
- snap_phdr.ts.nsecs -= time_adj.tv.tv_usec * 1000;
- } else { /* add */
- if (snap_phdr.ts.nsecs + time_adj.tv.tv_usec * 1000 > ONE_MILLION * 1000) {
- /* carry */
- snap_phdr.ts.secs++;
- snap_phdr.ts.nsecs += (time_adj.tv.tv_usec - ONE_MILLION) * 1000;
+ /* suppress duplicates by packet window */
+ if (dup_detect) {
+ if (is_duplicate(buf, phdr->caplen)) {
+ if (verbose) {
+ fprintf(stderr, "Skipped: %u, Len: %u, MD5 Hash: ",
+ count, phdr->caplen);
+ for (i = 0; i < 16; i++)
+ fprintf(stderr, "%02x",
+ (unsigned char)fd_hash[cur_dup_entry].digest[i]);
+ fprintf(stderr, "\n");
+ }
+ duplicate_count++;
+ count++;
+ continue;
} else {
- snap_phdr.ts.nsecs += time_adj.tv.tv_usec * 1000;
- }
- }
- phdr = &snap_phdr;
- }
-
- /* suppress duplicates by packet window */
- if (dup_detect) {
- if (is_duplicate(buf, phdr->caplen)) {
- if (verbose) {
- fprintf(stderr, "Skipped: %u, Len: %u, MD5 Hash: ",
- count, phdr->caplen);
- for (i = 0; i < 16; i++)
- fprintf(stderr, "%02x",
- (unsigned char)fd_hash[cur_dup_entry].digest[i]);
- fprintf(stderr, "\n");
- }
- duplicate_count++;
- count++;
- continue;
- } else {
- if (verbose) {
- fprintf(stderr, "Packet: %u, Len: %u, MD5 Hash: ",
- count, phdr->caplen);
- for (i = 0; i < 16; i++)
- fprintf(stderr, "%02x",
- (unsigned char)fd_hash[cur_dup_entry].digest[i]);
- fprintf(stderr, "\n");
+ if (verbose) {
+ fprintf(stderr, "Packet: %u, Len: %u, MD5 Hash: ",
+ count, phdr->caplen);
+ for (i = 0; i < 16; i++)
+ fprintf(stderr, "%02x",
+ (unsigned char)fd_hash[cur_dup_entry].digest[i]);
+ fprintf(stderr, "\n");
+ }
}
}
- }
- /* suppress duplicates by time window */
- if (dup_detect_by_time) {
- nstime_t current;
-
- current.secs = phdr->ts.secs;
- current.nsecs = phdr->ts.nsecs;
-
- if (is_duplicate_rel_time(buf, phdr->caplen, ¤t)) {
- if (verbose) {
- fprintf(stderr, "Skipped: %u, Len: %u, MD5 Hash: ",
- count, phdr->caplen);
- for (i = 0; i < 16; i++)
- fprintf(stderr, "%02x",
- (unsigned char)fd_hash[cur_dup_entry].digest[i]);
- fprintf(stderr, "\n");
- }
- duplicate_count++;
- count++;
- continue;
- } else {
- if (verbose) {
- fprintf(stderr, "Packet: %u, Len: %u, MD5 Hash: ",
- count, phdr->caplen);
- for (i = 0; i < 16; i++)
- fprintf(stderr, "%02x",
- (unsigned char)fd_hash[cur_dup_entry].digest[i]);
- fprintf(stderr, "\n");
+ /* suppress duplicates by time window */
+ if (dup_detect_by_time) {
+ nstime_t current;
+
+ current.secs = phdr->ts.secs;
+ current.nsecs = phdr->ts.nsecs;
+
+ if (is_duplicate_rel_time(buf, phdr->caplen, ¤t)) {
+ if (verbose) {
+ fprintf(stderr, "Skipped: %u, Len: %u, MD5 Hash: ",
+ count, phdr->caplen);
+ for (i = 0; i < 16; i++)
+ fprintf(stderr, "%02x",
+ (unsigned char)fd_hash[cur_dup_entry].digest[i]);
+ fprintf(stderr, "\n");
+ }
+ duplicate_count++;
+ count++;
+ continue;
+ } else {
+ if (verbose) {
+ fprintf(stderr, "Packet: %u, Len: %u, MD5 Hash: ",
+ count, phdr->caplen);
+ for (i = 0; i < 16; i++)
+ fprintf(stderr, "%02x",
+ (unsigned char)fd_hash[cur_dup_entry].digest[i]);
+ fprintf(stderr, "\n");
+ }
}
}
- }
- /* Random error mutation */
- if (err_prob > 0.0) {
- int real_data_start = 0;
+ /* Random error mutation */
+ if (err_prob > 0.0) {
+ int real_data_start = 0;
- /* Protect non-protocol data */
- if (wtap_file_type_subtype(wth) == WTAP_FILE_TYPE_SUBTYPE_CATAPULT_DCT2000)
- real_data_start = find_dct2000_real_data(buf);
+ /* Protect non-protocol data */
+ if (wtap_file_type_subtype(wth) == WTAP_FILE_TYPE_SUBTYPE_CATAPULT_DCT2000)
+ real_data_start = find_dct2000_real_data(buf);
- for (i = real_data_start; i < (int) phdr->caplen; i++) {
- if (rand() <= err_prob * RAND_MAX) {
- err_type = rand() / (RAND_MAX / ERR_WT_TOTAL + 1);
+ for (i = real_data_start; i < (int) phdr->caplen; i++) {
+ if (rand() <= err_prob * RAND_MAX) {
+ err_type = rand() / (RAND_MAX / ERR_WT_TOTAL + 1);
- if (err_type < ERR_WT_BIT) {
- buf[i] ^= 1 << (rand() / (RAND_MAX / 8 + 1));
- err_type = ERR_WT_TOTAL;
- } else {
- err_type -= ERR_WT_BYTE;
- }
+ if (err_type < ERR_WT_BIT) {
+ buf[i] ^= 1 << (rand() / (RAND_MAX / 8 + 1));
+ err_type = ERR_WT_TOTAL;
+ } else {
+ err_type -= ERR_WT_BYTE;
+ }
- if (err_type < ERR_WT_BYTE) {
- buf[i] = rand() / (RAND_MAX / 255 + 1);
- err_type = ERR_WT_TOTAL;
- } else {
- err_type -= ERR_WT_BYTE;
- }
+ if (err_type < ERR_WT_BYTE) {
+ buf[i] = rand() / (RAND_MAX / 255 + 1);
+ err_type = ERR_WT_TOTAL;
+ } else {
+ err_type -= ERR_WT_BYTE;
+ }
- if (err_type < ERR_WT_ALNUM) {
- buf[i] = ALNUM_CHARS[rand() / (RAND_MAX / ALNUM_LEN + 1)];
- err_type = ERR_WT_TOTAL;
- } else {
- err_type -= ERR_WT_ALNUM;
- }
+ if (err_type < ERR_WT_ALNUM) {
+ buf[i] = ALNUM_CHARS[rand() / (RAND_MAX / ALNUM_LEN + 1)];
+ err_type = ERR_WT_TOTAL;
+ } else {
+ err_type -= ERR_WT_ALNUM;
+ }
- if (err_type < ERR_WT_FMT) {
- if ((unsigned int)i < phdr->caplen - 2)
- g_strlcpy((char*) &buf[i], "%s", 2);
- err_type = ERR_WT_TOTAL;
- } else {
- err_type -= ERR_WT_FMT;
- }
+ if (err_type < ERR_WT_FMT) {
+ if ((unsigned int)i < phdr->caplen - 2)
+ g_strlcpy((char*) &buf[i], "%s", 2);
+ err_type = ERR_WT_TOTAL;
+ } else {
+ err_type -= ERR_WT_FMT;
+ }
- if (err_type < ERR_WT_AA) {
- for (j = i; j < (int) phdr->caplen; j++)
- buf[j] = 0xAA;
- i = phdr->caplen;
+ if (err_type < ERR_WT_AA) {
+ for (j = i; j < (int) phdr->caplen; j++)
+ buf[j] = 0xAA;
+ i = phdr->caplen;
+ }
}
}
}
- }
- if (!wtap_dump(pdh, phdr, buf, &err)) {
- switch (err) {
- case WTAP_ERR_UNSUPPORTED_ENCAP:
- /*
- * This is a problem with the particular frame we're
- * writing and the file type and subtype we're
- * writing; note that, and report the frame number
- * and file type/subtype.
- */
- fprintf(stderr,
- "editcap: Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file\n.",
- read_count, argv[optind],
- wtap_file_type_subtype_string(out_file_type_subtype));
- break;
-
- case WTAP_ERR_PACKET_TOO_LARGE:
- /*
- * This is a problem with the particular frame we're
- * writing and the file type and subtype we're
- * writing; note that, and report the frame number
- * and file type/subtype.
- */
- fprintf(stderr,
- "editcap: Frame %u of \"%s\" is too large for a \"%s\" file\n.",
- read_count, argv[optind],
- wtap_file_type_subtype_string(out_file_type_subtype));
- break;
-
- default:
- fprintf(stderr, "editcap: Error writing to %s: %s\n",
- filename, wtap_strerror(err));
- break;
+ if (!wtap_dump(pdh, phdr, buf, &err)) {
+ switch (err) {
+ case WTAP_ERR_UNSUPPORTED_ENCAP:
+ /*
+ * This is a problem with the particular frame we're
+ * writing and the file type and subtype we're
+ * writing; note that, and report the frame number
+ * and file type/subtype.
+ */
+ fprintf(stderr,
+ "editcap: Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file\n.",
+ read_count, argv[optind],
+ wtap_file_type_subtype_string(out_file_type_subtype));
+ break;
+
+ case WTAP_ERR_PACKET_TOO_LARGE:
+ /*
+ * This is a problem with the particular frame we're
+ * writing and the file type and subtype we're
+ * writing; note that, and report the frame number
+ * and file type/subtype.
+ */
+ fprintf(stderr,
+ "editcap: Frame %u of \"%s\" is too large for a \"%s\" file\n.",
+ read_count, argv[optind],
+ wtap_file_type_subtype_string(out_file_type_subtype));
+ break;
+
+ default:
+ fprintf(stderr, "editcap: Error writing to %s: %s\n",
+ filename, wtap_strerror(err));
+ break;
+ }
+ exit(2);
}
- exit(2);
+ written_count++;
}
- written_count++;
+ count++;
}
- count++;
}
g_free(fprefix);
{
int err;
gchar *err_info;
+ int rec_type;
gchar *name_ptr;
progdlg_t *progbar = NULL;
gboolean stop_flag;
}else
progbar_quantum = 0;
- while ((wtap_read(cf->wth, &err, &err_info, &data_offset))) {
+ while ((rec_type = wtap_read(cf->wth, &err, &err_info, &data_offset)) != -1) {
if (size >= 0) {
count++;
file_pos = wtap_read_so_far(cf->wth);
hours even on fast machines) just to see that it was the wrong file. */
break;
}
- read_packet(cf, dfcode, &edt, cinfo, data_offset);
+
+ if (rec_type == REC_TYPE_PACKET)
+ read_packet(cf, dfcode, &edt, cinfo, data_offset);
}
}
CATCH(OutOfMemoryError) {
cf_read_status_t
cf_continue_tail(capture_file *cf, volatile int to_read, int *err)
{
+ int rec_type;
gchar *err_info;
volatile int newly_displayed_packets = 0;
dfilter_t *dfcode;
while (to_read != 0) {
wtap_cleareof(cf->wth);
- if (!wtap_read(cf->wth, err, &err_info, &data_offset)) {
+ if ((rec_type = wtap_read(cf->wth, err, &err_info, &data_offset)) == -1) {
break;
}
if (cf->state == FILE_READ_ABORTED) {
aren't any packets left to read) exit. */
break;
}
- if (read_packet(cf, dfcode, &edt, (column_info *) cinfo, data_offset) != -1) {
- newly_displayed_packets++;
+ if (rec_type == REC_TYPE_PACKET) {
+ if (read_packet(cf, dfcode, &edt, (column_info *) cinfo, data_offset) != -1) {
+ newly_displayed_packets++;
+ }
}
to_read--;
}
cf_read_status_t
cf_finish_tail(capture_file *cf, int *err)
{
+ int rec_type;
gchar *err_info;
gint64 data_offset;
dfilter_t *dfcode;
epan_dissect_init(&edt, cf->epan, create_proto_tree, FALSE);
- while ((wtap_read(cf->wth, err, &err_info, &data_offset))) {
+ while ((rec_type = wtap_read(cf->wth, err, &err_info, &data_offset)) != -1) {
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
aren't any packets left to read) exit. */
break;
}
- read_packet(cf, dfcode, &edt, cinfo, data_offset);
+ if (rec_type == REC_TYPE_PACKET)
+ read_packet(cf, dfcode, &edt, cinfo, data_offset);
}
/* Cleanup and release all dfilter resources */
}
}
-gboolean
+int
cf_read_frame_r(capture_file *cf, const frame_data *fdata,
struct wtap_pkthdr *phdr, Buffer *buf)
{
+ int rec_type;
int err;
gchar *err_info;
gchar *display_basename;
if (!frame) {
simple_error_message_box("fdata->file_off == -1, but can't find modified frame!");
- return FALSE;
+ return -1;
}
*phdr = frame->phdr;
buffer_assure_space(buf, frame->phdr.caplen);
memcpy(buffer_start_ptr(buf), frame->pd, frame->phdr.caplen);
- return TRUE;
+ /* XXX - what if this isn't a packet? */
+ return REC_TYPE_PACKET;
}
#endif
- if (!wtap_seek_read(cf->wth, fdata->file_off, phdr, buf, &err, &err_info)) {
+ rec_type = wtap_seek_read(cf->wth, fdata->file_off, phdr, buf, &err, &err_info);
+ if (rec_type == -1) {
display_basename = g_filename_display_basename(cf->filename);
switch (err) {
break;
}
g_free(display_basename);
- return FALSE;
+ return -1;
}
- return TRUE;
+ return rec_type;
}
-gboolean
+int
cf_read_frame(capture_file *cf, frame_data *fdata)
{
return cf_read_frame_r(cf, fdata, &cf->phdr, &cf->buf);
/* Frame dependencies from the previous dissection/filtering are no longer valid. */
fdata->flags.dependent_of_displayed = 0;
- if (!cf_read_frame(cf, fdata))
+ if (cf_read_frame(cf, fdata) == -1)
break; /* error reading the frame */
/* If the previous frame is displayed, and we haven't yet seen the
}
/* Get the packet */
- if (!cf_read_frame_r(cf, fdata, &phdr, &buf)) {
+ if (cf_read_frame_r(cf, fdata, &phdr, &buf) == -1) {
/* Attempt to get the packet failed. */
ret = PSP_FAILED;
break;
epan_dissect_t edt;
/* Load the frame's data. */
- if (!cf_read_frame(cf, fdata)) {
+ if (cf_read_frame(cf, fdata) == -1) {
/* Attempt to get the packet failed. */
return MR_ERROR;
}
size_t c_match = 0;
/* Load the frame's data. */
- if (!cf_read_frame(cf, fdata)) {
+ if (cf_read_frame(cf, fdata) == -1) {
/* Attempt to get the packet failed. */
return MR_ERROR;
}
size_t c_match = 0;
/* Load the frame's data. */
- if (!cf_read_frame(cf, fdata)) {
+ if (cf_read_frame(cf, fdata) == -1) {
/* Attempt to get the packet failed. */
return MR_ERROR;
}
size_t c_match = 0;
/* Load the frame's data. */
- if (!cf_read_frame(cf, fdata)) {
+ if (cf_read_frame(cf, fdata) == -1) {
/* Attempt to get the packet failed. */
return MR_ERROR;
}
size_t c_match = 0;
/* Load the frame's data. */
- if (!cf_read_frame(cf, fdata)) {
+ if (cf_read_frame(cf, fdata) == -1) {
/* Attempt to get the packet failed. */
return MR_ERROR;
}
size_t c_match = 0;
/* Load the frame's data. */
- if (!cf_read_frame(cf, fdata)) {
+ if (cf_read_frame(cf, fdata) == -1) {
/* Attempt to get the packet failed. */
return MR_ERROR;
}
match_result result;
/* Load the frame's data. */
- if (!cf_read_frame(cf, fdata)) {
+ if (cf_read_frame(cf, fdata) == -1) {
/* Attempt to get the packet failed. */
return MR_ERROR;
}
}
/* Get the data in that frame. */
- if (!cf_read_frame (cf, fdata)) {
+ if (cf_read_frame (cf, fdata) == -1) {
return;
}
memset(&phdr, 0, sizeof(struct wtap_pkthdr));
buffer_init(&buf, 1500);
- if (!cf_read_frame_r(cf, fd, &phdr, &buf))
+ if (cf_read_frame_r(cf, fd, &phdr, &buf) == -1)
{ /* XXX, what we can do here? */ }
buffer_free(&buf);
{
const struct wtap_pkthdr *phdr;
gchar *err_info;
+ int rec_type;
gchar *name_ptr;
gint64 data_offset;
gint64 file_pos;
framenum = 0;
phdr = wtap_phdr(cf->wth);
- while ((wtap_read(cf->wth, err, &err_info, &data_offset))) {
- framenum++;
- fdata = frame_data_sequence_find(cf->frames, framenum);
- fdata->file_off = data_offset;
+ while ((rec_type = wtap_read(cf->wth, err, &err_info, &data_offset)) != -1) {
if (size >= 0) {
count++;
file_pos = wtap_read_so_far(cf->wth);
break;
}
- /* Add this packet's link-layer encapsulation type to cf->linktypes, if
- it's not already there.
- XXX - yes, this is O(N), so if every packet had a different
- link-layer encapsulation type, it'd be O(N^2) to read the file, but
- there are probably going to be a small number of encapsulation types
- in a file. */
- cf_add_encapsulation_type(cf, phdr->pkt_encap);
+ if (rec_type == REC_TYPE_PACKET) {
+ framenum++;
+ fdata = frame_data_sequence_find(cf->frames, framenum);
+ fdata->file_off = data_offset;
+
+ /* Add this packet's link-layer encapsulation type to cf->linktypes, if
+ it's not already there.
+ XXX - yes, this is O(N), so if every packet had a different
+ link-layer encapsulation type, it'd be O(N^2) to read the file, but
+ there are probably going to be a small number of encapsulation types
+ in a file. */
+ cf_add_encapsulation_type(cf, phdr->pkt_encap);
+ }
}
/* Free the display name */
cf_read_status_t cf_read(capture_file *cf, gboolean from_save);
/**
- * Read the pseudo-header and raw data for a packet. It will pop
- * up an alert box if there's an error.
+ * Read a record from a capture file. It will pop up an alert box
+ * if there's an error.
*
- * @param cf the capture file from which to read the packet
- * @param fdata the frame_data structure for the packet in question
+ * @param cf the capture file from which to read the record
+ * @param fdata the frame_data structure for the record in question
* @param phdr pointer to a wtap_pkthdr structure to contain the
- * packet's pseudo-header and other metadata
- * @param buf a Buffer into which to read the packet's raw data
- * @return TRUE if the read succeeded, FALSE if there was an error
+ * packet's pseudo-header and other metadata, if the record is a
+ * packet
+ * @param buf a Buffer into which to read the record's data
+ * @return record type if the read succeeded, -1 if there was an error
*/
-gboolean cf_read_frame_r(capture_file *cf, const frame_data *fdata,
- struct wtap_pkthdr *phdr, Buffer *buf);
+int cf_read_frame_r(capture_file *cf, const frame_data *fdata,
+ struct wtap_pkthdr *phdr, Buffer *buf);
/**
- * Read the pseudo-header and raw data for a packet into a
- * capture_file structure's pseudo_header and buf members.
+ * Read a record from a capture file into a capture_file structure's
+ * pseudo_header and buf members.
* It will pop up an alert box if there's an error.
*
- * @param cf the capture file from which to read the packet
- * @param fdata the frame_data structure for the packet in question
- * @return TRUE if the read succeeded, FALSE if there was an error
+ * @param cf the capture file from which to read the record
+ * @param fdata the frame_data structure for the record in question
+ * @return record type if the read succeeded, -1 if there was an error
*/
-gboolean cf_read_frame(capture_file *cf, frame_data *fdata);
+int cf_read_frame(capture_file *cf, frame_data *fdata);
/**
* Read packets from the "end" of a capture file.
/* XXX, what if phdr->caplen isn't equal to
* frame_tvb->tvb.length + frame_tvb->offset?
*/
- if (!wtap_seek_read(frame_tvb->wth, frame_tvb->file_off, phdr, buf, &err, &err_info)) {
+ if (wtap_seek_read(frame_tvb->wth, frame_tvb->file_off, phdr, buf, &err, &err_info) == -1) {
switch (err) {
case WTAP_ERR_UNSUPPORTED_ENCAP:
case WTAP_ERR_BAD_FILE:
/* Load the frame from the capture file */
buffer_init(&buf, 1500);
- if (!cf_read_frame_r(&cfile, frame, &phdr, &buf))
+ if (cf_read_frame_r(&cfile, frame, &phdr, &buf) == -1)
return FALSE; /* failure */
/* Dissect the frame tree not visible */
/* Re-read the first frame from the stored location */
- if (!wtap_seek_read(wth, frame->offset, &phdr, buf, &err, &err_info)) {
+ if (wtap_seek_read(wth, frame->offset, &phdr, buf, &err, &err_info) == -1) {
if (err != 0) {
/* Print a message noting that the read failed somewhere along the line. */
fprintf(stderr,
{
wtap *wth = NULL;
wtap_dumper *pdh = NULL;
+ int rec_type;
Buffer buf;
int err;
gchar *err_info;
frames = g_ptr_array_new();
/* Read each frame from infile */
- while (wtap_read(wth, &err, &err_info, &data_offset)) {
- FrameRecord_t *newFrameRecord;
+ while ((rec_type = wtap_read(wth, &err, &err_info, &data_offset)) != -1) {
+ if (rec_type == REC_TYPE_PACKET) {
+ FrameRecord_t *newFrameRecord;
- phdr = wtap_phdr(wth);
+ phdr = wtap_phdr(wth);
- newFrameRecord = g_slice_new(FrameRecord_t);
- newFrameRecord->num = frames->len + 1;
- newFrameRecord->offset = data_offset;
- newFrameRecord->time = phdr->ts;
+ newFrameRecord = g_slice_new(FrameRecord_t);
+ newFrameRecord->num = frames->len + 1;
+ newFrameRecord->offset = data_offset;
+ newFrameRecord->time = phdr->ts;
- if (prevFrame && frames_compare(&newFrameRecord, &prevFrame) < 0) {
- wrong_order_count++;
- }
+ if (prevFrame && frames_compare(&newFrameRecord, &prevFrame) < 0) {
+ wrong_order_count++;
+ }
- g_ptr_array_add(frames, newFrameRecord);
- prevFrame = newFrameRecord;
+ g_ptr_array_add(frames, newFrameRecord);
+ prevFrame = newFrameRecord;
+ }
}
if (err != 0) {
/* Print a message noting that the read failed somewhere along the line. */
for (framenum = 1; err == 0 && framenum <= cf->count; framenum++) {
fdata = frame_data_sequence_find(cf->frames, framenum);
#if 0
- if (wtap_seek_read(cf->wth, fdata->file_off,
+ if (local_wtap_seek_read(cf->wth, fdata->file_off,
&buf, fdata->cap_len, &err, &err_info)) {
process_packet_second_pass(cf, edt, fdata, &cf->phdr, &buf, tap_flags);
}
}
-/* capture child tells us we have new packets to read */
+/* capture child tells us we have new records to read */
void
-capture_input_new_packets(capture_session *cap_session, int to_read)
+capture_input_new_records(capture_session *cap_session, int to_read)
{
- gboolean ret;
+ int rec_type;
int err;
gchar *err_info;
gint64 data_offset;
while (to_read-- && cf->wth) {
wtap_cleareof(cf->wth);
- ret = wtap_read(cf->wth, &err, &err_info, &data_offset);
- if (ret == FALSE) {
+ rec_type = wtap_read(cf->wth, &err, &err_info, &data_offset);
+ if (rec_type == -1) {
/* read from file failed, tell the capture child to stop */
sync_pipe_stop(cap_session);
wtap_close(cf->wth);
cf->wth = NULL;
} else {
- ret = process_packet(cf, edt, data_offset, wtap_phdr(cf->wth),
+ if (rec_type == REC_TYPE_PACKET) {
+ if (process_packet(cf, edt, data_offset, wtap_phdr(cf->wth),
wtap_buf_ptr(cf->wth),
- tap_flags);
- }
- if (ret != FALSE) {
- /* packet successfully read and gone through the "Read Filter" */
- packet_count++;
+ tap_flags)) {
+ /* packet successfully read and gone through the "Read Filter" */
+ packet_count++;
+ }
+ }
}
}
int snapshot_length;
wtap_dumper *pdh;
guint32 framenum;
+ int rec_type;
int err;
gchar *err_info = NULL;
gint64 data_offset;
+ gboolean packet_count_reached = FALSE;
char *save_file_string = NULL;
gboolean filtering_tap_listeners;
guint tap_flags;
edt = epan_dissect_new(cf->epan, create_proto_tree, FALSE);
}
- while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
- if (process_packet_first_pass(cf, edt, data_offset, wtap_phdr(cf->wth),
- wtap_buf_ptr(cf->wth))) {
- /* Stop reading if we have the maximum number of packets;
- * When the -c option has not been used, max_packet_count
- * starts at 0, which practically means, never stop reading.
- * (unless we roll over max_packet_count ?)
- */
- if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
- err = 0; /* This is not an error */
- break;
+ while ((rec_type = wtap_read(cf->wth, &err, &err_info, &data_offset)) != -1) {
+ if (rec_type == REC_TYPE_PACKET) {
+ if (process_packet_first_pass(cf, edt, data_offset, wtap_phdr(cf->wth),
+ wtap_buf_ptr(cf->wth))) {
+ /* Stop reading if we have the maximum number of packets;
+ * When the -c option has not been used, max_packet_count
+ * starts at 0, which practically means, never stop reading.
+ * (unless we roll over max_packet_count ?)
+ */
+ if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
+ err = 0; /* This is not an error */
+ break;
+ }
}
}
}
for (framenum = 1; err == 0 && framenum <= cf->count; framenum++) {
fdata = frame_data_sequence_find(cf->frames, framenum);
- if (wtap_seek_read(cf->wth, fdata->file_off, &phdr, &buf, &err,
- &err_info)) {
- if (process_packet_second_pass(cf, edt, fdata, &phdr, &buf,
- tap_flags)) {
+ if ((rec_type = wtap_seek_read(cf->wth, fdata->file_off, &phdr, &buf, &err,
+ &err_info)) == -1) {
+ if (rec_type == REC_TYPE_PACKET) {
+ if (process_packet_second_pass(cf, edt, fdata, &phdr, &buf,
+ tap_flags)) {
+ /* Either there's no read filtering or this packet passed the
+ filter, so, if we're writing to a capture file, write
+ this packet out. */
+ if (pdh != NULL) {
+ if (!wtap_dump(pdh, &phdr, buffer_start_ptr(&buf), &err)) {
+ /* Error writing to a capture file */
+ switch (err) {
+
+ case WTAP_ERR_UNSUPPORTED_ENCAP:
+ /*
+ * This is a problem with the particular frame we're writing
+ * and the file type and subtype we're writing; note that,
+ * and report the frame number and file type/subtype.
+ *
+ * XXX - framenum is not necessarily the frame number in
+ * the input file if there was a read filter.
+ */
+ fprintf(stderr,
+ "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
+ framenum, cf->filename,
+ wtap_file_type_subtype_short_string(out_file_type));
+ break;
+
+ case WTAP_ERR_PACKET_TOO_LARGE:
+ /*
+ * This is a problem with the particular frame we're writing
+ * and the file type and subtype we're writing; note that,
+ * and report the frame number and file type/subtype.
+ *
+ * XXX - framenum is not necessarily the frame number in
+ * the input file if there was a read filter.
+ */
+ fprintf(stderr,
+ "Frame %u of \"%s\" is too large for a \"%s\" file.\n",
+ framenum, cf->filename,
+ wtap_file_type_subtype_short_string(out_file_type));
+ break;
+
+ default:
+ show_capture_file_io_error(save_file, err, FALSE);
+ break;
+ }
+ wtap_dump_close(pdh, &err);
+ g_free(shb_hdr);
+ exit(2);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if (edt) {
+ epan_dissect_free(edt);
+ edt = NULL;
+ }
+
+ buffer_free(&buf);
+ }
+ else {
+ framenum = 0;
+
+ if (do_dissection) {
+ gboolean create_proto_tree;
+
+ if (cf->rfcode || cf->dfcode || print_details || filtering_tap_listeners ||
+ (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
+ create_proto_tree = TRUE;
+ else
+ create_proto_tree = FALSE;
+
+ /* The protocol tree will be "visible", i.e., printed, only if we're
+ printing packet details, which is true if we're printing stuff
+ ("print_packet_info" is true) and we're in verbose mode
+ ("packet_details" is true). */
+ edt = epan_dissect_new(cf->epan, create_proto_tree, print_packet_info && print_details);
+ }
+
+ while ((rec_type = wtap_read(cf->wth, &err, &err_info, &data_offset)) != -1) {
+ if (rec_type == REC_TYPE_PACKET) {
+ framenum++;
+
+ if (process_packet(cf, edt, data_offset, wtap_phdr(cf->wth),
+ wtap_buf_ptr(cf->wth),
+ tap_flags)) {
/* Either there's no read filtering or this packet passed the
filter, so, if we're writing to a capture file, write
this packet out. */
if (pdh != NULL) {
- if (!wtap_dump(pdh, &phdr, buffer_start_ptr(&buf), &err)) {
+ if (!wtap_dump(pdh, wtap_phdr(cf->wth), wtap_buf_ptr(cf->wth), &err)) {
/* Error writing to a capture file */
switch (err) {
* This is a problem with the particular frame we're writing
* and the file type and subtype we're writing; note that,
* and report the frame number and file type/subtype.
- *
- * XXX - framenum is not necessarily the frame number in
- * the input file if there was a read filter.
*/
fprintf(stderr,
"Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
* This is a problem with the particular frame we're writing
* and the file type and subtype we're writing; note that,
* and report the frame number and file type/subtype.
- *
- * XXX - framenum is not necessarily the frame number in
- * the input file if there was a read filter.
*/
fprintf(stderr,
"Frame %u of \"%s\" is too large for a \"%s\" file.\n",
}
}
}
- }
- }
-
- if (edt) {
- epan_dissect_free(edt);
- edt = NULL;
- }
-
- buffer_free(&buf);
- }
- else {
- framenum = 0;
-
- if (do_dissection) {
- gboolean create_proto_tree;
- if (cf->rfcode || cf->dfcode || print_details || filtering_tap_listeners ||
- (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
- create_proto_tree = TRUE;
- else
- create_proto_tree = FALSE;
-
- /* The protocol tree will be "visible", i.e., printed, only if we're
- printing packet details, which is true if we're printing stuff
- ("print_packet_info" is true) and we're in verbose mode
- ("packet_details" is true). */
- edt = epan_dissect_new(cf->epan, create_proto_tree, print_packet_info && print_details);
- }
-
- while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
- framenum++;
-
- if (process_packet(cf, edt, data_offset, wtap_phdr(cf->wth),
- wtap_buf_ptr(cf->wth),
- tap_flags)) {
- /* Either there's no read filtering or this packet passed the
- filter, so, if we're writing to a capture file, write
- this packet out. */
- if (pdh != NULL) {
- if (!wtap_dump(pdh, wtap_phdr(cf->wth), wtap_buf_ptr(cf->wth), &err)) {
- /* Error writing to a capture file */
- switch (err) {
-
- case WTAP_ERR_UNSUPPORTED_ENCAP:
- /*
- * This is a problem with the particular frame we're writing
- * and the file type and subtype we're writing; note that,
- * and report the frame number and file type/subtype.
- */
- fprintf(stderr,
- "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
- framenum, cf->filename,
- wtap_file_type_subtype_short_string(out_file_type));
- break;
-
- case WTAP_ERR_PACKET_TOO_LARGE:
- /*
- * This is a problem with the particular frame we're writing
- * and the file type and subtype we're writing; note that,
- * and report the frame number and file type/subtype.
- */
- fprintf(stderr,
- "Frame %u of \"%s\" is too large for a \"%s\" file.\n",
- framenum, cf->filename,
- wtap_file_type_subtype_short_string(out_file_type));
- break;
-
- default:
- show_capture_file_io_error(save_file, err, FALSE);
- break;
- }
- wtap_dump_close(pdh, &err);
- g_free(shb_hdr);
- exit(2);
- }
+ /* If we're supposed to stop after max_packet_count packets,
+ * count this packet.
+ * When the -c option has not been used, max_packet_count
+ * starts at 0.
+ */
+ if (max_packet_count != 0) {
+ max_packet_count--;
+ if (max_packet_count == 0)
+ packet_count_reached = TRUE;
}
}
- /* Stop reading if we have the maximum number of packets;
- * When the -c option has not been used, max_packet_count
- * starts at 0, which practically means, never stop reading.
- * (unless we roll over max_packet_count ?)
+
+ /* Stop reading if we have the maximum number of packets or the
+ * maximum file size.
*/
- if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
+ if ( packet_count_reached || (max_byte_count != 0 && data_offset >= max_byte_count)) {
err = 0; /* This is not an error */
break;
}
static void
preview_do(GtkWidget *prev, wtap *wth)
{
+ int rec_type;
GtkWidget *label;
unsigned int elapsed_time;
time_t time_preview;
double start_time = 0; /* seconds, with nsec resolution */
double stop_time = 0; /* seconds, with nsec resolution */
double cur_time;
+ unsigned int records = 0;
unsigned int packets = 0;
gboolean is_breaked = FALSE;
gchar string_buff[PREVIEW_STR_MAX];
time(&time_preview);
- while ( (wtap_read(wth, &err, &err_info, &data_offset)) ) {
- phdr = wtap_phdr(wth);
- cur_time = nstime_to_sec(&phdr->ts);
- if (packets == 0) {
- start_time = cur_time;
- stop_time = cur_time;
- }
- if (cur_time < start_time) {
- start_time = cur_time;
- }
- if (cur_time > stop_time) {
- stop_time = cur_time;
- }
+ while ( (rec_type = wtap_read(wth, &err, &err_info, &data_offset)) != -1 ) {
+ if (rec_type == REC_TYPE_PACKET) {
+ phdr = wtap_phdr(wth);
+ cur_time = nstime_to_sec(&phdr->ts);
+ if (packets == 0) {
+ start_time = cur_time;
+ stop_time = cur_time;
+ }
+ if (cur_time < start_time) {
+ start_time = cur_time;
+ }
+ if (cur_time > stop_time) {
+ stop_time = cur_time;
+ }
- packets++;
- if (packets%1000 == 0) {
+ packets++;
+ }
+ records++;
+ if (records%1000 == 0) {
/* do we have a timeout? */
time(&time_current);
if (time_current-time_preview >= (time_t) prefs.gui_fileopen_preview) {
return; /* if we exit here it's an error */
/* dissect the current frame */
- if (!cf_read_frame(cf, fdata))
+ if (cf_read_frame(cf, fdata) == -1)
return; /* error reading the frame */
epan_dissect_init(&edt, cf->epan, TRUE, FALSE);
epan_dissect_prime_dfilter(&edt, sfcode);
if (fdata != NULL) {
epan_dissect_t edt;
- if (!cf_read_frame (&cfile, fdata))
+ if (cf_read_frame (&cfile, fdata) == -1)
return NULL; /* error reading the frame */
epan_dissect_init(&edt, cfile.epan, FALSE, FALSE);
if (fdata != NULL) {
epan_dissect_t edt;
- if (!cf_read_frame(&cfile, fdata))
+ if (cf_read_frame(&cfile, fdata) == -1)
return NULL; /* error reading the frame */
/* proto tree, visible. We need a proto tree if there's custom columns */
epan_dissect_init(&edt, cfile.epan, have_custom_cols(&cfile.cinfo), FALSE);
cinfo = NULL;
buffer_init(&buf, 1500);
- if (!cf_read_frame_r(&cfile, fdata, &phdr, &buf)) {
+ if (cf_read_frame_r(&cfile, fdata, &phdr, &buf) == -1) {
/*
* Error reading the frame.
*
}
/* With the new packetlists "lazy columns" it's necessary to reread the frame */
- if (!cf_read_frame(&cfile, fd)) {
+ if (cf_read_frame(&cfile, fd) == -1) {
/* error reading the frame */
return;
}
}
/* dissect the current frame */
- if (!cf_read_frame(cf, fdata)) {
+ if (cf_read_frame(cf, fdata) == -1) {
return NULL; /* error reading the frame */
}
return; /* if we exit here it's an error */
/* dissect the current frame */
- if (!cf_read_frame(cf, fdata))
+ if (cf_read_frame(cf, fdata) == -1)
return; /* error reading the frame */
epan_dissect_init(&edt, cf->epan, TRUE, FALSE);
epan_dissect_prime_dfilter(&edt, sfcode);
return; /* if we exit here it's an error */
/* dissect the current frame */
- if (!cf_read_frame(cf, fdata))
+ if (cf_read_frame(cf, fdata) == -1)
return; /* error reading the frame */
epan_dissect_init(&edt, cf->epan, TRUE, FALSE);
wtap *wth;
int err = 0;
gchar *err_info;
+ int rec_type;
gint64 data_offset;
const struct wtap_pkthdr *phdr;
double start_time = 0; /* seconds, with nsec resolution */
double stop_time = 0; /* seconds, with nsec resolution */
double cur_time;
+ unsigned int records = 0;
unsigned int packets = 0;
bool timed_out = FALSE;
time_t time_preview;
preview_size_.setText(QString(tr("%1 bytes")).arg(wtap_file_size(wth, &err)));
time(&time_preview);
- while ( (wtap_read(wth, &err, &err_info, &data_offset)) ) {
- phdr = wtap_phdr(wth);
- cur_time = nstime_to_sec(&phdr->ts);
- if(packets == 0) {
- start_time = cur_time;
- stop_time = cur_time;
- }
- if (cur_time < start_time) {
- start_time = cur_time;
- }
- if (cur_time > stop_time){
- stop_time = cur_time;
- }
+ while ( (rec_type = wtap_read(wth, &err, &err_info, &data_offset)) != -1 ) {
+ if (rec_type == REC_TYPE_PACKET) {
+ phdr = wtap_phdr(wth);
+ cur_time = nstime_to_sec(&phdr->ts);
+ if(packets == 0) {
+ start_time = cur_time;
+ stop_time = cur_time;
+ }
+ if (cur_time < start_time) {
+ start_time = cur_time;
+ }
+ if (cur_time > stop_time){
+ stop_time = cur_time;
+ }
- packets++;
- if(packets%1000 == 0) {
+ packets++;
+ }
+ records++;
+ if(records%1000 == 0) {
/* do we have a timeout? */
time(&time_current);
if(time_current-time_preview >= (time_t) prefs.gui_fileopen_preview) {
if (fdata != NULL) {
epan_dissect_t edt;
- if (!cf_read_frame(cap_file_, fdata))
+ if (cf_read_frame(cap_file_, fdata) == -1)
return filter; /* error reading the frame */
/* proto tree, visible. We need a proto tree if there's custom columns */
epan_dissect_init(&edt, cap_file_->epan, have_custom_cols(&cap_file_->cinfo), FALSE);
memset(&phdr, 0, sizeof(struct wtap_pkthdr));
buffer_init(&buf, 1500);
- if (!cap_file_ || !cf_read_frame_r(cap_file_, fdata, &phdr, &buf)) {
+ if (!cap_file_ || cf_read_frame_r(cap_file_, fdata, &phdr, &buf) == -1) {
/*
* Error reading the frame.
*
}
/* dissect the current frame */
- if (!cf_read_frame(cf, fdata))
+ if (cf_read_frame(cf, fdata) == -1)
return NULL; /* error reading the frame */
int err = 0;
gchar *err_info;
TCHAR string_buff[PREVIEW_STR_MAX];
+ int rec_type;
gint64 data_offset;
- guint packet = 0;
+ guint records = 0;
+ guint packets = 0;
gint64 filesize;
time_t ti_time;
struct tm *ti_tm;
SetWindowText(cur_ctrl, string_buff);
time(&time_preview);
- while ( (wtap_read(wth, &err, &err_info, &data_offset)) ) {
- phdr = wtap_phdr(wth);
- cur_time = nstime_to_sec( (const nstime_t *) &phdr->ts );
- if(packet == 0) {
- start_time = cur_time;
- stop_time = cur_time;
- }
- if (cur_time < start_time) {
- start_time = cur_time;
- }
- if (cur_time > stop_time){
- stop_time = cur_time;
+ while ( (rec_type = wtap_read(wth, &err, &err_info, &data_offset)) != -1 ) {
+ if (rec_type == REC_TYPE_PACKET) {
+ phdr = wtap_phdr(wth);
+ cur_time = nstime_to_sec( (const nstime_t *) &phdr->ts );
+ if(packets == 0) {
+ start_time = cur_time;
+ stop_time = cur_time;
+ }
+ if (cur_time < start_time) {
+ start_time = cur_time;
+ }
+ if (cur_time > stop_time){
+ stop_time = cur_time;
+ }
+ packets++;
}
- packet++;
- if(packet%100 == 0) {
+ records++;
+ if(records%100 == 0) {
time(&time_current);
if(time_current-time_preview >= (time_t) prefs.gui_fileopen_preview) {
is_breaked = TRUE;
}
if(err != 0) {
- StringCchPrintf(string_buff, PREVIEW_STR_MAX, _T("error after reading %u packets"), packet);
+ StringCchPrintf(string_buff, PREVIEW_STR_MAX, _T("error after reading %u packets"), packets);
cur_ctrl = GetDlgItem(of_hwnd, EWFD_PTX_PACKETS);
SetWindowText(cur_ctrl, string_buff);
wtap_close(wth);
/* Packets */
if(is_breaked) {
- StringCchPrintf(string_buff, PREVIEW_STR_MAX, _T("more than %u packets (preview timeout)"), packet);
+ StringCchPrintf(string_buff, PREVIEW_STR_MAX, _T("more than %u packets (preview timeout)"), packets);
} else {
- StringCchPrintf(string_buff, PREVIEW_STR_MAX, _T("%u"), packet);
+ StringCchPrintf(string_buff, PREVIEW_STR_MAX, _T("%u"), packets);
}
cur_ctrl = GetDlgItem(of_hwnd, EWFD_PTX_PACKETS);
SetWindowText(cur_ctrl, string_buff);
#define CST_5VW_CAPTURES_RECORD (CST_5VW_SECTION_CAPTURES << 28) /* 0x80000000 */
#define CST_5VW_SYSTEM_RECORD 0x00000000U
-static gboolean _5views_read(wtap *wth, int *err, gchar **err_info,
+static int _5views_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean _5views_seek_read(wtap *wth, gint64 seek_off,
+static int _5views_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
static int _5views_read_header(wtap *wth, FILE_T fh, t_5VW_TimeStamped_Header *hdr,
struct wtap_pkthdr *phdr, int *err, gchar **err_info);
}
/* Read the next packet */
-static gboolean
+static int
_5views_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
{
t_5VW_TimeStamped_Header TimeStamped_Header;
/* Read record header. */
if (!_5views_read_header(wth, wth->fh, &TimeStamped_Header,
&wth->phdr, err, err_info))
- return FALSE;
+ return -1;
if (TimeStamped_Header.RecSubType == CST_5VW_FRAME_RECORD) {
/*
* Not a packet - skip to the next record.
*/
if (file_seek(wth->fh, TimeStamped_Header.RecSize, SEEK_CUR, err) == -1)
- return FALSE;
+ return -1;
} while (1);
if (wth->phdr.caplen > WTAP_MAX_PACKET_SIZE) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("5views: File has %u-byte packet, bigger than maximum of %u",
wth->phdr.caplen, WTAP_MAX_PACKET_SIZE);
- return FALSE;
+ return -1;
}
- return wtap_read_packet_bytes(wth->fh, wth->frame_buffer,
- wth->phdr.caplen, err, err_info);
+ if (!wtap_read_packet_bytes(wth->fh, wth->frame_buffer,
+ wth->phdr.caplen, err, err_info))
+ return -1;
+ return REC_TYPE_PACKET;
}
static gboolean
t_5VW_TimeStamped_Header TimeStamped_Header;
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
/*
* Read the header.
phdr, err, err_info)) {
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
/*
* Read the packet data.
*/
- return wtap_read_packet_bytes(wth->random_fh, buf, phdr->caplen,
- err, err_info);
+ if (!wtap_read_packet_bytes(wth->random_fh, buf, phdr->caplen,
+ err, err_info))
+ return -1;
+ return REC_TYPE_PACKET;
}
/* Read the header of the next packet. Return TRUE on success, FALSE
time_t start;
} aethra_t;
-static gboolean aethra_read(wtap *wth, int *err, gchar **err_info,
+static int aethra_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean aethra_seek_read(wtap *wth, gint64 seek_off,
+static int aethra_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
static gboolean aethra_read_rec_header(wtap *wth, FILE_T fh, struct aethrarec_hdr *hdr,
struct wtap_pkthdr *phdr, int *err, gchar **err_info);
#endif
/* Read the next packet */
-static gboolean aethra_read(wtap *wth, int *err, gchar **err_info,
+static int aethra_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
struct aethrarec_hdr hdr;
/* Read record header. */
if (!aethra_read_rec_header(wth, wth->fh, &hdr, &wth->phdr, err, err_info))
- return FALSE;
+ return -1;
/*
* XXX - if this is big, we might waste memory by
if (wth->phdr.caplen != 0) {
if (!wtap_read_packet_bytes(wth->fh, wth->frame_buffer,
wth->phdr.caplen, err, err_info))
- return FALSE; /* Read error */
+ return -1; /* Read error */
}
#if 0
packet++;
}
found:
- return TRUE;
+ return REC_TYPE_PACKET;
}
-static gboolean
+static int
aethra_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr,
Buffer *buf, int *err, gchar **err_info)
{
struct aethrarec_hdr hdr;
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
if (!aethra_read_rec_header(wth, wth->random_fh, &hdr, phdr, err,
err_info)) {
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
/*
* Read the packet data.
*/
if (!wtap_read_packet_bytes(wth->random_fh, buf, phdr->caplen, err, err_info))
- return FALSE; /* failed */
+ return -1; /* failed */
- return TRUE;
+ return REC_TYPE_PACKET;
}
static gboolean
{ ASCEND_PFX_ETHER, "ETHER" },
};
-static gboolean ascend_read(wtap *wth, int *err, gchar **err_info,
+static int ascend_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean ascend_seek_read(wtap *wth, gint64 seek_off,
+static int ascend_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf,
int *err, gchar **err_info);
packet's header because we might mistake part of it for a new header. */
if (file_seek(wth->fh, ascend->next_packet_seek_start,
SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
offset = ascend_seek(wth, err, err_info);
if (offset == -1)
- return FALSE;
+ return -1;
if (parse_ascend(ascend, wth->fh, &wth->phdr, wth->frame_buffer,
wth->snapshot_length) != PARSED_RECORD) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup((ascend_parse_error != NULL) ? ascend_parse_error : "parse error");
- return FALSE;
+ return -1;
}
*data_offset = offset;
- return TRUE;
+ return REC_TYPE_PACKET;
}
-static gboolean ascend_seek_read(wtap *wth, gint64 seek_off,
+static int ascend_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf,
int *err, gchar **err_info)
{
ascend_t *ascend = (ascend_t *)wth->priv;
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
if (parse_ascend(ascend, wth->random_fh, phdr, buf,
wth->snapshot_length) != PARSED_RECORD) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup((ascend_parse_error != NULL) ? ascend_parse_error : "parse error");
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
#define BER_UNI_TAG_SEQ 16 /* SEQUENCE, SEQUENCE OF */
#define BER_UNI_TAG_SET 17 /* SET, SET OF */
-static gboolean ber_read_file(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
- Buffer *buf, int *err, gchar **err_info)
+static int ber_read_file(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
+ Buffer *buf, int *err, gchar **err_info)
{
gint64 file_size;
int packet_size;
if ((file_size = wtap_file_size(wth, err)) == -1)
- return FALSE;
+ return -1;
if (file_size > WTAP_MAX_PACKET_SIZE) {
/*
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("ber: File has %" G_GINT64_MODIFIER "d-byte packet, bigger than maximum of %u",
file_size, WTAP_MAX_PACKET_SIZE);
- return FALSE;
+ return -1;
}
packet_size = (int)file_size;
phdr->ts.secs = 0;
phdr->ts.nsecs = 0;
- return wtap_read_packet_bytes(fh, buf, packet_size, err, err_info);
+ if (!wtap_read_packet_bytes(fh, buf, packet_size, err, err_info))
+ return -1;
+ return REC_TYPE_PACKET;
}
-static gboolean ber_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
+static int ber_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
{
gint64 offset;
/* there is only ever one packet */
if (offset != 0)
- return FALSE;
+ return -1;
*data_offset = offset;
return ber_read_file(wth, wth->fh, &wth->phdr, wth->frame_buffer, err, err_info);
}
-static gboolean ber_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr _U_,
- Buffer *buf, int *err, gchar **err_info)
+static int ber_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr _U_,
+ Buffer *buf, int *err, gchar **err_info)
{
/* there is only one packet */
if(seek_off > 0) {
*err = 0;
- return FALSE;
+ return -1;
}
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
return ber_read_file(wth, wth->random_fh, phdr, buf, err, err_info);
}
static const gint64 KUnixTimeBase = G_GINT64_CONSTANT(0x00dcddb30f2f8000); /* offset from symbian - unix time */
-static gboolean btsnoop_read(wtap *wth, int *err, gchar **err_info,
+static int btsnoop_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean btsnoop_seek_read(wtap *wth, gint64 seek_off,
+static int btsnoop_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
-static gboolean btsnoop_read_record(wtap *wth, FILE_T fh,
+static int btsnoop_read_record(wtap *wth, FILE_T fh,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
int btsnoop_open(wtap *wth, int *err, gchar **err_info)
return 1;
}
-static gboolean btsnoop_read(wtap *wth, int *err, gchar **err_info,
+static int btsnoop_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
*data_offset = file_tell(wth->fh);
err, err_info);
}
-static gboolean btsnoop_seek_read(wtap *wth, gint64 seek_off,
+static int btsnoop_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
{
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
return btsnoop_read_record(wth, wth->random_fh, phdr, buf, err, err_info);
}
-static gboolean btsnoop_read_record(wtap *wth, FILE_T fh,
+static int btsnoop_read_record(wtap *wth, FILE_T fh,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
{
int bytes_read;
*err = file_error(fh, err_info);
if (*err == 0 && bytes_read != 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
packet_size = g_ntohl(hdr.incl_len);
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("btsnoop: File has %u-byte packet, bigger than maximum of %u",
packet_size, WTAP_MAX_PACKET_SIZE);
- return FALSE;
+ return -1;
}
ts = GINT64_FROM_BE(hdr.ts_usec);
/* Read packet data. */
- return wtap_read_packet_bytes(fh, buf, phdr->caplen, err, err_info);
+ if (!wtap_read_packet_bytes(fh, buf, phdr->caplen, err, err_info))
+ return -1;
+ return REC_TYPE_PACKET;
}
/* Returns 0 if we could write the specified encapsulation type,
}
-static gboolean
+static int
camins_read_packet(FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf,
int *err, gchar **err_info)
{
gint offset, bytes_read;
if (!find_next_pkt_dat_type_len(fh, &dat_trans_type, &dat_len, err, err_info))
- return FALSE;
+ return -1;
buffer_assure_space(buf, DVB_CI_PSEUDO_HDR_LEN+dat_len);
p = buffer_start_ptr(buf);
/* shouldn't happen, all invalid packets must be detected by
find_next_pkt_dat_type_len() */
*err = WTAP_ERR_INTERNAL;
- return FALSE;
+ return -1;
}
bytes_read = read_packet_data(fh, dat_trans_type,
/* 0<=bytes_read<=dat_len is very likely a corrupted packet
we let the dissector handle this */
if (bytes_read < 0)
- return FALSE;
+ return -1;
offset += bytes_read;
phdr->pkt_encap = WTAP_ENCAP_DVBCI;
phdr->caplen = offset;
phdr->len = offset;
- return TRUE;
+ return REC_TYPE_PACKET;
}
-static gboolean
+static int
camins_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
{
*data_offset = file_tell(wth->fh);
}
-static gboolean
+static int
camins_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *pkthdr, Buffer *buf, int *err, gchar **err_info)
{
if (-1 == file_seek(wth->random_fh, seek_off, SEEK_SET, err))
- return FALSE;
+ return -1;
return camins_read_packet(wth->random_fh, pkthdr, buf, err, err_info);
}
/************************************************************/
/* 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,
- struct wtap_pkthdr *phdr,
- Buffer *buf, int *err,
- gchar **err_info);
+static int catapult_dct2000_read(wtap *wth, int *err, gchar **err_info,
+ gint64 *data_offset);
+static int catapult_dct2000_seek_read(wtap *wth, gint64 seek_off,
+ 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,
/**************************************************/
/* Read packet function. */
/* Look for and read the next usable packet */
-/* - return TRUE and details if found */
+/* - return REC_TYPE_PACKET and details if found */
/**************************************************/
-static gboolean
+static int
catapult_dct2000_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
if (!read_new_line(wth->fh, &offset, &line_length, linebuff,
sizeof linebuff, err, err_info)) {
if (*err != 0)
- return FALSE; /* error */
+ return -1; /* error */
/* No more lines can be read, so quit. */
break;
}
g_hash_table_insert(file_externals->packet_prefix_table, pkey, line_prefix_info);
/* OK, we have packet details to return */
- return TRUE;
+ return REC_TYPE_PACKET;
}
}
/* No packet details to return... */
- return FALSE;
+ return -1;
}
/**************************************************/
/* Read & seek function. */
/**************************************************/
-static gboolean
+static int
catapult_dct2000_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf,
int *err, gchar **err_info)
/* Seek to beginning of packet */
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1) {
- return FALSE;
+ return -1;
}
/* Re-read whole line (this really should succeed) */
if (!read_new_line(wth->random_fh, &offset, &length, linebuff,
sizeof linebuff, err, err_info)) {
- return FALSE;
+ return -1;
}
/* Try to parse this line again (should succeed as re-reading...) */
is_comment, data_chars);
*err = errno = 0;
- return TRUE;
+ return REC_TYPE_PACKET;
}
/* If get here, must have failed */
*err_info = g_strdup_printf("catapult dct2000: seek_read failed to read/parse "
"line at position %" G_GINT64_MODIFIER "d",
seek_off);
- return FALSE;
+ return -1;
}
#define MEDIUM_WIFI 1
#define MEDIUM_TOKEN_RING 2
-static gboolean commview_read(wtap *wth, int *err, gchar **err_info,
- gint64 *data_offset);
-static gboolean commview_seek_read(wtap *wth, gint64 seek_off,
- struct wtap_pkthdr *phdr,
- Buffer *buf, int *err, gchar **err_info);
+static int commview_read(wtap *wth, int *err, gchar **err_info,
+ gint64 *data_offset);
+static int commview_seek_read(wtap *wth, gint64 seek_off,
+ struct wtap_pkthdr *phdr,
+ Buffer *buf, int *err, gchar **err_info);
static gboolean commview_read_header(commview_header_t *cv_hdr, FILE_T fh,
int *err, gchar **err_info);
static gboolean commview_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
struct tm tm;
if(!commview_read_header(&cv_hdr, fh, err, err_info))
- return FALSE;
+ return -1;
switch(cv_hdr.flags & FLAGS_MEDIUM) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("commview: unsupported encap: %u",
cv_hdr.flags & FLAGS_MEDIUM);
- return FALSE;
+ return -1;
}
tm.tm_year = cv_hdr.year - 1900;
phdr->ts.secs = mktime(&tm);
phdr->ts.nsecs = cv_hdr.usecs * 1000;
- return wtap_read_packet_bytes(fh, buf, phdr->caplen, err, err_info);
+ if (!wtap_read_packet_bytes(fh, buf, phdr->caplen, err, err_info))
+ return -1;
+ return REC_TYPE_PACKET;
}
-static gboolean
+static int
commview_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
{
*data_offset = file_tell(wth->fh);
err_info);
}
-static gboolean
+static int
commview_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr,
Buffer *buf, int *err, gchar **err_info)
{
if(file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
return commview_read_packet(wth->random_fh, phdr, buf, err, err_info);
}
static gint64 cosine_seek_next_packet(wtap *wth, int *err, gchar **err_info,
char *hdr);
static gboolean cosine_check_file_type(wtap *wth, int *err, gchar **err_info);
-static gboolean cosine_read(wtap *wth, int *err, gchar **err_info,
+static int cosine_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean cosine_seek_read(wtap *wth, gint64 seek_off,
+static int cosine_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
static int parse_cosine_rec_hdr(struct wtap_pkthdr *phdr, const char *line,
int *err, gchar **err_info);
-static gboolean parse_cosine_hex_dump(FILE_T fh, struct wtap_pkthdr *phdr,
+static int parse_cosine_hex_dump(FILE_T fh, struct wtap_pkthdr *phdr,
int pkt_len, Buffer* buf, int *err, gchar **err_info);
static int parse_single_hex_dump_line(char* rec, guint8 *buf,
guint byte_offset);
}
/* Find the next packet and parse it; called from wtap_read(). */
-static gboolean cosine_read(wtap *wth, int *err, gchar **err_info,
+static int cosine_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
gint64 offset;
/* Find the next packet */
offset = cosine_seek_next_packet(wth, err, err_info, line);
if (offset < 0)
- return FALSE;
+ return -1;
*data_offset = offset;
/* Parse the header */
pkt_len = parse_cosine_rec_hdr(&wth->phdr, line, err, err_info);
if (pkt_len == -1)
- return FALSE;
+ return -1;
/* Convert the ASCII hex dump to binary data */
return parse_cosine_hex_dump(wth->fh, &wth->phdr, pkt_len,
}
/* Used to read packets in random-access fashion */
-static gboolean
+static int
cosine_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr,
Buffer *buf, int *err, gchar **err_info)
{
return pkt_len;
}
-/* Converts ASCII hex dump to binary data. Returns TRUE on success,
- FALSE if any error is encountered. */
-static gboolean
+/* Converts ASCII hex dump to binary data. Returns REC_TYPE_PACKET on success,
+ -1 if any error is encountered. */
+static int
parse_cosine_hex_dump(FILE_T fh, struct wtap_pkthdr *phdr, int pkt_len,
Buffer* buf, int *err, gchar **err_info)
{
if (*err == 0) {
*err = WTAP_ERR_SHORT_READ;
}
- return FALSE;
+ return -1;
}
if (empty_line(line)) {
break;
if ((n = parse_single_hex_dump_line(line, pd, i*16)) == -1) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("cosine: hex dump line doesn't have 16 numbers");
- return FALSE;
+ return -1;
}
caplen += n;
}
phdr->caplen = caplen;
- return TRUE;
+ return REC_TYPE_PACKET;
}
gboolean byteswapped;
} csids_t;
-static gboolean csids_read(wtap *wth, int *err, gchar **err_info,
+static int csids_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean csids_seek_read(wtap *wth, gint64 seek_off,
+static int csids_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
static gboolean csids_read_packet(FILE_T fh, csids_t *csids,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
}
/* Find the next packet and parse it; called from wtap_read(). */
-static gboolean csids_read(wtap *wth, int *err, gchar **err_info,
+static int csids_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
csids_t *csids = (csids_t *)wth->priv;
*data_offset = file_tell(wth->fh);
- return csids_read_packet( wth->fh, csids, &wth->phdr, wth->frame_buffer,
- err, err_info );
+ if (!csids_read_packet( wth->fh, csids, &wth->phdr, wth->frame_buffer,
+ err, err_info ))
+ return -1;
+ return REC_TYPE_PACKET;
}
/* Used to read packets in random-access fashion */
-static gboolean
+static int
csids_seek_read(wtap *wth,
gint64 seek_off,
struct wtap_pkthdr *phdr,
csids_t *csids = (csids_t *)wth->priv;
if( file_seek( wth->random_fh, seek_off, SEEK_SET, err ) == -1 )
- return FALSE;
+ return -1;
if( !csids_read_packet( wth->random_fh, csids, phdr, buf, err, err_info ) ) {
if( *err == 0 )
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
static gboolean
#define COMMENT_LINE daintree_magic_text[0]
-static gboolean daintree_sna_read(wtap *wth, int *err, gchar **err_info,
+static int daintree_sna_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean daintree_sna_seek_read(wtap *wth, gint64 seek_off,
+static int daintree_sna_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
static gboolean daintree_sna_scan_header(struct wtap_pkthdr *phdr,
char *readLine, char *readData, int *err, gchar **err_info);
-static gboolean daintree_sna_process_hex_data(struct wtap_pkthdr *phdr,
+static int daintree_sna_process_hex_data(struct wtap_pkthdr *phdr,
Buffer *buf, char *readData, int *err, gchar **err_info);
/* Open a file and determine if it's a Daintree file */
/* Read the capture file sequentially
* Wireshark scans the file with sequential reads during preview and initial display. */
-static gboolean
+static int
daintree_sna_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
{
char readLine[DAINTREE_MAX_LINE_SIZE];
do {
if (file_gets(readLine, DAINTREE_MAX_LINE_SIZE, wth->fh) == NULL) {
*err = file_error(wth->fh, err_info);
- return FALSE; /* all done */
+ return -1; /* all done */
}
} while (readLine[0] == COMMENT_LINE);
/* parse one line of capture data */
if (!daintree_sna_scan_header(&wth->phdr, readLine, readData,
err, err_info))
- return FALSE;
+ return -1;
/* process packet data */
return daintree_sna_process_hex_data(&wth->phdr, wth->frame_buffer,
/* Read the capture file randomly
* Wireshark opens the capture file for random access when displaying user-selected packets */
-static gboolean
+static int
daintree_sna_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr,
Buffer *buf, int *err, gchar **err_info)
{
char readData[READDATA_BUF_SIZE];
if(file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
/* It appears only file header lines start with '#', but
* if we find any others, we toss them */
do {
if (file_gets(readLine, DAINTREE_MAX_LINE_SIZE, wth->random_fh) == NULL) {
*err = file_error(wth->random_fh, err_info);
- return FALSE; /* all done */
+ return -1; /* all done */
}
} while (readLine[0] == COMMENT_LINE);
/* parse one line of capture data */
if (!daintree_sna_scan_header(phdr, readLine, readData, err, err_info))
- return FALSE;
+ return -1;
/* process packet data */
return daintree_sna_process_hex_data(phdr, buf, readData, err,
/* Convert packet data from ASCII hex string to binary in place,
* sanity-check its length against what we assume is the packet length field,
* and copy it into a Buffer */
-static gboolean
+static int
daintree_sna_process_hex_data(struct wtap_pkthdr *phdr, Buffer *buf,
char *readData, int *err, gchar **err_info)
{
if (!isxdigit((guchar)*str)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("daintree_sna: non-hex digit in hex data");
- return FALSE;
+ return -1;
}
if(isdigit((guchar)*str)) {
*p = (*str - '0') << 4;
if (!isxdigit((guchar)*str)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("daintree_sna: non-hex digit in hex data");
- return FALSE;
+ return -1;
}
if(isdigit((guchar)*str)) {
*p += *str - '0';
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("daintree_sna: Only %u bytes of packet data",
bytes);
- return FALSE;
+ return -1;
}
bytes -= FCS_LENGTH;
if (bytes > phdr->len) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("daintree_sna: capture length (%u) > packet length (%u)",
bytes, phdr->len);
- return FALSE;
+ return -1;
}
phdr->caplen = bytes;
buffer_assure_space(buf, bytes);
memcpy(buffer_start_ptr(buf), readData, bytes);
- return TRUE;
+ return REC_TYPE_PACKET;
}
*/
#define DBS_ETHERWATCH_MAX_PACKET_LEN 16384
-static gboolean dbs_etherwatch_read(wtap *wth, int *err, gchar **err_info,
+static int dbs_etherwatch_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean dbs_etherwatch_seek_read(wtap *wth, gint64 seek_off,
+static int dbs_etherwatch_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
-static gboolean parse_dbs_etherwatch_packet(struct wtap_pkthdr *phdr, FILE_T fh,
+static int parse_dbs_etherwatch_packet(struct wtap_pkthdr *phdr, FILE_T fh,
Buffer* buf, int *err, gchar **err_info);
static guint parse_single_hex_dump_line(char* rec, guint8 *buf,
int byte_offset);
}
/* Find the next packet and parse it; called from wtap_read(). */
-static gboolean dbs_etherwatch_read(wtap *wth, int *err, gchar **err_info,
+static int dbs_etherwatch_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
gint64 offset;
/* Find the next packet */
offset = dbs_etherwatch_seek_next_packet(wth, err, err_info);
if (offset < 1)
- return FALSE;
+ return -1;
*data_offset = offset;
/* Parse the packet */
}
/* Used to read packets in random-access fashion */
-static gboolean
+static int
dbs_etherwatch_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
{
if (file_seek(wth->random_fh, seek_off - 1, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
return parse_dbs_etherwatch_packet(phdr, wth->random_fh, buf, err,
err_info);
*/
#define CTL_UNNUMB_MASK 0x03
#define CTL_UNNUMB_VALUE 0x03
-static gboolean
+static int
parse_dbs_etherwatch_packet(struct wtap_pkthdr *phdr, FILE_T fh, Buffer* buf,
int *err, gchar **err_info)
{
if (*err == 0) {
*err = WTAP_ERR_SHORT_READ;
}
- return FALSE;
+ return -1;
}
/* Get the destination address */
if(!p) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: destination address not found");
- return FALSE;
+ return -1;
}
p += strlen(DEST_MAC_PREFIX);
if(parse_hex_dump(p, &pd[eth_hdr_len], HEX_HDR_SPR, HEX_HDR_END)
!= MAC_ADDR_LENGTH) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: destination address not valid");
- return FALSE;
+ return -1;
}
eth_hdr_len += MAC_ADDR_LENGTH;
HEX_HDR_END) != MAC_ADDR_LENGTH) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: source address not valid");
- return FALSE;
+ return -1;
}
eth_hdr_len += MAC_ADDR_LENGTH;
if (*err == 0) {
*err = WTAP_ERR_SHORT_READ;
}
- return FALSE;
+ return -1;
}
/* Check the lines is as least as long as the length position */
if(strlen(line) < LENGTH_POS) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: line too short");
- return FALSE;
+ return -1;
}
num_items_scanned = sscanf(line + LENGTH_POS,
if (num_items_scanned != 8) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: header line not valid");
- return FALSE;
+ return -1;
}
/* Determine whether it is Ethernet II or IEEE 802 */
HEX_HDR_END) != PROTOCOL_LENGTH) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: Ethernet II protocol value not valid");
- return FALSE;
+ return -1;
}
eth_hdr_len += PROTOCOL_LENGTH;
} else {
HEX_HDR_END) != SAP_LENGTH) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: 802.2 DSAP+SSAP value not valid");
- return FALSE;
+ return -1;
}
eth_hdr_len += SAP_LENGTH;
/* Get the (first part of the) control field */
HEX_HDR_END) != CTL_UNNUMB_LENGTH) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: 802.2 control field first part not valid");
- return FALSE;
+ return -1;
}
/* Determine whether the control is numbered, and thus longer */
if((pd[eth_hdr_len] & CTL_UNNUMB_MASK) != CTL_UNNUMB_VALUE) {
HEX_HDR_SPR) != CTL_NUMB_LENGTH - CTL_UNNUMB_LENGTH) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: 802.2 control field second part value not valid");
- return FALSE;
+ return -1;
}
eth_hdr_len += CTL_NUMB_LENGTH;
} else {
HEX_PID_END) != PID_LENGTH) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: 802.2 PID value not valid");
- return FALSE;
+ return -1;
}
eth_hdr_len += PID_LENGTH;
}
if (*err == 0) {
*err = WTAP_ERR_SHORT_READ;
}
- return FALSE;
+ return -1;
}
if (!(line_count = parse_single_hex_dump_line(line,
&pd[eth_hdr_len + count], count))) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: packet data value not valid");
- return FALSE;
+ return -1;
}
count += line_count;
if (count > pkt_len) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: packet data value has too many bytes");
- return FALSE;
+ return -1;
}
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
/* Parse a hex dump line */
#define MAX_PACKET_LEN 23
-static gboolean dct3trace_read(wtap *wth, int *err, gchar **err_info,
+static int dct3trace_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean dct3trace_seek_read(wtap *wth, gint64 seek_off,
+static int dct3trace_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
/*
}
-static gboolean dct3trace_get_packet(FILE_T fh, struct wtap_pkthdr *phdr,
+static int dct3trace_get_packet(FILE_T fh, struct wtap_pkthdr *phdr,
Buffer *buf, int *err, gchar **err_info)
{
char line[1024];
{
/* Return on end of file </dump> */
*err = 0;
- return FALSE;
+ return -1;
}
else if( memcmp(dct3trace_magic_record_end, line, strlen(dct3trace_magic_record_end)) == 0 )
{
buffer_assure_space(buf, phdr->caplen);
memcpy( buffer_start_ptr(buf), databuf, phdr->caplen );
- return TRUE;
+ return REC_TYPE_PACKET;
}
else
{
/* If not got any data return error */
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("dct3trace: record without data");
- return FALSE;
+ return -1;
}
}
else if( memcmp(dct3trace_magic_record_start, line, strlen(dct3trace_magic_record_start)) == 0 )
{
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("dct3trace: record length %d too long", phdr->caplen);
- return FALSE;
+ return -1;
}
}
}
{
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("dct3trace: record length %d too long", phdr->caplen);
- return FALSE;
+ return -1;
}
len += data_len;
{
*err = WTAP_ERR_SHORT_READ;
}
- return FALSE;
+ return -1;
baddata:
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("dct3trace: record missing mandatory attributes");
- return FALSE;
+ return -1;
}
/* Find the next packet and parse it; called from wtap_read(). */
-static gboolean dct3trace_read(wtap *wth, int *err, gchar **err_info,
+static int dct3trace_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
*data_offset = file_tell(wth->fh);
/* Used to read packets in random-access fashion */
-static gboolean dct3trace_seek_read(wtap *wth, gint64 seek_off,
+static int dct3trace_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
{
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
{
- return FALSE;
+ return -1;
}
return dct3trace_get_packet(wth->random_fh, phdr, buf, err, err_info);
gchar **err_info,
guint32 *bytes_read,
guint32 *packet_size);
-static gboolean erf_read(wtap *wth, int *err, gchar **err_info,
- gint64 *data_offset);
-static gboolean erf_seek_read(wtap *wth, gint64 seek_off,
- struct wtap_pkthdr *phdr, Buffer *buf,
- int *err, gchar **err_info);
+static int erf_read(wtap *wth, int *err, gchar **err_info,
+ gint64 *data_offset);
+static int erf_seek_read(wtap *wth, gint64 seek_off,
+ struct wtap_pkthdr *phdr, Buffer *buf,
+ int *err, gchar **err_info);
static const struct {
int erf_encap_value;
}
/* Read the next packet */
-static gboolean erf_read(wtap *wth, int *err, gchar **err_info,
+static int erf_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
erf_header_t erf_header;
if (!erf_read_header(wth->fh,
&wth->phdr, &erf_header,
err, err_info, &bytes_read, &packet_size)) {
- return FALSE;
+ return -1;
}
if (!wtap_read_packet_bytes(wth->fh, wth->frame_buffer, packet_size,
err, err_info))
- return FALSE;
+ return -1;
} while ( erf_header.type == ERF_TYPE_PAD );
- return TRUE;
+ return REC_TYPE_PACKET;
}
-static gboolean erf_seek_read(wtap *wth, gint64 seek_off,
- struct wtap_pkthdr *phdr, Buffer *buf,
- int *err, gchar **err_info)
+static int erf_seek_read(wtap *wth, gint64 seek_off,
+ struct wtap_pkthdr *phdr, Buffer *buf,
+ int *err, gchar **err_info)
{
erf_header_t erf_header;
guint32 packet_size;
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
do {
if (!erf_read_header(wth->random_fh, phdr, &erf_header,
err, err_info, NULL, &packet_size))
- return FALSE;
+ return -1;
} while ( erf_header.type == ERF_TYPE_PAD );
- return wtap_read_packet_bytes(wth->random_fh, buf, packet_size,
- err, err_info);
+ if (!wtap_read_packet_bytes(wth->random_fh, buf, packet_size,
+ err, err_info))
+ return -1;
+ return REC_TYPE_PACKET;
}
static int erf_read_header(FILE_T fh,
*/
#define EYESDN_MAX_PACKET_LEN 16384
-static gboolean eyesdn_read(wtap *wth, int *err, gchar **err_info,
+static int eyesdn_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean eyesdn_seek_read(wtap *wth, gint64 seek_off,
+static int eyesdn_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
static int read_eyesdn_rec(FILE_T fh, struct wtap_pkthdr *phdr, Buffer* buf,
int *err, gchar **err_info);
}
/* Find the next packet and parse it; called from wtap_read(). */
-static gboolean eyesdn_read(wtap *wth, int *err, gchar **err_info,
+static int eyesdn_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
gint64 offset;
/* Find the next record */
offset = eyesdn_seek_next_packet(wth, err, err_info);
if (offset < 1)
- return FALSE;
+ return -1;
*data_offset = offset;
/* Parse the record */
}
/* Used to read packets in random-access fashion */
-static gboolean
+static int
eyesdn_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr,
Buffer *buf, int *err, gchar **err_info)
{
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
return read_eyesdn_rec(wth->random_fh, phdr, buf, err, err_info);
}
/* Parses a record. */
-static gboolean
+static int
read_eyesdn_rec(FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf, int *err,
gchar **err_info)
{
*err = file_error(fh, err_info);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
/* extract information from header */
*err_info = g_strdup_printf(
"eyesdn: ATM cell has a length != 53 (%u)",
pkt_len);
- return FALSE;
+ return -1;
}
cur_off = file_tell(fh);
*err = file_error(fh, err_info);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
if (file_seek(fh, cur_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
phdr->pkt_encap = WTAP_ENCAP_ATM_PDUS_UNTRUNCATED;
pseudo_header->atm.flags=ATM_RAW_CELL;
pseudo_header->atm.aal=AAL_UNKNOWN;
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("eyesdn: File has %u-byte packet, bigger than maximum of %u",
pkt_len, EYESDN_MAX_PACKET_LEN);
- return FALSE;
+ return -1;
}
phdr->presence_flags = WTAP_HAS_TS;
*err_info = g_strdup("eyesdn: No flag character seen in frame");
} else
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;;
}
#define DUMP_HDR_SIZE (sizeof(struct dump_hdr))
-static gboolean hcidump_process_packet(FILE_T fh, struct wtap_pkthdr *phdr,
+static int hcidump_process_packet(FILE_T fh, struct wtap_pkthdr *phdr,
Buffer *buf, int *err, gchar **err_info)
{
struct dump_hdr dh;
*err = file_error(fh, err_info);
if (*err == 0 && bytes_read != 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
packet_size = GUINT16_FROM_LE(dh.len);
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("hcidump: File has %u-byte packet, bigger than maximum of %u",
packet_size, WTAP_MAX_PACKET_SIZE);
- return FALSE;
+ return -1;
}
phdr->presence_flags = WTAP_HAS_TS;
phdr->pseudo_header.p2p.sent = (dh.in ? FALSE : TRUE);
- return wtap_read_packet_bytes(fh, buf, packet_size, err, err_info);
+ if (!wtap_read_packet_bytes(fh, buf, packet_size, err, err_info))
+ return -1;
+ return REC_TYPE_PACKET;
}
-static gboolean hcidump_read(wtap *wth, int *err, gchar **err_info,
+static int hcidump_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
*data_offset = file_tell(wth->fh);
err, err_info);
}
-static gboolean hcidump_seek_read(wtap *wth, gint64 seek_off,
+static int hcidump_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
{
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
return hcidump_process_packet(wth->random_fh, phdr, buf, err, err_info);
}
gboolean byte_swapped;
} i4btrace_t;
-static gboolean i4btrace_read(wtap *wth, int *err, gchar **err_info,
+static int i4btrace_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean i4btrace_seek_read(wtap *wth, gint64 seek_off,
+static int i4btrace_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
-static int i4b_read_rec(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
+static gboolean i4b_read_rec(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
Buffer *buf, int *err, gchar **err_info);
/*
}
/* Read the next packet */
-static gboolean i4btrace_read(wtap *wth, int *err, gchar **err_info,
+static int i4btrace_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
*data_offset = file_tell(wth->fh);
- return i4b_read_rec(wth, wth->fh, &wth->phdr, wth->frame_buffer,
- err, err_info);
+ if (!i4b_read_rec(wth, wth->fh, &wth->phdr, wth->frame_buffer,
+ err, err_info))
+ return -1;
+ return REC_TYPE_PACKET;
}
-static gboolean
+static int
i4btrace_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr,
Buffer *buf, int *err, gchar **err_info)
{
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
if (!i4b_read_rec(wth, wth->random_fh, phdr, buf, err, err_info)) {
/* Read error or EOF */
/* EOF means "short read" in random-access mode */
*err = WTAP_ERR_SHORT_READ;
}
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
-static int
+static gboolean
i4b_read_rec(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf,
int *err, gchar **err_info)
{
#define RECORDS_FOR_IPFIX_CHECK 20
-static gboolean
+static int
ipfix_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean
+static int
ipfix_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
static void
/* classic wtap: read packet */
-static gboolean
+static int
ipfix_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
{
*data_offset = file_tell(wth->fh);
if (!ipfix_read_message(wth->fh, &wth->phdr, wth->frame_buffer, err, err_info)) {
ipfix_debug2("ipfix_read: couldn't read message header with code: %d\n, and error '%s'",
*err, *err_info);
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
/* classic wtap: seek to file position and read packet */
-static gboolean
+static int
ipfix_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr,
Buffer *buf, int *err, gchar **err_info)
{
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1) {
ipfix_debug2("ipfix_seek_read: couldn't read message header with code: %d\n, and error '%s'",
*err, *err_info);
- return FALSE; /* Seek error */
+ return -1; /* Seek error */
}
ipfix_debug1("ipfix_seek_read: reading at offset %" G_GINT64_MODIFIER "u", seek_off);
ipfix_debug0("ipfix_seek_read: couldn't read message header");
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
}
/* Read the next packet */
-static gboolean iptrace_read_1_0(wtap *wth, int *err, gchar **err_info,
+static int iptrace_read_1_0(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
*data_offset = file_tell(wth->fh);
if (!iptrace_read_rec_1_0(wth->fh, &wth->phdr, wth->frame_buffer,
err, err_info)) {
/* Read error or EOF */
- return FALSE;
+ return -1;
}
/* If the per-file encapsulation isn't known, set it to this
wth->file_encap = WTAP_ENCAP_PER_PACKET;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
-static gboolean iptrace_seek_read_1_0(wtap *wth, gint64 seek_off,
+static int iptrace_seek_read_1_0(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
{
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
/* Read the packet */
if (!iptrace_read_rec_1_0(wth->random_fh, phdr, buf, err, err_info)) {
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
/***********************************************************
}
/* Read the next packet */
-static gboolean iptrace_read_2_0(wtap *wth, int *err, gchar **err_info,
+static int iptrace_read_2_0(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
*data_offset = file_tell(wth->fh);
if (!iptrace_read_rec_2_0(wth->fh, &wth->phdr, wth->frame_buffer,
err, err_info)) {
/* Read error or EOF */
- return FALSE;
+ return -1;
}
/* If the per-file encapsulation isn't known, set it to this
wth->file_encap = WTAP_ENCAP_PER_PACKET;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
-static gboolean iptrace_seek_read_2_0(wtap *wth, gint64 seek_off,
+static int iptrace_seek_read_2_0(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
{
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
/* Read the packet */
if (!iptrace_read_rec_2_0(wth->random_fh, phdr, buf, err, err_info)) {
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
static int
static gboolean iseries_check_file_type (wtap * wth, int *err, gchar **err_info,
int format);
static gint64 iseries_seek_next_packet (wtap * wth, int *err, gchar **err_info);
-static gboolean iseries_parse_packet (wtap * wth, FILE_T fh,
- struct wtap_pkthdr *phdr,
- Buffer * buf, int *err, gchar ** err_info);
+static int iseries_parse_packet (wtap * wth, FILE_T fh,
+ struct wtap_pkthdr *phdr,
+ Buffer * buf, int *err, gchar ** err_info);
static int iseries_UNICODE_to_ASCII (guint8 * buf, guint bytes);
static gboolean iseries_parse_hex_string (const char * ascii, guint8 * buf,
size_t len);
/*
* Find the next packet and parse it; called from wtap_read().
*/
-static gboolean
+static int
iseries_read (wtap * wth, int *err, gchar ** err_info, gint64 *data_offset)
{
gint64 offset;
/*
* Read packets in random-access fashion
*/
-static gboolean
+static int
iseries_seek_read (wtap * wth, gint64 seek_off, struct wtap_pkthdr *phdr,
Buffer * buf, int *err, gchar ** err_info)
{
/* seek to packet location */
if (file_seek (wth->random_fh, seek_off - 1, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
/*
* Parse the packet and extract the various fields
}
/* Parses a packet. */
-static gboolean
+static int
iseries_parse_packet (wtap * wth, FILE_T fh, struct wtap_pkthdr *phdr,
Buffer *buf, int *err, gchar **err_info)
{
if (file_gets (data, ISERIES_LINE_LENGTH, fh) == NULL)
{
*err = file_error (fh, err_info);
- return FALSE;
+ return -1;
}
/* Convert UNICODE data to ASCII */
if (iseries->format == ISERIES_FORMAT_UNICODE)
{
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup ("iseries: packet header isn't valid");
- return FALSE;
+ return -1;
}
phdr->presence_flags = WTAP_HAS_CAP_LEN;
if (ascii_offset == -1)
{
/* Bad line. */
- return FALSE;
+ return -1;
}
continue;
}
if (ascii_offset == -1)
{
/* Bad line. */
- return FALSE;
+ return -1;
}
continue;
}
if (ascii_offset == -1)
{
/* Bad line. */
- return FALSE;
+ return -1;
}
continue;
}
/* free buffer allocs and return */
*err = 0;
g_free (ascii_buf);
- return TRUE;
+ return REC_TYPE_PACKET;
errxit:
g_free (ascii_buf);
- return FALSE;
+ return -1;
}
/*
phdr->pseudo_header.k12.stuff = k12;
}
-static gboolean k12_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset) {
+static int k12_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset) {
k12_t *k12 = (k12_t *)wth->priv;
k12_src_desc_t* src_desc;
guint8* buffer;
if (len < 0) {
/* read error */
- return FALSE;
+ return -1;
} else if (len == 0) {
/* EOF */
*err = 0;
- return FALSE;
+ return -1;
} else if (len < K12_RECORD_SRC_ID + 4) {
/* Record not large enough to contain a src ID */
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("data record length %d too short", len);
- return FALSE;
+ return -1;
}
buffer = k12->seq_read_buff;
process_packet_data(&wth->phdr, wth->frame_buffer, buffer, len, k12);
- return TRUE;
+ return REC_TYPE_PACKET;
}
-static gboolean k12_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info) {
+static int k12_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info) {
k12_t *k12 = (k12_t *)wth->priv;
guint8* buffer;
gint len;
if ( file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1) {
K12_DBG(5,("k12_seek_read: SEEK ERROR"));
- return FALSE;
+ return -1;
}
len = get_record(k12, wth->random_fh, seek_off, TRUE, err, err_info);
if (len < 0) {
K12_DBG(5,("k12_seek_read: READ ERROR"));
- return FALSE;
+ return -1;
} else if (len < K12_RECORD_SRC_ID + 4) {
/* Record not large enough to contain a src ID */
K12_DBG(5,("k12_seek_read: SHORT READ"));
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
buffer = k12->rand_read_buff;
K12_DBG(5,("k12_seek_read: DONE OK"));
- return TRUE;
+ return REC_TYPE_PACKET;
}
ii=0;
}
-static gboolean
+static int
k12text_read(wtap *wth, int *err, char ** err_info, gint64 *data_offset)
{
k12text_t *k12text = (k12text_t *)wth->priv;
*/
if ( file_seek(wth->fh, k12text->next_frame_offset, SEEK_SET, err) == -1) {
- return FALSE;
+ return -1;
}
k12text_reset(wth->fh); /* init lexer buffer and vars set by lexer */
*err = WTAP_ERR_BAD_FILE;
*err_info = error_str;
}
- return FALSE;
+ return -1;
}
*data_offset = k12text->next_frame_offset; /* file position for beginning of this frame */
buffer_assure_space(wth->frame_buffer, wth->phdr.caplen);
memcpy(buffer_start_ptr(wth->frame_buffer), bb, wth->phdr.caplen);
- return TRUE;
+ return REC_TYPE_PACKET;
}
-static gboolean
+static int
k12text_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr, Buffer *buf, int *err, char **err_info)
{
if ( file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1) {
- return FALSE;
+ return -1;
}
k12text_reset(wth->random_fh); /* init lexer buffer and vars set by lexer */
} else {
*err_info = error_str;
}
- return FALSE;
+ return -1;
}
k12text_set_headers(phdr);
buffer_assure_space(buf, phdr->caplen);
memcpy(buffer_start_ptr(buf), bb, phdr->caplen);
- return TRUE;
+ return REC_TYPE_PACKET;
}
int
time_t start;
} lanalyzer_t;
-static gboolean lanalyzer_read(wtap *wth, int *err, gchar **err_info,
+static int lanalyzer_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean lanalyzer_seek_read(wtap *wth, gint64 seek_off,
+static int lanalyzer_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
static gboolean lanalyzer_dump_close(wtap_dumper *wdh, int *err);
}
/* Read the next packet */
-static gboolean lanalyzer_read(wtap *wth, int *err, gchar **err_info,
+static int lanalyzer_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
*data_offset = file_tell(wth->fh);
/* Read the record */
- return lanalyzer_read_trace_record(wth, wth->fh, &wth->phdr,
- wth->frame_buffer, err, err_info);
+ if (!lanalyzer_read_trace_record(wth, wth->fh, &wth->phdr,
+ wth->frame_buffer, err, err_info))
+ return -1;
+ return REC_TYPE_PACKET;
}
-static gboolean lanalyzer_seek_read(wtap *wth, gint64 seek_off,
+static int lanalyzer_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
{
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
/* Read the record */
if (!lanalyzer_read_trace_record(wth, wth->random_fh, phdr, buf,
err, err_info)) {
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
/*---------------------------------------------------
} libpcap_try_t;
static libpcap_try_t libpcap_try(wtap *wth, int *err);
-static gboolean libpcap_read(wtap *wth, int *err, gchar **err_info,
+static int libpcap_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean libpcap_seek_read(wtap *wth, gint64 seek_off,
+static int libpcap_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
static int libpcap_read_header(wtap *wth, FILE_T fh, int *err, gchar **err_info,
struct pcaprec_ss990915_hdr *hdr);
}
/* Read the next packet */
-static gboolean libpcap_read(wtap *wth, int *err, gchar **err_info,
+static int libpcap_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
*data_offset = file_tell(wth->fh);
- return libpcap_read_packet(wth, wth->fh, &wth->phdr,
- wth->frame_buffer, err, err_info);
+ if (!libpcap_read_packet(wth, wth->fh, &wth->phdr,
+ wth->frame_buffer, err, err_info))
+ return -1;
+ return REC_TYPE_PACKET;
}
static gboolean
Buffer *buf, int *err, gchar **err_info)
{
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
if (!libpcap_read_packet(wth, wth->random_fh, phdr, buf, err,
err_info)) {
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
static gboolean
return TRUE;
}
-static gboolean logcat_read(wtap *wth, int *err, gchar **err_info,
+static int logcat_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
*data_offset = file_tell(wth->fh);
- return logcat_read_packet((struct logcat_phdr *) wth->priv, wth->fh,
- &wth->phdr, wth->frame_buffer, err, err_info);
+ if (!logcat_read_packet((struct logcat_phdr *) wth->priv, wth->fh,
+ &wth->phdr, wth->frame_buffer, err, err_info))
+ return -1;
+ return REC_TYPE_PACKET;
}
-static gboolean logcat_seek_read(wtap *wth, gint64 seek_off,
+static int logcat_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf,
int *err, gchar **err_info)
{
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
if (!logcat_read_packet((struct logcat_phdr *) wth->priv, wth->random_fh,
phdr, buf, err, err_info)) {
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
int logcat_open(wtap *wth, int *err, gchar **err_info _U_)
*/
#define MAX_FILE_SIZE (16*1024*1024)
-static gboolean
+static int
mime_read_file(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
Buffer *buf, int *err, gchar **err_info)
{
int packet_size;
if ((file_size = wtap_file_size(wth, err)) == -1)
- return FALSE;
+ return -1;
if (file_size > MAX_FILE_SIZE) {
/*
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("mime_file: File has %" G_GINT64_MODIFIER "d-byte packet, bigger than maximum of %u",
file_size, MAX_FILE_SIZE);
- return FALSE;
+ return -1;
}
packet_size = (int)file_size;
phdr->ts.secs = 0;
phdr->ts.nsecs = 0;
- return wtap_read_packet_bytes(fh, buf, packet_size, err, err_info);
+ if (!wtap_read_packet_bytes(fh, buf, packet_size, err, err_info))
+ return -1;
+ return REC_TYPE_PACKET;
}
-static gboolean
+static int
mime_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
{
gint64 offset;
/* there is only ever one packet */
if (offset != 0)
- return FALSE;
+ return -1;
*data_offset = offset;
return mime_read_file(wth, wth->fh, &wth->phdr, wth->frame_buffer, err, err_info);
}
-static gboolean
+static int
mime_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
{
/* there is only one packet */
if (seek_off > 0) {
*err = 0;
- return FALSE;
+ return -1;
}
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
return mime_read_file(wth, wth->random_fh, phdr, buf, err, err_info);
}
return TRUE;
}
-static gboolean
+static int
mp2t_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
{
mp2t_filetype_t *mp2t;
if (!mp2t_read_packet(mp2t, wth->fh, *data_offset, &wth->phdr,
wth->frame_buffer, err, err_info)) {
- return FALSE;
+ return -1;
}
/* if there's a trailer, skip it and go to the start of the next packet */
if (mp2t->trailer_len!=0) {
if (-1 == file_seek(wth->fh, mp2t->trailer_len, SEEK_CUR, err)) {
- return FALSE;
+ return -1;
}
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
-static gboolean
+static int
mp2t_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr,
Buffer *buf, int *err, gchar **err_info)
{
mp2t_filetype_t *mp2t;
if (-1 == file_seek(wth->random_fh, seek_off, SEEK_SET, err)) {
- return FALSE;
+ return -1;
}
mp2t = (mp2t_filetype_t*) wth->priv;
err, err_info)) {
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
int
return TRUE;
}
-static gboolean
+static int
mpeg_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
{
*data_offset = file_tell(wth->fh);
- return mpeg_read_packet(wth, wth->fh, &wth->phdr, wth->frame_buffer,
- FALSE, err, err_info);
+ if (!mpeg_read_packet(wth, wth->fh, &wth->phdr, wth->frame_buffer,
+ FALSE, err, err_info))
+ return -1;
+ return REC_TYPE_PACKET;
}
-static gboolean
+static int
mpeg_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf,
int *err, gchar **err_info)
{
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
if (!mpeg_read_packet(wth, wth->random_fh, phdr, buf, TRUE, err,
err_info)) {
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
struct _mpeg_magic {
#define NETMON_NET_DNS_CACHE 0xFFFE
#define NETMON_NET_NETMON_FILTER 0xFFFF
-static gboolean netmon_read(wtap *wth, int *err, gchar **err_info,
+static int netmon_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean netmon_seek_read(wtap *wth, gint64 seek_off,
+static int netmon_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
static gboolean netmon_read_atm_pseudoheader(FILE_T fh,
union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info);
}
/* Read the next packet */
-static gboolean netmon_read(wtap *wth, int *err, gchar **err_info,
+static int netmon_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
netmon_t *netmon = (netmon_t *)wth->priv;
g_free(netmon->frame_table);
netmon->frame_table = NULL;
*err = 0; /* it's just an EOF, not an error */
- return FALSE;
+ return -1;
}
/* Seek to the beginning of the current record, if we're
rec_offset = netmon->frame_table[netmon->current_frame];
if (file_tell(wth->fh) != rec_offset) {
if (file_seek(wth->fh, rec_offset, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
}
netmon->current_frame++;
if (!netmon_process_rec_header(wth, wth->fh, &wth->phdr,
err, err_info))
- return FALSE;
+ return -1;
if (!wtap_read_packet_bytes(wth->fh, wth->frame_buffer,
wth->phdr.caplen, err, err_info))
- return FALSE; /* Read error */
+ return -1; /* Read error */
/*
* For version 2.1 and later, there's additional information
break;
case FAILURE:
- return FALSE;
+ return -1;
}
netmon_set_pseudo_header_info(wth->phdr.pkt_encap, &wth->phdr,
wth->frame_buffer);
- return TRUE;
+ return REC_TYPE_PACKET;
}
-static gboolean
+static int
netmon_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
{
netmon_t *netmon = (netmon_t *)wth->priv;
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
if (!netmon_process_rec_header(wth, wth->random_fh, phdr,
err, err_info))
- return FALSE;
+ return -1;
/*
* Read the packet data.
*/
if (!wtap_read_packet_bytes(wth->random_fh, buf, phdr->caplen, err,
err_info))
- return FALSE;
+ return -1;
/*
* For version 2.1 and later, there's additional information
*/
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("netmon: saw metadata in netmon_seek_read");
- return FALSE;
+ return -1;
case SUCCESS:
break;
case FAILURE:
- return FALSE;
+ return -1;
}
netmon_set_pseudo_header_info(phdr->pkt_encap, phdr, buf);
- return TRUE;
+ return REC_TYPE_PACKET;
}
static gboolean
} nstrace_t;
static guint32 nspm_signature_version(wtap*, gchar*, gint32);
-static gboolean nstrace_read_v10(wtap *wth, int *err, gchar **err_info,
- gint64 *data_offset);
-static gboolean nstrace_read_v20(wtap *wth, int *err, gchar **err_info,
- gint64 *data_offset);
-static gboolean nstrace_read_v30(wtap *wth, int *err, gchar **err_info,
- gint64 *data_offset);
-static gboolean nstrace_seek_read_v10(wtap *wth, gint64 seek_off,
- struct wtap_pkthdr *phdr,
- Buffer *buf,
- int *err, gchar **err_info);
-static gboolean nstrace_seek_read_v20(wtap *wth, gint64 seek_off,
- struct wtap_pkthdr *phdr,
- Buffer *buf,
- int *err, gchar **err_info);
-static gboolean nstrace_seek_read_v30(wtap *wth, gint64 seek_off,
- struct wtap_pkthdr *phdr,
- Buffer *buf,
- int *err, gchar **err_info);
+static int nstrace_read_v10(wtap *wth, int *err, gchar **err_info,
+ gint64 *data_offset);
+static int nstrace_read_v20(wtap *wth, int *err, gchar **err_info,
+ gint64 *data_offset);
+static int nstrace_read_v30(wtap *wth, int *err, gchar **err_info,
+ gint64 *data_offset);
+static int nstrace_seek_read_v10(wtap *wth, gint64 seek_off,
+ struct wtap_pkthdr *phdr,
+ Buffer *buf,
+ int *err, gchar **err_info);
+static int nstrace_seek_read_v20(wtap *wth, gint64 seek_off,
+ struct wtap_pkthdr *phdr,
+ Buffer *buf,
+ int *err, gchar **err_info);
+static int nstrace_seek_read_v30(wtap *wth, gint64 seek_off,
+ struct wtap_pkthdr *phdr,
+ Buffer *buf,
+ int *err, gchar **err_info);
static void nstrace_close(wtap *wth);
static gboolean nstrace_set_start_time_v10(wtap *wth);
/*
** Netscaler trace format read routines.
*/
-static gboolean nstrace_read_v10(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
+static int nstrace_read_v10(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
{
nstrace_t *nstrace = (nstrace_t *)wth->priv;
guint64 nsg_creltime = nstrace->nsg_creltime;
nstrace->nstrace_buf_offset = nstrace_buf_offset + (phdr)->len;\
nstrace->nstrace_buflen = nstrace_buflen;\
nstrace->nsg_creltime = nsg_creltime;\
- return TRUE;
+ return REC_TYPE_PACKET;
#define GENERATE_CASE_PART(phdr,type,acttype) \
case NSPR_PDPKTRACEPARTTX_V##type:\
nstrace->nstrace_buf_offset = nstrace_buf_offset + (phdr)->caplen;\
nstrace->nsg_creltime = nsg_creltime;\
nstrace->nstrace_buflen = nstrace_buflen;\
- return TRUE;\
+ return REC_TYPE_PACKET;\
switch (pletoh16(&(( nspr_header_v10_t*)&nstrace_buf[nstrace_buf_offset])->ph_RecordType))
{
nstrace_buflen = GET_READ_PAGE_SIZE((nstrace->file_size - nstrace->xxx_offset));
}while((nstrace_buflen > 0) && (bytes_read = file_read(nstrace_buf, nstrace_buflen, wth->fh)) && (bytes_read == nstrace_buflen));
- return FALSE;
+ return -1;
}
#define TIMEDEFV20(fp,type) \
nstrace->nstrace_buf_offset = nstrace_buf_offset + nspr_getv20recordsize((nspr_hd_v20_t *)fp);\
nstrace->nstrace_buflen = nstrace_buflen;\
nstrace->nsg_creltime = nsg_creltime;\
- return TRUE;\
+ return REC_TYPE_PACKET;\
}while(0)
-static gboolean nstrace_read_v20(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
+static int nstrace_read_v20(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
{
nstrace_t *nstrace = (nstrace_t *)wth->priv;
guint64 nsg_creltime = nstrace->nsg_creltime;
nstrace_buflen = GET_READ_PAGE_SIZE((nstrace->file_size - nstrace->xxx_offset));
}while((nstrace_buflen > 0) && (bytes_read = file_read(nstrace_buf, nstrace_buflen, wth->fh)) && (bytes_read == nstrace_buflen));
- return FALSE;
+ return -1;
}
#undef PACKET_DESCRIBE
nstrace->xxx_offset += nstrace_buflen;\
bytes_read = file_read(nstrace_buf, NSPR_PAGESIZE_TRACE, wth->fh);\
if (bytes_read != NSPR_PAGESIZE_TRACE) {\
- return FALSE;\
+ return -1;\
} else {\
nstrace_buf_offset = 0;\
}\
nstrace->nstrace_buf_offset = nstrace_buf_offset;\
nstrace->nstrace_buflen = nstrace_buflen = ((gint32)NSPR_PAGESIZE_TRACE);\
nstrace->nsg_creltime = nsg_creltime;\
- return TRUE;\
+ return REC_TYPE_PACKET;\
} while(0)
-static gboolean nstrace_read_v30(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
+static int nstrace_read_v30(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
{
nstrace_t *nstrace = (nstrace_t *)wth->priv;
guint64 nsg_creltime = nstrace->nsg_creltime;
nstrace_buflen = NSPR_PAGESIZE_TRACE;
} while((nstrace_buflen > 0) && (bytes_read = file_read(nstrace_buf, nstrace_buflen, wth->fh)) && (bytes_read == nstrace_buflen));
- return FALSE;
+ return -1;
}
#undef PACKET_DESCRIBE
-static gboolean nstrace_seek_read_v10(wtap *wth, gint64 seek_off,
+static int nstrace_seek_read_v10(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
{
nspr_hd_v10_t hdr;
*err = 0;
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
/*
** Read the record header.
*err = file_error(wth->random_fh, err_info);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
/*
*err = file_error(wth->random_fh, err_info);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
}
#undef GENERATE_CASE_FULL
#undef GENERATE_CASE_PART
- return TRUE;
+ return REC_TYPE_PACKET;
}
#define PACKET_DESCRIBE(phdr,FPTIMEDEF,SIZEDEF,ver,enumprefix,type,structname,TYPE)\
SIZEDEF##ver((phdr),fp,ver);\
TRACE_V##ver##_REC_LEN_OFF((phdr),enumprefix,type,structname);\
(phdr)->pseudo_header.nstr.rec_type = NSPR_HEADER_VERSION##TYPE;\
- return TRUE;\
+ return REC_TYPE_PACKET;\
}while(0)
-static gboolean nstrace_seek_read_v20(wtap *wth, gint64 seek_off,
+static int nstrace_seek_read_v20(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
{
nspr_hd_v20_t hdr;
*err = 0;
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
/*
** Read the first 2 bytes of the record header.
*err = file_error(wth->random_fh, err_info);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
hdrlen = 2;
*err = file_error(wth->random_fh, err_info);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
hdrlen = 3;
}
*err = file_error(wth->random_fh, err_info);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
}
#undef GENERATE_CASE_PART
#undef GENERATE_CASE_PART_V25
- return TRUE;
+ return REC_TYPE_PACKET;
}
-static gboolean nstrace_seek_read_v30(wtap *wth, gint64 seek_off,
+static int nstrace_seek_read_v30(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
{
nspr_hd_v20_t hdr;
*err = 0;
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
/*
** Read the first 2 bytes of the record header.
*/
*err = file_error(wth->random_fh, err_info);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
hdrlen = 2;
*err = file_error(wth->random_fh, err_info);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
hdrlen = 3;
}
*err = file_error(wth->random_fh, err_info);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
}
GENERATE_CASE_V30(phdr,30, 300);
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
char *hdr);
static gboolean netscreen_check_file_type(wtap *wth, int *err,
gchar **err_info);
-static gboolean netscreen_read(wtap *wth, int *err, gchar **err_info,
+static int netscreen_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean netscreen_seek_read(wtap *wth, gint64 seek_off,
+static int netscreen_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf,
int *err, gchar **err_info);
static int parse_netscreen_rec_hdr(struct wtap_pkthdr *phdr, const char *line,
}
/* Find the next packet and parse it; called from wtap_read(). */
-static gboolean netscreen_read(wtap *wth, int *err, gchar **err_info,
+static int netscreen_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
gint64 offset;
/* Find the next packet */
offset = netscreen_seek_next_packet(wth, err, err_info, line);
if (offset < 0)
- return FALSE;
+ return -1;
/* Parse the header */
pkt_len = parse_netscreen_rec_hdr(&wth->phdr, line, cap_int, &cap_dir,
cap_dst, err, err_info);
if (pkt_len == -1)
- return FALSE;
+ return -1;
/* Convert the ASCII hex dump to binary data, and fill in some
struct wtap_pkthdr fields */
if (!parse_netscreen_hex_dump(wth->fh, pkt_len, cap_int,
cap_dst, &wth->phdr, wth->frame_buffer, err, err_info))
- return FALSE;
+ return -1;
/*
* If the per-file encapsulation isn't known, set it to this
}
*data_offset = offset;
- return TRUE;
+ return REC_TYPE_PACKET;
}
/* Used to read packets in random-access fashion */
-static gboolean
+static int
netscreen_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf,
int *err, gchar **err_info)
char cap_dst[13];
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1) {
- return FALSE;
+ return -1;
}
if (file_gets(line, NETSCREEN_LINE_LENGTH, wth->random_fh) == NULL) {
if (*err == 0) {
*err = WTAP_ERR_SHORT_READ;
}
- return FALSE;
+ return -1;
}
pkt_len = parse_netscreen_rec_hdr(phdr, line, cap_int, &cap_dir,
cap_dst, err, err_info);
if (pkt_len == -1)
- return FALSE;
+ return -1;
if (!parse_netscreen_hex_dump(wth->random_fh, pkt_len, cap_int,
cap_dst, phdr, buf, err, err_info))
- return FALSE;
- return TRUE;
+ return -1;
+ return REC_TYPE_PACKET;
}
/* Parses a packet record header. There are a few possible formats:
gboolean is_hpux_11;
} nettl_t;
-static gboolean nettl_read(wtap *wth, int *err, gchar **err_info,
+static int nettl_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean nettl_seek_read(wtap *wth, gint64 seek_off,
+static int nettl_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf,
int *err, gchar **err_info);
static gboolean nettl_read_rec(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
}
/* Read the next packet */
-static gboolean nettl_read(wtap *wth, int *err, gchar **err_info,
+static int nettl_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
/* Read record header. */
if (!nettl_read_rec(wth, wth->fh, &wth->phdr, wth->frame_buffer,
err, err_info)) {
/* Read error or EOF */
- return FALSE;
+ return -1;
}
/*
wth->file_encap = WTAP_ENCAP_PER_PACKET;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
-static gboolean
+static int
nettl_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr,
Buffer *buf, int *err, gchar **err_info)
{
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
/* Read record header. */
if (!nettl_read_rec(wth, wth->random_fh, phdr, buf, err, err_info)) {
/* EOF means "short read" in random-access mode */
*err = WTAP_ERR_SHORT_READ;
}
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
static gboolean
}
}
-static gboolean observer_read(wtap *wth, int *err, gchar **err_info,
+static int observer_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean observer_seek_read(wtap *wth, gint64 seek_off,
+static int observer_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
static int read_packet_header(FILE_T fh, union wtap_pseudo_header *pseudo_header,
packet_entry_header *packet_header, int *err, gchar **err_info);
}
/* Reads the next packet. */
-static gboolean observer_read(wtap *wth, int *err, gchar **err_info,
+static int observer_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
int header_bytes_consumed;
header_bytes_consumed = read_packet_header(wth->fh, &wth->phdr.pseudo_header, &packet_header, err,
err_info);
if (header_bytes_consumed <= 0)
- return FALSE; /* EOF or error */
+ return -1; /* EOF or error */
if (packet_header.packet_type == PACKET_TYPE_DATA_PACKET)
break;
/* skip to next packet */
if (!skip_to_next_packet(wth, packet_header.offset_to_next_packet,
header_bytes_consumed, err, err_info)) {
- return FALSE; /* EOF or error */
+ return -1; /* EOF or error */
}
}
if (!process_packet_header(wth, &packet_header, &wth->phdr, err, err_info))
- return FALSE;
+ return -1;
/* read the frame data */
data_bytes_consumed = read_packet_data(wth->fh, packet_header.offset_to_frame,
header_bytes_consumed, wth->frame_buffer,
wth->phdr.caplen, err, err_info);
if (data_bytes_consumed < 0) {
- return FALSE;
+ return -1;
}
/* skip over any extra bytes following the frame data */
if (!skip_to_next_packet(wth, packet_header.offset_to_next_packet,
header_bytes_consumed + data_bytes_consumed, err, err_info)) {
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
/* Reads a packet at an offset. */
-static gboolean observer_seek_read(wtap *wth, gint64 seek_off,
+static int observer_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
{
union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header;
int data_bytes_consumed;
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
/* process the packet header, including TLVs */
offset = read_packet_header(wth->random_fh, pseudo_header, &packet_header, err,
err_info);
if (offset <= 0)
- return FALSE; /* EOF or error */
+ return -1; /* EOF or error */
if (!process_packet_header(wth, &packet_header, phdr, err, err_info))
- return FALSE;
+ return -1;
/* read the frame data */
data_bytes_consumed = read_packet_data(wth->random_fh, packet_header.offset_to_frame,
offset, buf, phdr->caplen, err, err_info);
if (data_bytes_consumed < 0) {
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
static int
guint isdn_type; /* 1 = E1 PRI, 2 = T1 PRI, 3 = BRI */
} netxray_t;
-static gboolean netxray_read(wtap *wth, int *err, gchar **err_info,
+static int netxray_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean netxray_seek_read(wtap *wth, gint64 seek_off,
+static int netxray_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
static int netxray_process_rec_header(wtap *wth, FILE_T fh,
struct wtap_pkthdr *phdr, int *err, gchar **err_info);
}
/* Read the next packet */
-static gboolean
+static int
netxray_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
if (*data_offset == netxray->end_offset) {
/* Yes. */
*err = 0; /* it's just an EOF, not an error */
- return FALSE;
+ return -1;
}
/* Read and process record header. */
/*
* Error of some sort; give up.
*/
- return FALSE;
+ return -1;
}
/* We're at EOF. Wrap?
*/
if (netxray->start_offset < netxray->end_offset) {
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
if (!netxray->wrapped) {
netxray->wrapped = TRUE;
if (file_seek(wth->fh, CAPTUREFILE_HEADER_SIZE,
SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
goto reread;
}
/* We've already wrapped - don't wrap again. */
- return FALSE;
+ return -1;
}
/*
*/
if (!wtap_read_packet_bytes(wth->fh, wth->frame_buffer,
wth->phdr.caplen, err, err_info))
- return FALSE;
+ return -1;
/*
* If there's extra stuff at the end of the record, skip it.
*/
if (file_seek(wth->fh, padding, SEEK_CUR, err) == -1)
- return FALSE;
+ return -1;
/*
* If it's an ATM packet, and we don't have enough information
* attempt to guess them from the packet data.
*/
netxray_guess_atm_type(wth, &wth->phdr, wth->frame_buffer);
- return TRUE;
+ return REC_TYPE_PACKET;
}
-static gboolean
+static int
netxray_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf,
int *err, gchar **err_info)
{
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
if (netxray_process_rec_header(wth, wth->random_fh, phdr, err,
err_info) == -1) {
*/
*err = WTAP_ERR_SHORT_READ;
}
- return FALSE;
+ return -1;
}
/*
*/
if (!wtap_read_packet_bytes(wth->random_fh, buf, phdr->caplen, err,
err_info))
- return FALSE;
+ return -1;
/*
* If it's an ATM packet, and we don't have enough information
* attempt to guess them from the packet data.
*/
netxray_guess_atm_type(wth, phdr, buf);
- return TRUE;
+ return REC_TYPE_PACKET;
}
static int
guint16 length, int *err, gchar **err_info);
static int process_rec_header2_v145(wtap *wth, unsigned char *buffer,
guint16 length, gint16 maj_vers, int *err, gchar **err_info);
-static gboolean ngsniffer_read(wtap *wth, int *err, gchar **err_info,
+static int ngsniffer_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean ngsniffer_seek_read(wtap *wth, gint64 seek_off,
+static int ngsniffer_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
static int ngsniffer_process_record(wtap *wth, gboolean is_random,
guint *padding, struct wtap_pkthdr *phdr, Buffer *buf, int *err,
}
/* Read the next packet */
-static gboolean
+static int
ngsniffer_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
{
ngsniffer_t *ngsniffer;
&wth->phdr, wth->frame_buffer, err, err_info);
if (ret < 0) {
/* Read error or short read */
- return FALSE;
+ return -1;
}
/*
if (padding != 0) {
if (!ng_file_skip_seq(wth, padding, err,
err_info))
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
case REC_EOF:
/*
* End of file. Return an EOF indication.
*/
*err = 0; /* EOF, not error */
- return FALSE;
+ return -1;
default:
/*
if (padding != 0) {
if (!ng_file_skip_seq(wth, padding, err,
err_info))
- return FALSE;
+ return -1;
}
break;
}
}
}
-static gboolean
+static int
ngsniffer_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
{
int ret;
if (!ng_file_seek_rand(wth, seek_off, err, err_info))
- return FALSE;
+ return -1;
ret = ngsniffer_process_record(wth, TRUE, NULL, phdr, buf, err, err_info);
if (ret < 0) {
/* Read error or short read */
- return FALSE;
+ return -1;
}
/*
* "Can't happen".
*/
g_assert_not_reached();
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
/*
guint64 ts;
} packetlogger_header_t;
-static gboolean packetlogger_read(wtap *wth, int *err, gchar **err_info,
- gint64 *data_offset);
-static gboolean packetlogger_seek_read(wtap *wth, gint64 seek_off,
- struct wtap_pkthdr *phdr,
- Buffer *buf, int *err, gchar **err_info);
+static int packetlogger_read(wtap *wth, int *err, gchar **err_info,
+ gint64 *data_offset);
+static int packetlogger_seek_read(wtap *wth, gint64 seek_off,
+ struct wtap_pkthdr *phdr,
+ Buffer *buf, int *err, gchar **err_info);
static gboolean packetlogger_read_header(packetlogger_header_t *pl_hdr,
FILE_T fh, int *err, gchar **err_info);
static gboolean packetlogger_read_packet(FILE_T fh, struct wtap_pkthdr *phdr,
return 1; /* Our kind of file */
}
-static gboolean
+static int
packetlogger_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
{
*data_offset = file_tell(wth->fh);
- return packetlogger_read_packet(wth->fh, &wth->phdr,
- wth->frame_buffer, err, err_info);
+ if (!packetlogger_read_packet(wth->fh, &wth->phdr,
+ wth->frame_buffer, err, err_info))
+ return -1;
+ return REC_TYPE_PACKET;
}
-static gboolean
+static int
packetlogger_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr,
Buffer *buf, int *err, gchar **err_info)
{
if(file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
if(!packetlogger_read_packet(wth->random_fh, phdr, buf, err, err_info)) {
if(*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
static gboolean
/* classic wtap: read packet */
-static gboolean
+static int
pcapng_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
{
pcapng_t *pcapng = (pcapng_t *)wth->priv;
if (bytes_read <= 0) {
pcapng_debug1("pcapng_read: data_offset is finally %" G_GINT64_MODIFIER "d", *data_offset);
pcapng_debug0("pcapng_read: couldn't read packet block");
- return FALSE;
+ return -1;
}
switch (wblock.type) {
wth->phdr.pkt_encap = WTAP_ENCAP_UNKNOWN;
*err = WTAP_ERR_UNSUPPORTED;
*err_info = g_strdup_printf("pcapng: multi-section files not currently supported");
- return FALSE;
+ return -1;
case(BLOCK_TYPE_PB):
case(BLOCK_TYPE_SPB):
/*pcapng_debug2("Read length: %u Packet length: %u", bytes_read, wth->phdr.caplen);*/
pcapng_debug1("pcapng_read: data_offset is finally %" G_GINT64_MODIFIER "d", *data_offset + bytes_read);
- return TRUE;
+ return REC_TYPE_PACKET;
}
/* classic wtap: seek to file position and read packet */
-static gboolean
+static int
pcapng_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf,
int *err, gchar **err_info)
/* seek to the right file position */
bytes_read64 = file_seek(wth->random_fh, seek_off, SEEK_SET, err);
if (bytes_read64 <= 0) {
- return FALSE; /* Seek error */
+ return -1; /* Seek error */
}
pcapng_debug1("pcapng_seek_read: reading at offset %" G_GINT64_MODIFIER "u", seek_off);
if (bytes_read <= 0) {
pcapng_debug3("pcapng_seek_read: couldn't read packet block (err=%d, errno=%d, bytes_read=%d).",
*err, errno, bytes_read);
- return FALSE;
+ return -1;
}
/* block must be a "Packet Block", an "Enhanced Packet Block",
return FALSE;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
return 1;
}
-static gboolean peekclassic_read_v7(wtap *wth, int *err, gchar **err_info,
+static int peekclassic_read_v7(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
int sliceLength;
sliceLength = peekclassic_read_packet_v7(wth, wth->fh, &wth->phdr,
wth->frame_buffer, err, err_info);
if (sliceLength < 0)
- return FALSE;
+ return -1;
/* Skip extra ignored data at the end of the packet. */
if ((guint32)sliceLength > wth->phdr.caplen) {
if (!file_skip(wth->fh, sliceLength - wth->phdr.caplen, err))
- return FALSE;
+ return -1;
}
/* Records are padded to an even length, so if the slice length
is odd, read the padding byte. */
if (sliceLength & 0x01) {
if (!file_skip(wth->fh, 1, err))
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
-static gboolean peekclassic_seek_read_v7(wtap *wth, gint64 seek_off,
+static int peekclassic_seek_read_v7(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
{
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
/* Read the packet. */
if (peekclassic_read_packet_v7(wth, wth->random_fh, phdr, buf,
err, err_info) == -1) {
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
static int peekclassic_read_packet_v7(wtap *wth, FILE_T fh,
return sliceLength;
}
-static gboolean peekclassic_read_v56(wtap *wth, int *err, gchar **err_info,
+static int peekclassic_read_v56(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
*data_offset = file_tell(wth->fh);
/* read the packet */
if (!peekclassic_read_packet_v56(wth, wth->fh, &wth->phdr,
wth->frame_buffer, err, err_info))
- return FALSE;
+ return -1;
/*
* XXX - is the captured packet data padded to a multiple
* of 2 bytes?
*/
- return TRUE;
+ return REC_TYPE_PACKET;
}
static gboolean peekclassic_seek_read_v56(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
{
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
/* read the packet */
if (!peekclassic_read_packet_v56(wth, wth->random_fh, phdr, buf,
err, err_info)) {
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
static gboolean peekclassic_read_packet_v56(wtap *wth, FILE_T fh,
gboolean has_fcs;
} peektagged_t;
-static gboolean peektagged_read(wtap *wth, int *err, gchar **err_info,
+static int peektagged_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean peektagged_seek_read(wtap *wth, gint64 seek_off,
+static int peektagged_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
static int wtap_file_read_pattern (wtap *wth, const char *pattern, int *err,
return skip_len;
}
-static gboolean peektagged_read(wtap *wth, int *err, gchar **err_info,
+static int peektagged_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
int skip_len;
skip_len = peektagged_read_packet(wth, wth->fh, &wth->phdr,
wth->frame_buffer, err, err_info);
if (skip_len == -1)
- return FALSE;
+ return -1;
if (skip_len != 0) {
/* Skip extra junk at the end of the packet data. */
if (!file_skip(wth->fh, skip_len, err))
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
-static gboolean
+static int
peektagged_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
{
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
/* Read the packet. */
if (peektagged_read_packet(wth, wth->random_fh, phdr, buf, err, err_info) == -1) {
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
DIRECTION_RECV
} direction_enum;
-static gboolean pppdump_read(wtap *wth, int *err, gchar **err_info,
+static int pppdump_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean pppdump_seek_read(wtap *wth, gint64 seek_off,
+static int pppdump_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
/*
}
/* Find the next packet and parse it; called from wtap_read(). */
-static gboolean
+static int
pppdump_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
{
int num_bytes;
pid = g_new(pkt_id, 1);
if (!pid) {
*err = errno; /* assume a malloc failed and set "errno" */
- return FALSE;
+ return -1;
}
pid->offset = 0;
} else
pid, 0)) {
if (pid != NULL)
g_free(pid);
- return FALSE;
+ return -1;
}
if (pid != NULL)
wth->phdr.ts.nsecs = state->tenths * 100000000;
pppdump_set_phdr(&wth->phdr, num_bytes, direction);
- return TRUE;
+ return REC_TYPE_PACKET;
}
/* Returns number of bytes copied for record, -1 if failure.
/* Used to read packets in random-access fashion */
-static gboolean
+static int
pppdump_seek_read(wtap *wth,
gint64 seek_off,
struct wtap_pkthdr *phdr,
if (!pid) {
*err = WTAP_ERR_BAD_FILE; /* XXX - better error? */
*err_info = g_strdup("pppdump: PID not found for record");
- return FALSE;
+ return -1;
}
if (file_seek(wth->random_fh, pid->offset, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
init_state(state->seek_state);
state->seek_state->offset = pid->offset;
do {
if (!collate(state->seek_state, wth->random_fh, err, err_info,
pd, &num_bytes, &direction, NULL, num_bytes_to_skip))
- return FALSE;
+ return -1;
num_bytes_to_skip = 0;
} while (direction != pid->dir);
pppdump_set_phdr(phdr, num_bytes, pid->dir);
- return TRUE;
+ return REC_TYPE_PACKET;
}
static void
char xxw[9]; /* unknown */
};
-static gboolean radcom_read(wtap *wth, int *err, gchar **err_info,
+static int radcom_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean radcom_seek_read(wtap *wth, gint64 seek_off,
+static int radcom_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
static gboolean radcom_read_rec(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
Buffer *buf, int *err, gchar **err_info);
}
/* Read the next packet */
-static gboolean radcom_read(wtap *wth, int *err, gchar **err_info,
- gint64 *data_offset)
+static int radcom_read(wtap *wth, int *err, gchar **err_info,
+ gint64 *data_offset)
{
int bytes_read;
char fcs[2];
if (!radcom_read_rec(wth, wth->fh, &wth->phdr, wth->frame_buffer,
err, err_info)) {
/* Read error or EOF */
- return FALSE;
+ return -1;
}
if (wth->file_encap == WTAP_ENCAP_LAPB) {
*err = file_error(wth->fh, err_info);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
-static gboolean
+static int
radcom_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf,
int *err, gchar **err_info)
{
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
/* Read record. */
if (!radcom_read_rec(wth, wth->random_fh, phdr, buf, err,
/* EOF means "short read" in random-access mode */
*err = WTAP_ERR_SHORT_READ;
}
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
static gboolean
#define RX_STATUS_FIFO_ERROR 0x0080 /* receive FIFO error */
#define RX_STATUS_TRIGGERED 0x0001 /* frame did trigger */
-static gboolean snoop_read(wtap *wth, int *err, gchar **err_info,
+static int snoop_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean snoop_seek_read(wtap *wth, gint64 seek_off,
+static int snoop_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
static int snoop_read_packet(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
Buffer *buf, int *err, gchar **err_info);
/* Read the next packet */
-static gboolean snoop_read(wtap *wth, int *err, gchar **err_info,
+static int snoop_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
int padbytes;
padbytes = snoop_read_packet(wth, wth->fh, &wth->phdr,
wth->frame_buffer, err, err_info);
if (padbytes == -1)
- return FALSE;
+ return -1;
/*
* Skip over the padding (don't "fseek()", as the standard
*err = file_error(wth->fh, err_info);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
padbytes -= bytes_read;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
-static gboolean
+static int
snoop_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
{
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
if (snoop_read_packet(wth, wth->random_fh, phdr, buf, err, err_info) == -1) {
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
static int
return TRUE;
}
-static gboolean stanag4607_read_file(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
- Buffer *buf, int *err, gchar **err_info)
+static int stanag4607_read_file(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
+ Buffer *buf, int *err, gchar **err_info)
{
stanag4607_t *stanag4607 = (stanag4607_t *)wth->priv;
guint32 millisecs, secs, nsecs;
if (!is_valid_id(pntoh16(&stanag_pkt_hdr[0]))) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("Bad version number");
- return FALSE;
+ return -1;
}
/* The next 4 bytes are the packet length */
/* wind back to the start of the packet ... */
if (file_seek(fh, - offset, SEEK_CUR, err) == -1)
- goto fail;
+ return -1;
- return wtap_read_packet_bytes(fh, buf, packet_size, err, err_info);
+ if (!wtap_read_packet_bytes(fh, buf, packet_size, err, err_info))
+ return -1;
+
+ return REC_TYPE_PACKET;
fail:
*err = file_error(wth->fh, err_info);
- return FALSE;
+ return -1;
}
-static gboolean stanag4607_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
+static int stanag4607_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
{
gint64 offset;
return stanag4607_read_file(wth, wth->fh, &wth->phdr, wth->frame_buffer, err, err_info);
}
-static gboolean stanag4607_seek_read(wtap *wth, gint64 seek_off,
- struct wtap_pkthdr *phdr,
- Buffer *buf, int *err, gchar **err_info)
+static int stanag4607_seek_read(wtap *wth, gint64 seek_off,
+ struct wtap_pkthdr *phdr,
+ Buffer *buf, int *err, gchar **err_info)
{
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
return stanag4607_read_file(wth, wth->random_fh, phdr, buf, err, err_info);
}
#include "buffer.h"
#include "tnef.h"
-static gboolean tnef_read_file(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
- Buffer *buf, int *err, gchar **err_info)
+static int tnef_read_file(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
+ Buffer *buf, int *err, gchar **err_info)
{
gint64 file_size;
int packet_size;
if ((file_size = wtap_file_size(wth, err)) == -1)
- return FALSE;
+ return -1;
if (file_size > WTAP_MAX_PACKET_SIZE) {
/*
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("tnef: File has %" G_GINT64_MODIFIER "d-byte packet, bigger than maximum of %u",
file_size, WTAP_MAX_PACKET_SIZE);
- return FALSE;
+ return -1;
}
packet_size = (int)file_size;
phdr->ts.secs = 0;
phdr->ts.nsecs = 0;
- return wtap_read_packet_bytes(fh, buf, packet_size, err, err_info);
+ if (!wtap_read_packet_bytes(fh, buf, packet_size, err, err_info))
+ return -1;
+ return REC_TYPE_PACKET;
}
-static gboolean tnef_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
+static int tnef_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
{
gint64 offset;
/* there is only ever one packet */
if (offset)
- return FALSE;
+ return -1;
*data_offset = offset;
return tnef_read_file(wth, wth->fh, &wth->phdr, wth->frame_buffer, err, err_info);
}
-static gboolean tnef_seek_read(wtap *wth, gint64 seek_off,
- struct wtap_pkthdr *phdr,
- Buffer *buf, int *err, gchar **err_info)
+static int tnef_seek_read(wtap *wth, gint64 seek_off,
+ struct wtap_pkthdr *phdr,
+ Buffer *buf, int *err, gchar **err_info)
{
/* there is only one packet */
if(seek_off > 0) {
*err = 0;
- return FALSE;
+ return -1;
}
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
return tnef_read_file(wth, wth->random_fh, phdr, buf, err, err_info);
}
*/
#define TOSHIBA_MAX_PACKET_LEN 16384
-static gboolean toshiba_read(wtap *wth, int *err, gchar **err_info,
+static int toshiba_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean toshiba_seek_read(wtap *wth, gint64 seek_off,
+static int toshiba_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
static gboolean parse_single_hex_dump_line(char* rec, guint8 *buf,
guint byte_offset);
}
/* Find the next packet and parse it; called from wtap_read(). */
-static gboolean toshiba_read(wtap *wth, int *err, gchar **err_info,
+static int toshiba_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
gint64 offset;
/* Find the next packet */
offset = toshiba_seek_next_packet(wth, err, err_info);
if (offset < 1)
- return FALSE;
+ return -1;
*data_offset = offset;
/* Parse the packet */
- return parse_toshiba_packet(wth->fh, &wth->phdr, wth->frame_buffer,
- err, err_info);
+ if (!parse_toshiba_packet(wth->fh, &wth->phdr, wth->frame_buffer,
+ err, err_info))
+ return -1;
+ return REC_TYPE_PACKET;
}
/* Used to read packets in random-access fashion */
-static gboolean
+static int
toshiba_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf,
int *err, gchar **err_info)
{
if (file_seek(wth->random_fh, seek_off - 1, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
if (!parse_toshiba_packet(wth->random_fh, phdr, buf, err, err_info)) {
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
/* Parses a packet. */
/* Local functions to handle file reads and writes */
-static gboolean visual_read(wtap *wth, int *err, gchar **err_info,
+static int visual_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean visual_seek_read(wtap *wth, gint64 seek_off,
+static int visual_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
static gboolean visual_read_packet(wtap *wth, FILE_T fh,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
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. */
-static gboolean visual_read(wtap *wth, int *err, gchar **err_info,
+static int visual_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
struct visual_read_info *visual = (struct visual_read_info *)wth->priv;
if (visual->current_pkt > visual->num_pkts)
{
*err = 0; /* it's just an EOF, not an error */
- return FALSE;
+ return -1;
}
visual->current_pkt++;
*data_offset = file_tell(wth->fh);
- return visual_read_packet(wth, wth->fh, &wth->phdr, wth->frame_buffer,
- err, err_info);
+ if (!visual_read_packet(wth, wth->fh, &wth->phdr, wth->frame_buffer,
+ err, err_info))
+ return -1;
+ return REC_TYPE_PACKET;
}
/* Read packet header and data for random access. */
-static gboolean visual_seek_read(wtap *wth, gint64 seek_off,
+static int visual_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
{
/* Seek to the packet header */
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
/* Read the packet. */
if (!visual_read_packet(wth, wth->random_fh, phdr, buf, err, err_info)) {
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
static gboolean
#define VMS_HEADER_LINES_TO_CHECK 200
#define VMS_LINE_LENGTH 240
-static gboolean vms_read(wtap *wth, int *err, gchar **err_info,
+static int vms_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset);
-static gboolean vms_seek_read(wtap *wth, gint64 seek_off,
+static int vms_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
static gboolean parse_single_hex_dump_line(char* rec, guint8 *buf,
long byte_offset, int in_off, int remaining_bytes);
}
/* Find the next packet and parse it; called from wtap_read(). */
-static gboolean vms_read(wtap *wth, int *err, gchar **err_info,
+static int vms_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
gint64 offset = 0;
#endif
if (offset < 1) {
*err = file_error(wth->fh, err_info);
- return FALSE;
+ return -1;
}
*data_offset = offset;
/* Parse the packet */
- return parse_vms_packet(wth->fh, &wth->phdr, wth->frame_buffer, err, err_info);
+ if (!parse_vms_packet(wth->fh, &wth->phdr, wth->frame_buffer, err, err_info))
+ return -1;
+ return REC_TYPE_PACKET;
}
/* Used to read packets in random-access fashion */
Buffer *buf, int *err, gchar **err_info)
{
if (file_seek(wth->random_fh, seek_off - 1, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
if (!parse_vms_packet(wth->random_fh, phdr, buf, err, err_info)) {
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
- return FALSE;
+ return -1;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
/* isdumpline assumes that dump lines start with some non-alphanumerics
static guint8 get_cck_rate(const guint8 *plcp);
static void setup_defaults(vwr_t *, guint16);
-static gboolean vwr_read(wtap *, int *, gchar **, gint64 *);
-static gboolean vwr_seek_read(wtap *, gint64, struct wtap_pkthdr *phdr,
+static int vwr_read(wtap *, int *, gchar **, gint64 *);
+static int vwr_seek_read(wtap *, gint64, struct wtap_pkthdr *phdr,
Buffer *, int *, gchar **);
static gboolean vwr_read_rec_header(vwr_t *, FILE_T, int *, int *, int *, gchar **);
/* frame, and a 64-byte statistics block trailer. */
/* The PLCP frame consists of a 4-byte or 6-byte PLCP header, followed by the MAC frame */
-static gboolean vwr_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
+static int vwr_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
{
vwr_t *vwr = (vwr_t *)wth->priv;
int rec_size = 0, IS_TX;
/* read the next frame record header in the capture file; if no more frames, return */
if (!vwr_read_rec_header(vwr, wth->fh, &rec_size, &IS_TX, err, err_info))
- return FALSE; /* Read error or EOF */
+ return -1; /* Read error or EOF */
/*
* We're past the header; return the offset of the header, not of
/* got a frame record; read and process it */
if (!vwr_process_rec_data(wth->fh, rec_size, &wth->phdr,
wth->frame_buffer, vwr, IS_TX, err, err_info))
- return FALSE;
+ return -1;
/* If the per-file encapsulation isn't known, set it to this packet's encapsulation. */
/* If it *is* known, and it isn't this packet's encapsulation, set it to */
wth->file_encap = WTAP_ENCAP_PER_PACKET;
}
- return TRUE;
+ return REC_TYPE_PACKET;
}
/* read a random record in the middle of a file; the start of the record is @ seek_off */
-static gboolean vwr_seek_read(wtap *wth, gint64 seek_off,
+static int vwr_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
{
vwr_t *vwr = (vwr_t *)wth->priv;
/* first seek to the indicated record header */
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
- return FALSE;
+ return -1;
/* read in the record header */
if (!vwr_read_rec_header(vwr, wth->random_fh, &rec_size, &IS_TX, err, err_info))
- return FALSE; /* Read error or EOF */
+ return -1; /* Read error or EOF */
+
+ if (!vwr_process_rec_data(wth->random_fh, rec_size, phdr, buf,
+ vwr, IS_TX, err, err_info))
+ return -1;
- return vwr_process_rec_data(wth->random_fh, rec_size, phdr, buf,
- vwr, IS_TX, err, err_info);
+ return REC_TYPE_PACKET;
}
/* Scan down in the input capture file to find the next frame header. */
WS_DLL_PUBLIC
int wtap_fstat(wtap *wth, ws_statb64 *statb, int *err);
-typedef gboolean (*subtype_read_func)(struct wtap*, int*, char**, gint64*);
-typedef gboolean (*subtype_seek_read_func)(struct wtap*, gint64,
- struct wtap_pkthdr *, Buffer *buf,
- int *, char **);
+typedef int (*subtype_read_func)(struct wtap*, int*, char**, gint64*);
+typedef int (*subtype_seek_read_func)(struct wtap*, gint64,
+ struct wtap_pkthdr *, Buffer *,
+ int *, char **);
/**
* Struct holding data of the currently read file.
*/
wth->add_new_ipv6 = add_new_ipv6;
}
-gboolean
+int
wtap_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
{
+ int rectype;
+
/*
* Set the packet encapsulation to the file's encapsulation
* value; if that's not WTAP_ENCAP_PER_PACKET, it's the
*/
wth->phdr.pkt_encap = wth->file_encap;
- if (!wth->subtype_read(wth, err, err_info, data_offset)) {
+ rectype = wth->subtype_read(wth, err, err_info, data_offset);
+ if (rectype == -1) {
/*
* If we didn't get an error indication, we read
* the last packet. See if there's any deferred
*/
if (*err == 0)
*err = file_error(wth->fh, err_info);
- return FALSE; /* failure */
+ return rectype; /* failure */
}
/*
*/
g_assert(wth->phdr.pkt_encap != WTAP_ENCAP_PER_PACKET);
- return TRUE; /* success */
+ return rectype;
}
/*
return buffer_start_ptr(wth->frame_buffer);
}
-gboolean
+int
wtap_seek_read(wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
{
- if (!wth->subtype_seek_read(wth, seek_off, phdr, buf, err, err_info))
- return FALSE;
+ int rectype;
+
+ rectype = wth->subtype_seek_read(wth, seek_off, phdr, buf, err, err_info);
+ if (rectype == -1)
+ return rectype;
/*
* It makes no sense for the captured data length to be bigger
*/
g_assert(wth->phdr.pkt_encap != WTAP_ENCAP_PER_PACKET);
- return TRUE;
+ return rectype;
}
WS_DLL_PUBLIC
void wtap_set_cb_new_ipv6(wtap *wth, wtap_new_ipv6_callback_t add_new_ipv6);
-/** Returns TRUE if read was successful. FALSE if failure. data_offset is
- * set to the offset in the file where the data for the read packet is
- * located. */
+/*
+ * Values returned by wtap_read() and wtap_seek_read(). They indicate the
+ * type of record read by that routine.
+ *
+ * This list will expand over time, so don't assume everything will be a
+ * file-type-specific record or a packet record.
+ */
+#define REC_TYPE_FILE_TYPE_SPECIFIC 0 /* file-type-specific record */
+#define REC_TYPE_PACKET 1 /* packet */
+
+/** Returns a REC_TYPE_ value if read was successful, -1 if it failed.
+ * *data_offset is set to the offset in the file where the data for
+ * the read packet is located. */
WS_DLL_PUBLIC
-gboolean wtap_read(wtap *wth, int *err, gchar **err_info,
- gint64 *data_offset);
+int wtap_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset);
WS_DLL_PUBLIC
-gboolean wtap_seek_read (wtap *wth, gint64 seek_off,
+int wtap_seek_read (wtap *wth, gint64 seek_off,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
/*** get various information snippets about the current packet ***/
git.samba.org / jlayton / wireshark.git / commitdiff