diff options
Diffstat (limited to 'wiretap')
49 files changed, 218 insertions, 5 deletions
diff --git a/wiretap/5views.c b/wiretap/5views.c index db377b1570..c30571096c 100644 --- a/wiretap/5views.c +++ b/wiretap/5views.c @@ -297,6 +297,7 @@ _5views_read_header(wtap *wth, FILE_T fh, t_5VW_TimeStamped_Header *hdr, hdr->Utc = pletoh32(&hdr->Utc); hdr->NanoSecondes = pletoh32(&hdr->NanoSecondes); + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS; phdr->ts.secs = hdr->Utc; phdr->ts.nsecs = hdr->NanoSecondes; @@ -370,6 +371,12 @@ static gboolean _5views_dump(wtap_dumper *wdh, _5views_dump_t *_5views = (_5views_dump_t *)wdh->priv; t_5VW_TimeStamped_Header HeaderFrame; + /* We can only write packet records. */ + if (phdr->rec_type != REC_TYPE_PACKET) { + *err = WTAP_ERR_REC_TYPE_UNSUPPORTED; + return FALSE; + } + /* Don't write out something bigger than we can read. */ if (phdr->caplen > WTAP_MAX_PACKET_SIZE) { *err = WTAP_ERR_PACKET_TOO_LARGE; diff --git a/wiretap/aethra.c b/wiretap/aethra.c index a0b783b349..59fbcd55e7 100644 --- a/wiretap/aethra.c +++ b/wiretap/aethra.c @@ -331,6 +331,7 @@ aethra_read_rec_header(wtap *wth, FILE_T fh, struct aethrarec_hdr *hdr, packet_size = rec_size - (guint32)(sizeof *hdr - sizeof hdr->rec_size); msecs = pletoh32(hdr->timestamp); + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS; phdr->ts.secs = aethra->start + (msecs / 1000); phdr->ts.nsecs = (msecs % 1000) * 1000000; diff --git a/wiretap/ber.c b/wiretap/ber.c index 59e7e28f39..8e52e79b06 100644 --- a/wiretap/ber.c +++ b/wiretap/ber.c @@ -59,6 +59,7 @@ static gboolean ber_read_file(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, } packet_size = (int)file_size; + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = 0; /* yes, we have no bananas^Wtime stamp */ phdr->caplen = packet_size; diff --git a/wiretap/btsnoop.c b/wiretap/btsnoop.c index b7c0b4c5c5..9ea165ad4c 100644 --- a/wiretap/btsnoop.c +++ b/wiretap/btsnoop.c @@ -216,6 +216,7 @@ static gboolean btsnoop_read_record(wtap *wth, FILE_T fh, ts = GINT64_FROM_BE(hdr.ts_usec); ts -= KUnixTimeBase; + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN; phdr->ts.secs = (guint)(ts / 1000000); phdr->ts.nsecs = (guint)((ts % 1000000) * 1000); @@ -331,6 +332,12 @@ static gboolean btsnoop_dump_h1(wtap_dumper *wdh, const union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header; struct btsnooprec_hdr rec_hdr; + /* We can only write packet records. */ + if (phdr->rec_type != REC_TYPE_PACKET) { + *err = WTAP_ERR_REC_TYPE_UNSUPPORTED; + return FALSE; + } + /* * Don't write out anything bigger than we can read. * (This will also fail on a caplen of 0, as it should.) @@ -369,6 +376,12 @@ static gboolean btsnoop_dump_h4(wtap_dumper *wdh, const union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header; struct btsnooprec_hdr rec_hdr; + /* We can only write packet records. */ + if (phdr->rec_type != REC_TYPE_PACKET) { + *err = WTAP_ERR_REC_TYPE_UNSUPPORTED; + return FALSE; + } + /* Don't write out anything bigger than we can read. */ if (phdr->caplen > WTAP_MAX_PACKET_SIZE) { *err = WTAP_ERR_PACKET_TOO_LARGE; diff --git a/wiretap/camins.c b/wiretap/camins.c index ccc618498a..f065f0bd1d 100644 --- a/wiretap/camins.c +++ b/wiretap/camins.c @@ -287,6 +287,7 @@ camins_read_packet(FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf, return FALSE; offset += bytes_read; + phdr->rec_type = REC_TYPE_PACKET; phdr->pkt_encap = WTAP_ENCAP_DVBCI; /* timestamps aren't supported for now */ phdr->caplen = offset; diff --git a/wiretap/catapult_dct2000.c b/wiretap/catapult_dct2000.c index 8b29a23880..be9b75eeee 100644 --- a/wiretap/catapult_dct2000.c +++ b/wiretap/catapult_dct2000.c @@ -605,6 +605,12 @@ catapult_dct2000_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr, dct2000_file_externals_t *file_externals = (dct2000_file_externals_t*)pseudo_header->dct2000.wth->priv; + /* We can only write packet records. */ + if (phdr->rec_type != REC_TYPE_PACKET) { + *err = WTAP_ERR_REC_TYPE_UNSUPPORTED; + return FALSE; + } + dct2000 = (dct2000_dump_t *)wdh->priv; if (dct2000 == NULL) { @@ -1276,6 +1282,7 @@ process_parsed_line(wtap *wth, dct2000_file_externals_t *file_externals, gsize length; guint8 *frame_buffer; + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS; /* Make sure all packets go to Catapult DCT2000 dissector */ diff --git a/wiretap/commview.c b/wiretap/commview.c index e2a868a6b2..b9ad83bfd0 100644 --- a/wiretap/commview.c +++ b/wiretap/commview.c @@ -173,6 +173,7 @@ commview_read_packet(FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf, tm.tm_sec = cv_hdr.seconds; tm.tm_isdst = -1; + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS; phdr->len = cv_hdr.data_len; @@ -275,6 +276,12 @@ static gboolean commview_dump(wtap_dumper *wdh, commview_header_t cv_hdr; struct tm *tm; + /* We can only write packet records. */ + if (phdr->rec_type != REC_TYPE_PACKET) { + *err = WTAP_ERR_REC_TYPE_UNSUPPORTED; + return FALSE; + } + /* Don't write out anything bigger than we can read. * (The length field in packet headers is 16 bits, which * imposes a hard limit.) */ diff --git a/wiretap/cosine.c b/wiretap/cosine.c index d937018796..a583e766b0 100644 --- a/wiretap/cosine.c +++ b/wiretap/cosine.c @@ -386,6 +386,7 @@ parse_cosine_rec_hdr(struct wtap_pkthdr *phdr, const char *line, yy = mm = dd = hr = min = sec = csec = 0; } + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN; tm.tm_year = yy - 1900; tm.tm_mon = mm - 1; diff --git a/wiretap/csids.c b/wiretap/csids.c index bc640f639d..bdfe8fcd34 100644 --- a/wiretap/csids.c +++ b/wiretap/csids.c @@ -195,6 +195,7 @@ csids_read_packet(FILE_T fh, csids_t *csids, struct wtap_pkthdr *phdr, hdr.seconds = pntoh32(&hdr.seconds); hdr.caplen = pntoh16(&hdr.caplen); + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS; phdr->len = hdr.caplen; phdr->caplen = hdr.caplen; diff --git a/wiretap/daintree-sna.c b/wiretap/daintree-sna.c index 23785548d2..ea47993d5f 100644 --- a/wiretap/daintree-sna.c +++ b/wiretap/daintree-sna.c @@ -199,6 +199,7 @@ daintree_sna_scan_header(struct wtap_pkthdr *phdr, char *readLine, guint64 seconds; int useconds; + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN; if (sscanf(readLine, "%*s %18" G_GINT64_MODIFIER "u.%9d %9u %" READDATA_MAX_FIELD_SIZE "s", diff --git a/wiretap/dbs-etherwatch.c b/wiretap/dbs-etherwatch.c index 0a3e9f57e1..2fb4bc873a 100644 --- a/wiretap/dbs-etherwatch.c +++ b/wiretap/dbs-etherwatch.c @@ -431,6 +431,7 @@ parse_dbs_etherwatch_packet(struct wtap_pkthdr *phdr, FILE_T fh, Buffer* buf, pd[length_pos+1] = (length) & 0xFF; } + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN; p = strstr(months, mon); diff --git a/wiretap/dct3trace.c b/wiretap/dct3trace.c index 2a0eb9103a..b1bc62050b 100644 --- a/wiretap/dct3trace.c +++ b/wiretap/dct3trace.c @@ -210,6 +210,7 @@ static gboolean dct3trace_get_packet(FILE_T fh, struct wtap_pkthdr *phdr, if( have_data ) { /* We've got a full packet! */ + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = 0; /* no time stamp, no separate "on the wire" length */ phdr->ts.secs = 0; phdr->ts.nsecs = 0; diff --git a/wiretap/erf.c b/wiretap/erf.c index 67b7ccab1d..5800c81650 100644 --- a/wiretap/erf.c +++ b/wiretap/erf.c @@ -374,6 +374,7 @@ static int erf_read_header(FILE_T fh, { guint64 ts = pletoh64(&erf_header->ts); + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN|WTAP_HAS_INTERFACE_ID; phdr->ts.secs = (long) (ts >> 32); ts = ((ts & 0xffffffff) * 1000 * 1000 * 1000); @@ -589,6 +590,12 @@ static gboolean erf_dump( gboolean must_add_crc = FALSE; guint32 crc32 = 0x00000000; + /* We can only write packet records. */ + if (phdr->rec_type != REC_TYPE_PACKET) { + *err = WTAP_ERR_REC_TYPE_UNSUPPORTED; + return FALSE; + } + /* Don't write anything bigger than we're willing to read. */ if(phdr->caplen > WTAP_MAX_PACKET_SIZE) { *err = WTAP_ERR_PACKET_TOO_LARGE; diff --git a/wiretap/eyesdn.c b/wiretap/eyesdn.c index 8bd32c2249..399c02d5b2 100644 --- a/wiretap/eyesdn.c +++ b/wiretap/eyesdn.c @@ -313,6 +313,7 @@ read_eyesdn_rec(FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf, int *err, return FALSE; } + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS; phdr->ts.secs = secs; phdr->ts.nsecs = usecs * 1000; @@ -415,6 +416,12 @@ static gboolean eyesdn_dump(wtap_dumper *wdh, int protocol; int size; + /* We can only write packet records. */ + if (phdr->rec_type != REC_TYPE_PACKET) { + *err = WTAP_ERR_REC_TYPE_UNSUPPORTED; + return FALSE; + } + /* Don't write out anything bigger than we can read. * (The length field in packet headers is 16 bits, which * imposes a hard limit.) */ diff --git a/wiretap/hcidump.c b/wiretap/hcidump.c index cc38a62154..2253134a05 100644 --- a/wiretap/hcidump.c +++ b/wiretap/hcidump.c @@ -60,6 +60,7 @@ static gboolean hcidump_process_packet(FILE_T fh, struct wtap_pkthdr *phdr, return FALSE; } + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS; phdr->ts.secs = GUINT32_FROM_LE(dh.ts_sec); phdr->ts.nsecs = GUINT32_FROM_LE(dh.ts_usec) * 1000; diff --git a/wiretap/i4btrace.c b/wiretap/i4btrace.c index 10b7a83eeb..3cf1da691f 100644 --- a/wiretap/i4btrace.c +++ b/wiretap/i4btrace.c @@ -189,6 +189,7 @@ i4b_read_rec(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf, return FALSE; } + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS; phdr->len = length; diff --git a/wiretap/ipfix.c b/wiretap/ipfix.c index 5db06507c2..54fb229e86 100644 --- a/wiretap/ipfix.c +++ b/wiretap/ipfix.c @@ -169,6 +169,7 @@ ipfix_read_message(FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf, int *err, g if (!ipfix_read_message_header(&msg_hdr, fh, err, err_info)) return FALSE; + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS; phdr->len = msg_hdr.message_length; phdr->caplen = msg_hdr.message_length; diff --git a/wiretap/iptrace.c b/wiretap/iptrace.c index 67e8e65806..c7fa0249a7 100644 --- a/wiretap/iptrace.c +++ b/wiretap/iptrace.c @@ -200,6 +200,7 @@ iptrace_read_rec_1_0(FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf, return FALSE; } + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS; phdr->len = packet_size; phdr->caplen = packet_size; @@ -395,6 +396,7 @@ iptrace_read_rec_2_0(FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf, return FALSE; } + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS; phdr->len = packet_size; phdr->caplen = packet_size; diff --git a/wiretap/iseries.c b/wiretap/iseries.c index 0a171a6341..729ad7729e 100644 --- a/wiretap/iseries.c +++ b/wiretap/iseries.c @@ -618,6 +618,7 @@ iseries_parse_packet (wtap * wth, FILE_T fh, struct wtap_pkthdr *phdr, return FALSE; } + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_CAP_LEN; /* diff --git a/wiretap/k12.c b/wiretap/k12.c index 3da976767e..3bd3d3f533 100644 --- a/wiretap/k12.c +++ b/wiretap/k12.c @@ -553,6 +553,7 @@ process_packet_data(struct wtap_pkthdr *phdr, Buffer *target, guint8 *buffer, guint32 src_id; k12_src_desc_t* src_desc; + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS; ts = pntoh64(buffer + K12_PACKET_TIMESTAMP); @@ -1179,6 +1180,12 @@ static gboolean k12_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr, } record; } obj; + /* We can only write packet records. */ + if (phdr->rec_type != REC_TYPE_PACKET) { + *err = WTAP_ERR_REC_TYPE_UNSUPPORTED; + return FALSE; + } + if (k12->num_of_records == 0) { k12_t* file_data = (k12_t*)pseudo_header->k12.stuff; /* XXX: We'll assume that any fwrite errors in k12_dump_src_setting will */ diff --git a/wiretap/k12text.l b/wiretap/k12text.l index 42de8e6875..fd332f2739 100644 --- a/wiretap/k12text.l +++ b/wiretap/k12text.l @@ -185,6 +185,7 @@ static void finalize_frame(void) { static void k12text_set_headers(struct wtap_pkthdr *phdr) { + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN; phdr->ts.secs = 946681200 + (3600*g_h) + (60*g_m) + g_s; diff --git a/wiretap/lanalyzer.c b/wiretap/lanalyzer.c index 8c2ce348a1..d00691beac 100644 --- a/wiretap/lanalyzer.c +++ b/wiretap/lanalyzer.c @@ -523,6 +523,7 @@ static gboolean lanalyzer_read_trace_record(wtap *wth, FILE_T fh, return FALSE; } + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN; time_low = pletoh16(&descriptor[8]); @@ -662,6 +663,12 @@ static gboolean lanalyzer_dump(wtap_dumper *wdh, struct timeval td; int thisSize = phdr->caplen + LA_PacketRecordSize + LA_RecordHeaderSize; + /* We can only write packet records. */ + if (phdr->rec_type != REC_TYPE_PACKET) { + *err = WTAP_ERR_REC_TYPE_UNSUPPORTED; + return FALSE; + } + if (wdh->bytes_dumped + thisSize > LA_ProFileLimit) { /* printf(" LA_ProFileLimit reached\n"); */ *err = EFBIG; @@ -674,7 +681,7 @@ static gboolean lanalyzer_dump(wtap_dumper *wdh, if (len > 65535) { *err = WTAP_ERR_PACKET_TOO_LARGE; return FALSE; - } + } if (!s16write(wdh, GUINT16_TO_LE(0x1005), err)) return FALSE; diff --git a/wiretap/libpcap.c b/wiretap/libpcap.c index fe9c111261..fb920d4e08 100644 --- a/wiretap/libpcap.c +++ b/wiretap/libpcap.c @@ -669,6 +669,7 @@ libpcap_read_packet(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, orig_size -= phdr_len; packet_size -= phdr_len; + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN; /* Update the timestamp, if not already done */ @@ -932,6 +933,12 @@ static gboolean libpcap_dump(wtap_dumper *wdh, phdrsize = pcap_get_phdr_size(wdh->encap, pseudo_header); + /* We can only write packet records. */ + if (phdr->rec_type != REC_TYPE_PACKET) { + *err = WTAP_ERR_REC_TYPE_UNSUPPORTED; + return FALSE; + } + /* Don't write anything we're not willing to read. */ if (phdr->caplen + phdrsize > WTAP_MAX_PACKET_SIZE) { *err = WTAP_ERR_PACKET_TOO_LARGE; diff --git a/wiretap/logcat.c b/wiretap/logcat.c index a1a41c0689..1aa8058fdd 100644 --- a/wiretap/logcat.c +++ b/wiretap/logcat.c @@ -203,6 +203,7 @@ static gboolean logcat_read_packet(struct logcat_phdr *logcat, FILE_T fh, return FALSE; } + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS; phdr->ts.secs = (time_t) pletoh32(pd + 12); phdr->ts.nsecs = (int) pletoh32(pd + 16); @@ -298,6 +299,12 @@ static gboolean logcat_binary_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr, const guint8 *pd, int *err) { + /* We can only write packet records. */ + if (phdr->rec_type != REC_TYPE_PACKET) { + *err = WTAP_ERR_REC_TYPE_UNSUPPORTED; + return FALSE; + } + if (!wtap_dump_file_write(wdh, pd, phdr->caplen, err)) return FALSE; @@ -343,6 +350,12 @@ static gboolean logcat_dump_text(wtap_dumper *wdh, const union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header; const struct dumper_t *dumper = (const struct dumper_t *) wdh->priv; + /* We can only write packet records. */ + if (phdr->rec_type != REC_TYPE_PACKET) { + *err = WTAP_ERR_REC_TYPE_UNSUPPORTED; + return FALSE; + } + if (pseudo_header->logcat.version == 1) { pid = (const gint *) (pd + 4); tid = (const gint *) (pd + 2 * 4); diff --git a/wiretap/mime_file.c b/wiretap/mime_file.c index 3601f23952..52c04ccc69 100644 --- a/wiretap/mime_file.c +++ b/wiretap/mime_file.c @@ -116,6 +116,7 @@ mime_read_file(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, } packet_size = (int)file_size; + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = 0; /* yes, we have no bananas^Wtime stamp */ phdr->caplen = packet_size; diff --git a/wiretap/mp2t.c b/wiretap/mp2t.c index 844fb40a13..103d6fe298 100644 --- a/wiretap/mp2t.c +++ b/wiretap/mp2t.c @@ -79,6 +79,8 @@ mp2t_read_packet(mp2t_filetype_t *mp2t, FILE_T fh, gint64 offset, return FALSE; } + phdr->rec_type = REC_TYPE_PACKET; + /* XXX - relative, not absolute, time stamps */ phdr->presence_flags = WTAP_HAS_TS; diff --git a/wiretap/mpeg.c b/wiretap/mpeg.c index abe87a37fe..b8d867754c 100644 --- a/wiretap/mpeg.c +++ b/wiretap/mpeg.c @@ -209,6 +209,8 @@ mpeg_read_packet(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf, if (!wtap_read_packet_bytes(fh, buf, packet_size, err, err_info)) return FALSE; + phdr->rec_type = REC_TYPE_PACKET; + /* XXX - relative, not absolute, time stamps */ if (!is_random) { phdr->presence_flags = WTAP_HAS_TS; diff --git a/wiretap/netmon.c b/wiretap/netmon.c index f12bf43a87..85d82a2d22 100644 --- a/wiretap/netmon.c +++ b/wiretap/netmon.c @@ -538,6 +538,8 @@ static gboolean netmon_process_rec_header(wtap *wth, FILE_T fh, return FALSE; } + phdr->rec_type = REC_TYPE_PACKET; + /* * If this is an ATM packet, the first * "sizeof (struct netmon_atm_hdr)" bytes have destination and @@ -1024,6 +1026,12 @@ static gboolean netmon_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr, gint64 secs; gint32 nsecs; + /* We can only write packet records. */ + if (phdr->rec_type != REC_TYPE_PACKET) { + *err = WTAP_ERR_REC_TYPE_UNSUPPORTED; + return FALSE; + } + switch (wdh->file_type_subtype) { case WTAP_FILE_TYPE_SUBTYPE_NETMON_1_x: diff --git a/wiretap/netscaler.c b/wiretap/netscaler.c index c9785ac992..e6df1d1081 100644 --- a/wiretap/netscaler.c +++ b/wiretap/netscaler.c @@ -513,6 +513,7 @@ typedef struct nspr_pktracepart_v26 TRACE_V10_REC_LEN_OFF(phdr,enumprefix,structprefix,structname) #define TRACE_PART_V10_REC_LEN_OFF(phdr,enumprefix,structprefix,structname) \ + (phdr)->rec_type = REC_TYPE_PACKET;\ (phdr)->presence_flags |= WTAP_HAS_CAP_LEN;\ (phdr)->len = pletoh16(&pp->pp_PktSizeOrg) + nspr_pktracepart_v10_s;\ (phdr)->caplen = pletoh16(&pp->nsprRecordSize);\ @@ -954,6 +955,7 @@ static gboolean nstrace_read_v10(wtap *wth, int *err, gchar **err_info, gint64 * * as the time stamps in the records are relative to\ * the previous packet.\ */\ + (phdr)->rec_type = REC_TYPE_PACKET;\ (phdr)->presence_flags = WTAP_HAS_TS;\ nsg_creltime += ns_hrtime2nsec(pletoh32(&fp->fp_RelTimeHr));\ (phdr)->ts.secs = nstrace->nspm_curtime + (guint32) (nsg_creltime / 1000000000);\ @@ -977,6 +979,7 @@ static gboolean nstrace_read_v10(wtap *wth, int *err, gchar **err_info, gint64 * * as the time stamps in the records are relative to\ * the previous packet.\ */\ + (phdr)->rec_type = REC_TYPE_PACKET;\ (phdr)->presence_flags = WTAP_HAS_TS;\ nsg_creltime += ns_hrtime2nsec(pletoh32(&pp->pp_RelTimeHr));\ (phdr)->ts.secs = nstrace->nspm_curtime + (guint32) (nsg_creltime / 1000000000);\ @@ -1035,6 +1038,7 @@ static gboolean nstrace_read_v10(wtap *wth, int *err, gchar **err_info, gint64 * #define TIMEDEFV20(fp,type) \ do {\ + wth->phdr.rec_type = REC_TYPE_PACKET;\ wth->phdr.presence_flags |= WTAP_HAS_TS;\ nsg_creltime += ns_hrtime2nsec(pletoh32(fp->type##_RelTimeHr));\ wth->phdr.ts.secs = nstrace->nspm_curtime + (guint32) (nsg_creltime / 1000000000);\ @@ -1043,6 +1047,7 @@ static gboolean nstrace_read_v10(wtap *wth, int *err, gchar **err_info, gint64 * #define TIMEDEFV23(fp,type) \ do {\ + wth->phdr.rec_type = REC_TYPE_PACKET;\ wth->phdr.presence_flags |= WTAP_HAS_TS;\ /* access _AbsTimeHr as a 64bit value */\ nsg_creltime = pletoh64(fp->type##_AbsTimeHr);\ @@ -1052,6 +1057,7 @@ static gboolean nstrace_read_v10(wtap *wth, int *err, gchar **err_info, gint64 * #define TIMEDEFV30(fp,type) \ do {\ + wth->phdr.rec_type = REC_TYPE_PACKET;\ wth->phdr.presence_flags |= WTAP_HAS_TS;\ /* access _AbsTimeHr as a 64bit value */\ nsg_creltime = pletoh64(fp->type##_AbsTimeHr);\ @@ -1067,6 +1073,7 @@ static gboolean nstrace_read_v10(wtap *wth, int *err, gchar **err_info, gint64 * #define PPSIZEDEFV20(phdr,pp,ver) \ do {\ + (phdr)->rec_type = REC_TYPE_PACKET;\ (phdr)->presence_flags |= WTAP_HAS_CAP_LEN;\ (phdr)->len = pletoh16(&pp->pp_PktSizeOrg) + nspr_pktracepart_v##ver##_s;\ (phdr)->caplen = nspr_getv20recordsize((nspr_hd_v20_t *)pp);\ @@ -1094,9 +1101,10 @@ static gboolean nstrace_read_v10(wtap *wth, int *err, gchar **err_info, gint64 * #define FPSIZEDEFV30(phdr,fp,ver)\ do {\ + (phdr)->rec_type = REC_TYPE_PACKET;\ + (phdr)->presence_flags |= WTAP_HAS_CAP_LEN;\ (phdr)->len = pletoh16(&fp->fp_PktSizeOrg) + nspr_pktracefull_v##ver##_s;\ (phdr)->caplen = nspr_getv20recordsize((nspr_hd_v20_t *)fp);\ - (phdr)->presence_flags |= WTAP_HAS_CAP_LEN;\ }while(0) #define PACKET_DESCRIBE(phdr,FPTIMEDEF,SIZEDEF,ver,enumprefix,type,structname,TYPE)\ @@ -1822,6 +1830,12 @@ static gboolean nstrace_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr, { nstrace_dump_t *nstrace = (nstrace_dump_t *)wdh->priv; + /* We can only write packet records. */ + if (phdr->rec_type != REC_TYPE_PACKET) { + *err = WTAP_ERR_REC_TYPE_UNSUPPORTED; + return FALSE; + } + if (nstrace->page_offset == 0) { /* Add the signature record and abs time record */ diff --git a/wiretap/netscreen.c b/wiretap/netscreen.c index bbb4a535e9..0d07d14c5e 100644 --- a/wiretap/netscreen.c +++ b/wiretap/netscreen.c @@ -297,6 +297,7 @@ parse_netscreen_rec_hdr(struct wtap_pkthdr *phdr, const char *line, char *cap_in char direction[2]; char cap_src[13]; + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN; if (sscanf(line, "%9d.%9d: %15[a-z0-9/:.-](%1[io]) len=%9d:%12s->%12s/", diff --git a/wiretap/nettl.c b/wiretap/nettl.c index e5f159ef89..8727db106a 100644 --- a/wiretap/nettl.c +++ b/wiretap/nettl.c @@ -323,7 +323,7 @@ nettl_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr, if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1) return FALSE; - /* Read record header. */ + /* Read record. */ if (!nettl_read_rec(wth, wth->random_fh, phdr, buf, err, err_info)) { /* Read error or EOF */ if (*err == 0) { @@ -581,6 +581,7 @@ nettl_read_rec(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf, length, padlen); return FALSE; } + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN; phdr->len = length - padlen; if (caplen < padlen) { @@ -732,6 +733,12 @@ static gboolean nettl_dump(wtap_dumper *wdh, struct nettlrec_hdr rec_hdr; guint8 dummyc[24]; + /* We can only write packet records. */ + if (phdr->rec_type != REC_TYPE_PACKET) { + *err = WTAP_ERR_REC_TYPE_UNSUPPORTED; + return FALSE; + } + /* Don't write anything we're not willing to read. */ if (phdr->caplen > WTAP_MAX_PACKET_SIZE) { *err = WTAP_ERR_PACKET_TOO_LARGE; diff --git a/wiretap/network_instruments.c b/wiretap/network_instruments.c index 38abfab2cd..5e95e1826e 100644 --- a/wiretap/network_instruments.c +++ b/wiretap/network_instruments.c @@ -443,6 +443,7 @@ process_packet_header(wtap *wth, packet_entry_header *packet_header, struct wtap_pkthdr *phdr, int *err, gchar **err_info) { /* set the wiretap packet header fields */ + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN; phdr->pkt_encap = observer_to_wtap_encap(packet_header->network_type); if(wth->file_encap == WTAP_ENCAP_FIBRE_CHANNEL_FC2_WITH_FRAME_DELIMS) { @@ -695,6 +696,12 @@ static gboolean observer_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr, packet_entry_header packet_header; guint64 seconds_since_2000; + /* We can only write packet records. */ + if (phdr->rec_type != REC_TYPE_PACKET) { + *err = WTAP_ERR_REC_TYPE_UNSUPPORTED; + return FALSE; + } + /* The captured size field is 16 bits, so there's a hard limit of 65535. */ if (phdr->caplen > 65535) { diff --git a/wiretap/netxray.c b/wiretap/netxray.c index e6dd704bb3..1a7465453d 100644 --- a/wiretap/netxray.c +++ b/wiretap/netxray.c @@ -1590,6 +1590,7 @@ netxray_process_rec_header(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, break; } + phdr->rec_type = REC_TYPE_PACKET; if (netxray->version_major == 0) { phdr->presence_flags = WTAP_HAS_TS; t = (double)pletoh32(&hdr.old_hdr.timelo) @@ -1738,6 +1739,12 @@ netxray_dump_1_1(wtap_dumper *wdh, guint32 t32; struct netxrayrec_1_x_hdr rec_hdr; + /* We can only write packet records. */ + if (phdr->rec_type != REC_TYPE_PACKET) { + *err = WTAP_ERR_REC_TYPE_UNSUPPORTED; + return FALSE; + } + /* The captured length field is 16 bits, so there's a hard limit of 65535. */ if (phdr->caplen > 65535) { @@ -1911,6 +1918,12 @@ netxray_dump_2_0(wtap_dumper *wdh, guint32 t32; struct netxrayrec_2_x_hdr rec_hdr; + /* We can only write packet records. */ + if (phdr->rec_type != REC_TYPE_PACKET) { + *err = WTAP_ERR_REC_TYPE_UNSUPPORTED; + return FALSE; + } + /* Don't write anything we're not willing to read. */ if (phdr->caplen > WTAP_MAX_PACKET_SIZE) { *err = WTAP_ERR_PACKET_TOO_LARGE; diff --git a/wiretap/ngsniffer.c b/wiretap/ngsniffer.c index 8138a31f44..dd341413b9 100644 --- a/wiretap/ngsniffer.c +++ b/wiretap/ngsniffer.c @@ -1347,6 +1347,7 @@ ngsniffer_process_record(wtap *wth, gboolean is_random, guint *padding, *padding = length - size; } + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = true_size ? WTAP_HAS_TS|WTAP_HAS_CAP_LEN : WTAP_HAS_TS; phdr->len = true_size ? true_size : size; phdr->caplen = size; @@ -2073,6 +2074,12 @@ ngsniffer_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr, guint16 start_date; struct tm *tm; + /* We can only write packet records. */ + if (phdr->rec_type != REC_TYPE_PACKET) { + *err = WTAP_ERR_REC_TYPE_UNSUPPORTED; + return FALSE; + } + /* The captured length field is 16 bits, so there's a hard limit of 65535. */ if (phdr->caplen > 65535) { diff --git a/wiretap/packetlogger.c b/wiretap/packetlogger.c index 313cf3e5b8..1941e981d8 100644 --- a/wiretap/packetlogger.c +++ b/wiretap/packetlogger.c @@ -157,6 +157,7 @@ packetlogger_read_packet(FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf, return FALSE; } + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS; phdr->len = pl_hdr.len - 8; diff --git a/wiretap/pcapng.c b/wiretap/pcapng.c index a0be4a9eaa..6fd0a881e2 100644 --- a/wiretap/pcapng.c +++ b/wiretap/pcapng.c @@ -1109,6 +1109,7 @@ pcapng_read_packet_block(FILE_T fh, pcapng_block_header_t *bh, pcapng_t *pn, wta iface_info = g_array_index(pn->interfaces, interface_info_t, packet.interface_id); + wblock->packet_header->rec_type = REC_TYPE_PACKET; wblock->packet_header->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN|WTAP_HAS_INTERFACE_ID; pcapng_debug3("pcapng_read_packet_block: encapsulation = %d (%s), pseudo header size = %d.", @@ -1388,6 +1389,7 @@ pcapng_read_simple_packet_block(FILE_T fh, pcapng_block_header_t *bh, pcapng_t * pcap_get_phdr_size(iface_info.wtap_encap, &wblock->packet_header->pseudo_header)); /* No time stamp in a simple packet block; no options, either */ + wblock->packet_header->rec_type = REC_TYPE_PACKET; wblock->packet_header->presence_flags = WTAP_HAS_CAP_LEN|WTAP_HAS_INTERFACE_ID; wblock->packet_header->interface_id = 0; wblock->packet_header->pkt_encap = iface_info.wtap_encap; @@ -3552,6 +3554,12 @@ static gboolean pcapng_dump(wtap_dumper *wdh, phdr->pkt_encap, wtap_encap_string(phdr->pkt_encap)); + /* We can only write packet records. */ + if (phdr->rec_type != REC_TYPE_PACKET) { + *err = WTAP_ERR_REC_TYPE_UNSUPPORTED; + return FALSE; + } + /* Flush any hostname resolution info we may have */ pcapng_write_name_resolution_block(wdh, err); diff --git a/wiretap/peekclassic.c b/wiretap/peekclassic.c index a10ae66fd5..4bde81adde 100644 --- a/wiretap/peekclassic.c +++ b/wiretap/peekclassic.c @@ -447,6 +447,7 @@ static int peekclassic_read_packet_v7(wtap *wth, FILE_T fh, } /* fill in packet header values */ + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN; tsecs = (time_t) (timestamp/1000000); tusecs = (guint32) (timestamp - tsecs*1000000); @@ -580,6 +581,7 @@ static gboolean peekclassic_read_packet_v56(wtap *wth, FILE_T fh, } /* fill in packet header values */ + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN; /* timestamp is in milliseconds since reference_time */ phdr->ts.secs = peekclassic->reference_time.tv_sec diff --git a/wiretap/peektagged.c b/wiretap/peektagged.c index 05dc8beaef..ae3881ed90 100644 --- a/wiretap/peektagged.c +++ b/wiretap/peektagged.c @@ -577,6 +577,7 @@ peektagged_read_packet(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, return -1; } + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN; phdr->len = hdr_info.length; phdr->caplen = hdr_info.sliceLength; diff --git a/wiretap/pppdump.c b/wiretap/pppdump.c index 6ba142485b..c22b70a682 100644 --- a/wiretap/pppdump.c +++ b/wiretap/pppdump.c @@ -319,6 +319,7 @@ static void pppdump_set_phdr(struct wtap_pkthdr *phdr, int num_bytes, direction_enum direction) { + phdr->rec_type = REC_TYPE_PACKET; phdr->len = num_bytes; phdr->caplen = num_bytes; phdr->pkt_encap = WTAP_ENCAP_PPP_WITH_PHDR; @@ -369,10 +370,10 @@ pppdump_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset) *data_offset = state->pkt_cnt; state->pkt_cnt++; + pppdump_set_phdr(&wth->phdr, num_bytes, direction); wth->phdr.presence_flags = WTAP_HAS_TS; wth->phdr.ts.secs = state->timestamp; wth->phdr.ts.nsecs = state->tenths * 100000000; - pppdump_set_phdr(&wth->phdr, num_bytes, direction); return TRUE; } diff --git a/wiretap/radcom.c b/wiretap/radcom.c index 3e9883da57..96842d00bd 100644 --- a/wiretap/radcom.c +++ b/wiretap/radcom.c @@ -339,6 +339,7 @@ radcom_read_rec(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf, length = pletoh16(&hdr.length); real_length = pletoh16(&hdr.real_length); + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN; tm.tm_year = pletoh16(&hdr.date.year)-1900; diff --git a/wiretap/snoop.c b/wiretap/snoop.c index 265d23f4a2..c6991d064c 100644 --- a/wiretap/snoop.c +++ b/wiretap/snoop.c @@ -626,6 +626,7 @@ snoop_read_packet(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, break; } + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN; phdr->ts.secs = g_ntohl(hdr.ts_sec); phdr->ts.nsecs = g_ntohl(hdr.ts_usec) * 1000; @@ -876,6 +877,12 @@ static gboolean snoop_dump(wtap_dumper *wdh, struct snoop_atm_hdr atm_hdr; int atm_hdrsize; + /* We can only write packet records. */ + if (phdr->rec_type != REC_TYPE_PACKET) { + *err = WTAP_ERR_REC_TYPE_UNSUPPORTED; + return FALSE; + } + if (wdh->encap == WTAP_ENCAP_ATM_PDUS) atm_hdrsize = sizeof (struct snoop_atm_hdr); else diff --git a/wiretap/stanag4607.c b/wiretap/stanag4607.c index d4a5ed5317..369bb31654 100644 --- a/wiretap/stanag4607.c +++ b/wiretap/stanag4607.c @@ -72,6 +72,8 @@ static gboolean stanag4607_read_file(wtap *wth, FILE_T fh, struct wtap_pkthdr *p return FALSE; } + phdr->rec_type = REC_TYPE_PACKET; + /* The next 4 bytes are the packet length */ packet_size = pntoh32(&stanag_pkt_hdr[2]); phdr->caplen = packet_size; diff --git a/wiretap/tnef.c b/wiretap/tnef.c index 5bd2fa1463..b7e834eaaa 100644 --- a/wiretap/tnef.c +++ b/wiretap/tnef.c @@ -51,6 +51,7 @@ static gboolean tnef_read_file(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, } packet_size = (int)file_size; + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = 0; /* yes, we have no bananas^Wtime stamp */ phdr->caplen = packet_size; diff --git a/wiretap/toshiba.c b/wiretap/toshiba.c index 6fcf40270b..e649bf8fb3 100644 --- a/wiretap/toshiba.c +++ b/wiretap/toshiba.c @@ -314,6 +314,7 @@ parse_toshiba_packet(FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf, return FALSE; } + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN; phdr->ts.secs = hr * 3600 + min * 60 + sec; phdr->ts.nsecs = csec * 10000000; diff --git a/wiretap/visual.c b/wiretap/visual.c index cfa03bceac..c10594b615 100644 --- a/wiretap/visual.c +++ b/wiretap/visual.c @@ -350,6 +350,7 @@ visual_read_packet(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, /* Get the included length of data. This includes extra headers + payload */ packet_size = pletoh16(&vpkt_hdr.incl_len); + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN; /* Set the packet time and length. */ @@ -674,6 +675,12 @@ static gboolean visual_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr, guint delta_msec; guint32 packet_status; + /* We can only write packet records. */ + if (phdr->rec_type != REC_TYPE_PACKET) { + *err = WTAP_ERR_REC_TYPE_UNSUPPORTED; + return FALSE; + } + /* Don't write anything we're not willing to read. */ if (phdr->caplen > WTAP_MAX_PACKET_SIZE) { *err = WTAP_ERR_PACKET_TOO_LARGE; diff --git a/wiretap/vms.c b/wiretap/vms.c index 3684c3bbbe..4cabfdf3d8 100644 --- a/wiretap/vms.c +++ b/wiretap/vms.c @@ -400,6 +400,7 @@ parse_vms_packet(FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf, int *err, gch tm.tm_year -= 1900; tm.tm_isdst = -1; + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS; phdr->ts.secs = mktime(&tm); phdr->ts.nsecs = csec * 10000000; diff --git a/wiretap/vwr.c b/wiretap/vwr.c index 7d0b291c62..7dad644fcb 100644 --- a/wiretap/vwr.c +++ b/wiretap/vwr.c @@ -979,6 +979,7 @@ static gboolean vwr_read_s1_W_rec(vwr_t *vwr, struct wtap_pkthdr *phdr, phdr->ts.nsecs = (int)(s_usec * 1000); phdr->pkt_encap = WTAP_ENCAP_IXVERIWAVE; + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS; buffer_assure_space(buf, phdr->caplen); @@ -1335,6 +1336,7 @@ static gboolean vwr_read_s2_W_rec(vwr_t *vwr, struct wtap_pkthdr *phdr, phdr->ts.nsecs = (int)(s_usec * 1000); phdr->pkt_encap = WTAP_ENCAP_IXVERIWAVE; + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS; buffer_assure_space(buf, phdr->caplen); @@ -1628,6 +1630,7 @@ static gboolean vwr_read_rec_data_ethernet(vwr_t *vwr, struct wtap_pkthdr *phdr, phdr->ts.nsecs = (int)(s_usec * 1000); phdr->pkt_encap = WTAP_ENCAP_IXVERIWAVE; + phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS; /*etap_hdr.vw_ip_length = (guint16)ip_len;*/ diff --git a/wiretap/wtap.c b/wiretap/wtap.c index c32524be80..a0117ab784 100644 --- a/wiretap/wtap.c +++ b/wiretap/wtap.c @@ -833,7 +833,9 @@ static const char *wtap_errlist[] = { NULL, "Uncompression error", "Internal error", - "The packet being written is too large for that format" + "The packet being written is too large for that format", + NULL, + "That record type cannot be written in that format" }; #define WTAP_ERRLIST_SIZE (sizeof wtap_errlist / sizeof wtap_errlist[0]) diff --git a/wiretap/wtap.h b/wiretap/wtap.h index 005d748304..4c12eb422c 100644 --- a/wiretap/wtap.h +++ b/wiretap/wtap.h @@ -916,7 +916,20 @@ union wtap_pseudo_header { struct logcat_phdr logcat; }; +/* + * Record type values. + * + * This list will expand over time, so don't assume everything will be a + * packet record or a file-type-specific record. + * + * Non-packet records might have a time stamp; other fields may only + * apply to packet records. + */ +#define REC_TYPE_PACKET 0 /**< packet */ +#define REC_TYPE_FILE_TYPE_SPECIFIC 1 /**< file-type-specific record */ + struct wtap_pkthdr { + guint rec_type; /* what type of record is this? */ guint32 presence_flags; /* what stuff do we have? */ nstime_t ts; guint32 caplen; /* data length in the file */ @@ -1634,6 +1647,9 @@ int wtap_register_encap_type(const char* name, const char* short_name); /** Not really an error: the file type being checked is from a Lua plugin, so that the code will call wslua_can_write_encap() instead if it gets this */ +#define WTAP_ERR_REC_TYPE_UNSUPPORTED -26 + /** Specified record type can't be written to that file type */ + #ifdef __cplusplus } #endif /* __cplusplus */ |