Allow wtap_read() and wtap_seek_read() to return records other than packets.

Add a "record type" field to "struct wtap_pkthdr"; currently, it can be
REC_TYPE_PACKET, for a record containing a packet, or
REC_TYPE_FILE_TYPE_SPECIFIC, for records containing file-type-specific
data.

Modify code that reads packets to be able to handle non-packet records,
even if that just means ignoring them.

Rename some routines to indicate that they handle more than just
packets.

We don't yet have any libwiretap code that supplies records other than
REC_TYPE_PACKET or that supporting writing records other than
REC_TYPE_PACKET, or any code to support plugins for handling
REC_TYPE_FILE_TYPE_SPECIFIC records; this is just the first step for bug
8590.

Change-Id: Idb40b78f17c2c3aea72031bcd252abf9bc11c813
Reviewed-on: https://code.wireshark.org/review/1773
Reviewed-by: Guy Harris <guy@alum.mit.edu>

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 */