From Harald Welte:
[obnox/wireshark/wip.git] / wiretap / k12.c
index f9952f778e93f6005e432605b6997cc13e297bff..0ff3d68f16214d7d6248c3e5debf803c2c4d5cca 100644 (file)
 
 #include <wsutil/str_util.h>
 
+/*
+ * See
+ *
+ *  http://www2.tek.com/cmswpt/madownload.lotr?ct=MA&cs=mpm&ci=11284&lc=EN
+ *
+ * for some information about the file format.  You may have to fill in
+ * a form to download the document ("Recored File API Programmer Manual").
+ *
+ * Unfortunately, it describes an API that delivers records from an rf5
+ * file, not the raw format of an rf5 file, so, while it gives the formats
+ * of the records with various types, it does not indicate how those records
+ * are stored in the file.
+ */
+
 /* #define DEBUG_K12 */
 #ifdef DEBUG_K12
 #include <stdio.h>
@@ -128,7 +142,7 @@ void k12_hexdump(guint level, gint64 offset, char* label, unsigned char* b, unsi
 
 static const guint8 k12_file_magic[] = { 0x00, 0x00, 0x02, 0x00 ,0x12, 0x05, 0x00, 0x10 };
 
-struct _k12_t {
+typedef struct {
     guint32 file_len;
     guint32 num_of_records; /* XXX: not sure about this */
 
@@ -136,7 +150,7 @@ struct _k12_t {
     GHashTable* src_by_name; /* k12_srcdsc_recs by stack_name */
 
     Buffer extra_info; /* Buffer to hold per packet extra information */
-};
+} k12_t;
 
 typedef struct _k12_src_desc_t {
     guint32 input;
@@ -147,6 +161,37 @@ typedef struct _k12_src_desc_t {
 } k12_src_desc_t;
 
 
+/*
+ * According to the Tektronix documentation, this value is a combination of
+ * a "group" code and a "type" code, with both being 2-byte values and
+ * with the "group" code followe by the "type" code.  The "group" values
+ * are:
+ *
+ *     0x0001 - "data event"
+ *     0x0002 - "text or L1 event"
+ *     0x0007 - "configuration event"
+ *
+ * and the "type" values are:
+ *
+ *  data events:
+ *     0x0020 - "frame" (i.e., "an actual packet")
+ *     0x0021 - "transparent frame"
+ *     0x0022 - "bit data (TRAU frame)"
+ *     0x0024 - "used to mark the frame which is a fragment"
+ *     0x0026 - "used to mark the frame which is a fragment"
+ *     0x0028 - "used to mark the frame which is generated by the LSA"
+ *     0x002A - "used to mark the frame which is generated by the LSA"
+ *
+ *  text or L1 events:
+ *     0x0030 - "text event"
+ *     0x0031 - "L1 event"
+ *     0x0032 - "L1 event (BAI)"
+ *     0x0033 - "L1 event (VX)"
+ *
+ *  configuration events:
+ *     0x0040 - Logical Data Source configuration event
+ *     0x0041 - Logical Link configuration event
+ */
 /* so far we've seen these types of records */
 #define K12_REC_PACKET        0x00010020 /* an actual packet */
 #define K12_REC_SRCDSC        0x00070041 /* port-stack mapping + more, the key of the whole thing */
@@ -157,7 +202,14 @@ typedef struct _k12_src_desc_t {
 #define K12_REC_START         0x00020030 /* a string containing human readable start time  */
 #define K12_REC_STOP          0x00020031 /* a string containing human readable stop time */
 
-#define K12_MASK_PACKET       0xfffffff0  /* the last nibble in packet records somentimes change (not yet understood why) */
+/*
+ * According to the Tektronix documentation, packets, i.e. "data events",
+ * have several different group/type values, which differ in the last
+ * nibble of the type code.  For now, we just mask that nibble off; the
+ * format of the items are different, so we might have to treat different
+ * data event types differently.
+ */
+#define K12_MASK_PACKET       0xfffffff0
 
 /* offsets of elements in the records */
 #define K12_RECORD_LEN         0x0 /* uint32, in bytes */
@@ -207,120 +259,154 @@ typedef struct _k12_src_desc_t {
  *   This reads the next record without the eventual 0x10 bytes.
  *   returns the length of the record + the stuffing (if any)
  *
+ *   Returns number of bytes read on success, 0 on EOF, -1 on error;
+ *   if -1 is returned, *err is set to the error indication and, for
+ *   errors where that's appropriate, *err_info is set to an additional
+ *   error string.
+ *
  * XXX: works at most with 0x1FFF bytes per record
  */
-static gint get_record(guint8** bufferp, FILE* fh, gint64 file_offset) {
-       static guint8* buffer = NULL;
-       static guint buffer_len = 0x2000 ;
-       guint bytes_read;
-       guint last_read;
-       guint actual_len, left;
-       guint8 junk[0x14];
-       guint8* writep;
+static gint get_record(guint8** bufferp, FILE_T fh, gint64 file_offset,
+                       int *err, gchar **err_info) {
+    static guint8* buffer = NULL;
+    static guint buffer_len = 0x2000 ;
+    guint bytes_read;
+    guint last_read;
+    guint left;
+    guint8 junk[0x14];
+    guint8* writep;
+#ifdef DEBUG_K12
+    guint actual_len;
+#endif
 
-       /* where the next unknown 0x10 bytes are stuffed to the file */
-       guint junky_offset = 0x2000 - (gint) ( (file_offset - 0x200) % 0x2000 );
+    /* where the next unknown 0x10 bytes are stuffed to the file */
+    guint junky_offset = 0x2000 - (gint) ( (file_offset - 0x200) % 0x2000 );
 
-       K12_DBG(6,("get_record: ENTER: junky_offset=%" G_GINT64_MODIFIER "d, file_offset=%" G_GINT64_MODIFIER "d",junky_offset,file_offset));
+    K12_DBG(6,("get_record: ENTER: junky_offset=%" G_GINT64_MODIFIER "d, file_offset=%" G_GINT64_MODIFIER "d",junky_offset,file_offset));
 
-       /* no buffer is given, lets create it */
-       if (buffer == NULL) {
-               buffer = g_malloc(0x2000);
-               buffer_len = 0x2000;
-       }
+    /* no buffer is given, lets create it */
+    if (buffer == NULL) {
+        buffer = g_malloc(0x2000);
+        buffer_len = 0x2000;
+    }
 
-       *bufferp = buffer;
+    *bufferp = buffer;
 
-       if  ( junky_offset == 0x2000 ) {
-               /* the length of the record is 0x10 bytes ahead from we are reading */
-               bytes_read = file_read(junk,1,0x14,fh);
+    if  ( junky_offset == 0x2000 ) {
+        /* the length of the record is 0x10 bytes ahead from we are reading */
+        bytes_read = file_read(junk,0x14,fh);
 
         if (bytes_read == 2 && junk[0] == 0xff && junk[1] == 0xff) {
             K12_DBG(1,("get_record: EOF"));
             return 0;
         } else if ( bytes_read < 0x14 ){
-            K12_DBG(1,("get_record: SHORT READ"));
+            K12_DBG(1,("get_record: SHORT READ OR ERROR"));
+            *err = file_error(fh, err_info);
+            if (*err == 0) {
+                *err = WTAP_ERR_SHORT_READ;
+            }
             return -1;
         }
 
-               memcpy(buffer,&(junk[0x10]),4);
-       } else {
-               /* the length of the record is right where we are reading */
-               bytes_read = file_read(buffer,1, 0x4, fh);
+        memcpy(buffer,&(junk[0x10]),4);
+    } else {
+        /* the length of the record is right where we are reading */
+        bytes_read = file_read(buffer, 0x4, fh);
 
-               if (bytes_read == 2 && buffer[0] == 0xff && buffer[1] == 0xff) {
+        if (bytes_read == 2 && buffer[0] == 0xff && buffer[1] == 0xff) {
             K12_DBG(1,("get_record: EOF"));
             return 0;
         } else if ( bytes_read != 0x4 ) {
-            K12_DBG(1,("get_record: SHORT READ"));
+            K12_DBG(1,("get_record: SHORT READ OR ERROR"));
+            *err = file_error(fh, err_info);
+            if (*err == 0) {
+                *err = WTAP_ERR_SHORT_READ;
+            }
             return -1;
         }
-       }
+    }
 
-       actual_len = left = pntohl(buffer);
-       junky_offset -= 0x4;
+    left = pntohl(buffer);
+#ifdef DEBUG_K12
+    actual_len = left;
+#endif
+    junky_offset -= 0x4;
 
-       K12_DBG(5,("get_record: GET length=%u",left));
+    K12_DBG(5,("get_record: GET length=%u",left));
 
-       /* XXX - Is WTAP_MAX_PACKET_SIZE */
-       if (left < 4 || left > WTAP_MAX_PACKET_SIZE) {
-               K12_DBG(1,("get_record: Invalid GET length=%u",left));
-               errno = WTAP_ERR_BAD_RECORD;
-               return -1;
-       }
+    /* XXX - Is WTAP_MAX_PACKET_SIZE */
+    if (left < 4 || left > WTAP_MAX_PACKET_SIZE) {
+        K12_DBG(1,("get_record: Invalid GET length=%u",left));
+        *err = WTAP_ERR_BAD_FILE;
+        *err_info = g_strdup_printf("get_record: Invalid GET length=%u",left);
+        return -1;
+    }
 
-       while (left > buffer_len) *bufferp = buffer = g_realloc(buffer,buffer_len*=2);
+    while (left > buffer_len) *bufferp = buffer = g_realloc(buffer,buffer_len*=2);
 
-       writep = buffer + 4;
-       left -= 4;
+    writep = buffer + 4;
+    left -= 4;
 
-       do {
-               K12_DBG(6,("get_record: looping left=%d junky_offset=%" G_GINT64_MODIFIER "d",left,junky_offset));
+    do {
+        K12_DBG(6,("get_record: looping left=%d junky_offset=%" G_GINT64_MODIFIER "d",left,junky_offset));
 
-               if (junky_offset > left) {
-                       bytes_read += last_read = file_read(writep,1, left, fh);
+        if (junky_offset > left) {
+            bytes_read += last_read = file_read(writep, left, fh);
 
-                       if ( last_read != left ) {
-                               K12_DBG(1,("get_record: SHORT READ"));
-                               return -1;
-                       } else {
-                               K12_HEXDMP(5,file_offset, "GOT record", buffer, actual_len);
-                               return bytes_read;
-                       }
-               } else {
-                       bytes_read += last_read = file_read(writep,1, junky_offset, fh);
+            if ( last_read != left ) {
+                K12_DBG(1,("get_record: SHORT READ OR ERROR"));
+                *err = file_error(fh, err_info);
+                if (*err == 0) {
+                    *err = WTAP_ERR_SHORT_READ;
+                }
+                return -1;
+            } else {
+                K12_HEXDMP(5,file_offset, "GOT record", buffer, actual_len);
+                return bytes_read;
+            }
+        } else {
+            bytes_read += last_read = file_read(writep, junky_offset, fh);
 
-                       if ( last_read != junky_offset ) {
-                               K12_DBG(1,("get_record: SHORT READ, read=%d expected=%d",last_read, junky_offset));
-                               return -1;
-                       }
+            if ( last_read != junky_offset ) {
+                K12_DBG(1,("get_record: SHORT READ OR ERROR, read=%d expected=%d",last_read, junky_offset));
+                *err = file_error(fh, err_info);
+                if (*err == 0) {
+                    *err = WTAP_ERR_SHORT_READ;
+                }
+                return -1;
+            }
 
-                       writep += last_read;
+            writep += last_read;
 
-                       bytes_read += last_read = file_read(junk,1, 0x10, fh);
+            bytes_read += last_read = file_read(junk, 0x10, fh);
 
-                       if ( last_read != 0x10 ) {
-                               K12_DBG(1,("get_record: SHORT READ"));
-                               return -1;
-                       }
+            if ( last_read != 0x10 ) {
+                K12_DBG(1,("get_record: SHORT READ OR ERROR"));
+                *err = file_error(fh, err_info);
+                if (*err == 0) {
+                    *err = WTAP_ERR_SHORT_READ;
+                }
+                return -1;
+            }
 
-                       left -= junky_offset;
-                       junky_offset = 0x2000;
-               }
+            left -= junky_offset;
+            junky_offset = 0x2000;
+        }
 
-       } while(left);
+    } while(left);
 
-       K12_HEXDMP(5,file_offset, "GOT record", buffer, actual_len);
-       return bytes_read;
+    K12_HEXDMP(5,file_offset, "GOT record", buffer, actual_len);
+    return bytes_read;
 }
 
-static gboolean k12_read(wtap *wth, int *err, gchar **err_info _U_, gint64 *data_offset) {
+static gboolean 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 = NULL;
     gint64 offset;
-    long len;
+    gint len;
     guint32 type;
-       guint32 src_id;
+    guint32 src_id;
     guint64 ts;
     guint32 extra_len;
 
@@ -328,14 +414,13 @@ static gboolean k12_read(wtap *wth, int *err, gchar **err_info _U_, gint64 *data
 
     /* ignore the record if it isn't a packet */
     do {
-               K12_DBG(5,("k12_read: offset=%i",offset));
+        K12_DBG(5,("k12_read: offset=%i",offset));
 
         *data_offset = offset;
 
-        len = get_record(&buffer, wth->fh, offset);
+        len = get_record(&buffer, wth->fh, offset, err, err_info);
 
         if (len < 0) {
-            *err = WTAP_ERR_SHORT_READ;
             return FALSE;
         } else if (len == 0) {
             *err = 0;
@@ -346,16 +431,16 @@ static gboolean k12_read(wtap *wth, int *err, gchar **err_info _U_, gint64 *data
         src_id = pntohl(buffer + K12_RECORD_SRC_ID);
 
 
-        if ( ! (src_desc = g_hash_table_lookup(wth->capture.k12->src_by_id,GUINT_TO_POINTER(src_id))) ) {
-                       /*
-                        * Some records from K15 files have a port ID of an undeclared
-                        * interface which happens to be the only one with the first byte changed.
-                        * It is still unknown how to recognize when this happens.
-                        * If the lookup of the interface record fails we'll mask it
-                        * and retry.
-                        */
-                       src_desc = g_hash_table_lookup(wth->capture.k12->src_by_id,GUINT_TO_POINTER(src_id&K12_RECORD_SRC_ID_MASK));
-               }
+        if ( ! (src_desc = g_hash_table_lookup(k12->src_by_id,GUINT_TO_POINTER(src_id))) ) {
+            /*
+             * Some records from K15 files have a port ID of an undeclared
+             * interface which happens to be the only one with the first byte changed.
+             * It is still unknown how to recognize when this happens.
+             * If the lookup of the interface record fails we'll mask it
+             * and retry.
+             */
+            src_desc = g_hash_table_lookup(k12->src_by_id,GUINT_TO_POINTER(src_id&K12_RECORD_SRC_ID_MASK));
+        }
 
         K12_DBG(5,("k12_read: record type=%x src_id=%x",type,src_id));
 
@@ -380,46 +465,47 @@ static gboolean k12_read(wtap *wth, int *err, gchar **err_info _U_, gint64 *data
     memcpy(buffer_start_ptr(wth->frame_buffer), buffer + K12_PACKET_FRAME, wth->phdr.caplen);
 
     /* extra information need by some protocols */
-    buffer_assure_space(&(wth->capture.k12->extra_info), extra_len);
-    memcpy(buffer_start_ptr(&(wth->capture.k12->extra_info)),
+    buffer_assure_space(&(k12->extra_info), extra_len);
+    memcpy(buffer_start_ptr(&(k12->extra_info)),
            buffer + K12_PACKET_FRAME + wth->phdr.caplen, extra_len);
-    wth->pseudo_header.k12.extra_info = (void*)buffer_start_ptr(&(wth->capture.k12->extra_info));
+    wth->pseudo_header.k12.extra_info = (void*)buffer_start_ptr(&(k12->extra_info));
     wth->pseudo_header.k12.extra_length = extra_len;
 
     wth->pseudo_header.k12.input = src_id;
 
     K12_DBG(5,("k12_read: wth->pseudo_header.k12.input=%x wth->phdr.len=%i input_name='%s' stack_file='%s' type=%x",
-                          wth->pseudo_header.k12.input,wth->phdr.len,src_desc->input_name,src_desc->stack_file,src_desc->input_type));\
+               wth->pseudo_header.k12.input,wth->phdr.len,src_desc->input_name,src_desc->stack_file,src_desc->input_type));\
 
-       wth->pseudo_header.k12.input_name = src_desc->input_name;
-       wth->pseudo_header.k12.stack_file = src_desc->stack_file;
-       wth->pseudo_header.k12.input_type = src_desc->input_type;
+    wth->pseudo_header.k12.input_name = src_desc->input_name;
+    wth->pseudo_header.k12.stack_file = src_desc->stack_file;
+    wth->pseudo_header.k12.input_type = src_desc->input_type;
 
-       switch(src_desc->input_type) {
-               case K12_PORT_ATMPVC:
-               if ((long)(K12_PACKET_FRAME + wth->phdr.len + K12_PACKET_OFFSET_CID) < len) {
-                       wth->pseudo_header.k12.input_info.atm.vp =  pntohs(buffer + (K12_PACKET_FRAME + wth->phdr.caplen + K12_PACKET_OFFSET_VP));
-                       wth->pseudo_header.k12.input_info.atm.vc =  pntohs(buffer + (K12_PACKET_FRAME + wth->phdr.caplen + K12_PACKET_OFFSET_VC));
-                       wth->pseudo_header.k12.input_info.atm.cid =  *((unsigned char*)(buffer + K12_PACKET_FRAME + wth->phdr.len + K12_PACKET_OFFSET_CID));
-                       break;
-               }
-               /* Fall through */
-               default:
-               memcpy(&(wth->pseudo_header.k12.input_info),&(src_desc->input_info),sizeof(src_desc->input_info));
-               break;
+    switch(src_desc->input_type) {
+        case K12_PORT_ATMPVC:
+        if ((long)(K12_PACKET_FRAME + wth->phdr.len + K12_PACKET_OFFSET_CID) < len) {
+            wth->pseudo_header.k12.input_info.atm.vp =  pntohs(buffer + (K12_PACKET_FRAME + wth->phdr.caplen + K12_PACKET_OFFSET_VP));
+            wth->pseudo_header.k12.input_info.atm.vc =  pntohs(buffer + (K12_PACKET_FRAME + wth->phdr.caplen + K12_PACKET_OFFSET_VC));
+            wth->pseudo_header.k12.input_info.atm.cid =  *((unsigned char*)(buffer + K12_PACKET_FRAME + wth->phdr.len + K12_PACKET_OFFSET_CID));
+            break;
+        }
+        /* Fall through */
+        default:
+        memcpy(&(wth->pseudo_header.k12.input_info),&(src_desc->input_info),sizeof(src_desc->input_info));
+        break;
 
-       }
+    }
 
-    wth->pseudo_header.k12.stuff = wth->capture.k12;
+    wth->pseudo_header.k12.stuff = k12;
 
     return TRUE;
 }
 
 
-static gboolean k12_seek_read(wtap *wth, gint64 seek_off, union wtap_pseudo_header *pseudo_header, guchar *pd, int length, int *err _U_, gchar **err_info _U_) {
+static gboolean k12_seek_read(wtap *wth, gint64 seek_off, union wtap_pseudo_header *pseudo_header, guint8 *pd, int length, int *err _U_, gchar **err_info) {
+    k12_t *k12 = (k12_t *)wth->priv;
     k12_src_desc_t* src_desc;
     guint8* buffer;
-    long len;
+    gint len;
     guint32 extra_len;
     guint32 input;
 
@@ -430,37 +516,43 @@ static gboolean k12_seek_read(wtap *wth, gint64 seek_off, union wtap_pseudo_head
         return FALSE;
     }
 
-    if ((len = get_record(&buffer, wth->random_fh, seek_off)) < 1) {
+    len = get_record(&buffer, wth->random_fh, seek_off, err, err_info);
+    if (len < 0) {
         K12_DBG(5,("k12_seek_read: READ ERROR"));
         return FALSE;
     }
+    if (len < 1) {
+        K12_DBG(5,("k12_seek_read: SHORT READ"));
+        *err = WTAP_ERR_SHORT_READ;
+        return FALSE;
+    }
 
     memcpy(pd, buffer + K12_PACKET_FRAME, length);
 
     extra_len = len - K12_PACKET_FRAME - length;
-    buffer_assure_space(&(wth->capture.k12->extra_info), extra_len);
-    memcpy(buffer_start_ptr(&(wth->capture.k12->extra_info)),
+    buffer_assure_space(&(k12->extra_info), extra_len);
+    memcpy(buffer_start_ptr(&(k12->extra_info)),
            buffer + K12_PACKET_FRAME + length, extra_len);
-    wth->pseudo_header.k12.extra_info = (void*)buffer_start_ptr(&(wth->capture.k12->extra_info));
+    wth->pseudo_header.k12.extra_info = (void*)buffer_start_ptr(&(k12->extra_info));
     wth->pseudo_header.k12.extra_length = extra_len;
     if (pseudo_header) {
-        pseudo_header->k12.extra_info = (void*)buffer_start_ptr(&(wth->capture.k12->extra_info));
+        pseudo_header->k12.extra_info = (void*)buffer_start_ptr(&(k12->extra_info));
         pseudo_header->k12.extra_length = extra_len;
     }
 
     input = pntohl(buffer + K12_RECORD_SRC_ID);
     K12_DBG(5,("k12_seek_read: input=%.8x",input));
 
-       if ( ! (src_desc = g_hash_table_lookup(wth->capture.k12->src_by_id,GUINT_TO_POINTER(input))) ) {
-               /*
-                * Some records from K15 files have a port ID of an undeclared
-                * interface which happens to be the only one with the first byte changed.
-                * It is still unknown how to recognize when this happens.
-                * If the lookup of the interface record fails we'll mask it
-                * and retry.
-                */
-               src_desc = g_hash_table_lookup(wth->capture.k12->src_by_id,GUINT_TO_POINTER(input&K12_RECORD_SRC_ID_MASK));
-       }
+    if ( ! (src_desc = g_hash_table_lookup(k12->src_by_id,GUINT_TO_POINTER(input))) ) {
+        /*
+         * Some records from K15 files have a port ID of an undeclared
+         * interface which happens to be the only one with the first byte changed.
+         * It is still unknown how to recognize when this happens.
+         * If the lookup of the interface record fails we'll mask it
+         * and retry.
+         */
+        src_desc = g_hash_table_lookup(k12->src_by_id,GUINT_TO_POINTER(input&K12_RECORD_SRC_ID_MASK));
+    }
 
     if (src_desc) {
         K12_DBG(5,("k12_seek_read: input_name='%s' stack_file='%s' type=%x",src_desc->input_name,src_desc->stack_file,src_desc->input_type));
@@ -519,11 +611,11 @@ static gboolean k12_seek_read(wtap *wth, gint64 seek_off, union wtap_pseudo_head
 
     if (pseudo_header) {
         pseudo_header->k12.input = input;
-        pseudo_header->k12.stuff = wth->capture.k12;
+        pseudo_header->k12.stuff = k12;
     }
 
     wth->pseudo_header.k12.input = input;
-    wth->pseudo_header.k12.stuff = wth->capture.k12;
+    wth->pseudo_header.k12.stuff = k12;
 
     K12_DBG(5,("k12_seek_read: DONE OK"));
 
@@ -563,7 +655,10 @@ static void destroy_k12_file_data(k12_t* fd) {
 }
 
 static void k12_close(wtap *wth) {
-    destroy_k12_file_data(wth->capture.k12);
+    k12_t *k12 = (k12_t *)wth->priv;
+
+    destroy_k12_file_data(k12);
+    wth->priv = NULL;  /* destroy_k12_file_data freed it */
 #ifdef DEBUG_K12
     K12_DBG(5,("k12_close: CLOSED"));
     if (env_file) fclose(dbg_out);
@@ -571,7 +666,7 @@ static void k12_close(wtap *wth) {
 }
 
 
-int k12_open(wtap *wth, int *err, gchar **err_info _U_) {
+int k12_open(wtap *wth, int *err, gchar **err_info) {
     k12_src_desc_t* rec;
     guint8 header_buffer[0x200];
     guint8* read_buffer;
@@ -594,8 +689,12 @@ int k12_open(wtap *wth, int *err, gchar **err_info _U_) {
     K12_DBG(1,("k12_open: ENTER debug_level=%u",debug_level));
 #endif
 
-    if ( file_read(header_buffer,1,0x200,wth->fh) != 0x200 ) {
-        K12_DBG(1,("k12_open: FILE HEADER TOO SHORT"));
+    if ( file_read(header_buffer,0x200,wth->fh) != 0x200 ) {
+        K12_DBG(1,("k12_open: FILE HEADER TOO SHORT OR READ ERROR"));
+        *err = file_error(wth->fh, err_info);
+        if (*err != 0) {
+            return -1;
+        }
         return 0;
     } else {
         if ( memcmp(header_buffer,k12_file_magic,8) != 0 ) {
@@ -618,10 +717,19 @@ int k12_open(wtap *wth, int *err, gchar **err_info _U_) {
 
     do {
 
-        len = get_record(&read_buffer, wth->fh, offset);
+        len = get_record(&read_buffer, wth->fh, offset, err, err_info);
 
-        if ( len <= 0 ) {
+        if ( len < 0 ) {
             K12_DBG(1,("k12_open: BAD HEADER RECORD",len));
+            destroy_k12_file_data(file_data);
+            g_free(file_data);
+            return -1;
+        }
+        if (len == 0) {
+            K12_DBG(1,("k12_open: BAD HEADER RECORD",len));
+            *err = WTAP_ERR_SHORT_READ;
+            destroy_k12_file_data(file_data);
+            g_free(file_data);
             return -1;
         }
 
@@ -634,6 +742,7 @@ int k12_open(wtap *wth, int *err, gchar **err_info _U_) {
              */
             if (file_seek(wth->fh, offset, SEEK_SET, err) == -1) {
                 destroy_k12_file_data(file_data);
+                g_free(file_data);
                 return -1;
             }
             K12_DBG(5,("k12_open: FIRST PACKET offset=%x",offset));
@@ -655,6 +764,8 @@ int k12_open(wtap *wth, int *err, gchar **err_info _U_) {
                 g_free(rec);
                 K12_DBG(5,("k12_open: failed (name_len == 0 || stack_len == 0 "
                         "|| 0x20 + extra_len + name_len + stack_len > rec_len)  extra_len=%i name_len=%i stack_len=%i"));
+                destroy_k12_file_data(file_data);
+                g_free(file_data);
                 return 0;
             }
 
@@ -667,7 +778,7 @@ int k12_open(wtap *wth, int *err, gchar **err_info _U_) {
                             rec->input_info.ds0mask |= ( *(read_buffer + K12_SRCDESC_DS0_MASK + i) == 0xff ) ? 0x1<<(31-i) : 0x0;
                         }
 
-                            break;
+                        break;
                     case K12_PORT_ATMPVC:
                         rec->input_info.atm.vp = pntohs( read_buffer + K12_SRCDESC_ATM_VPI );
                         rec->input_info.atm.vc = pntohs( read_buffer + K12_SRCDESC_ATM_VCI );
@@ -686,7 +797,10 @@ int k12_open(wtap *wth, int *err, gchar **err_info _U_) {
 
             /* XXX - this is assumed, in a number of places (not just in the
                ascii_strdown_inplace() call below) to be null-terminated;
-               is that guaranteed (even with a corrupt file)? */
+               is that guaranteed (even with a corrupt file)?
+              Obviously not, as a corrupt file could contain anything
+              here; the Tektronix document says the strings "must end
+              with \0", but a bad file could fail to add the \0. */
             rec->input_name = g_memdup(read_buffer + K12_SRCDESC_EXTRATYPE + extra_len, name_len);
             rec->stack_file = g_memdup(read_buffer + K12_SRCDESC_EXTRATYPE + extra_len + name_len, stack_len);
 
@@ -710,12 +824,18 @@ int k12_open(wtap *wth, int *err, gchar **err_info _U_) {
     wth->subtype_read = k12_read;
     wth->subtype_seek_read = k12_seek_read;
     wth->subtype_close = k12_close;
-    wth->capture.k12 = file_data;
+    wth->priv = (void *)file_data;
     wth->tsprecision = WTAP_FILE_TSPREC_NSEC;
 
     return 1;
 }
 
+typedef struct {
+       guint32 file_len;
+       guint32 num_of_records;
+       guint32 file_offset;
+} k12_dump_t;
+
 int k12_dump_can_write_encap(int encap) {
 
     if (encap == WTAP_ENCAP_PER_PACKET)
@@ -729,42 +849,29 @@ int k12_dump_can_write_encap(int encap) {
 
 static const gchar dumpy_junk[] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
 
-static gboolean do_fwrite(const void *data, size_t size, size_t count, FILE *stream, int *err_p) {
-    size_t nwritten;
-
-    nwritten = fwrite(data, size, count, stream);
-    if (nwritten != count) {
-        if (nwritten == 0 && ferror(stream))
-            *err_p = errno;
-        else
-            *err_p = WTAP_ERR_SHORT_WRITE;
-        return FALSE;
-    }
-    return TRUE;
-}
-
-static gboolean k12_dump_record(wtap_dumper *wdh, long len,  guint8* buffer, int *err_p) {
-    long junky_offset = (0x2000 - ( (wdh->dump.k12->file_offset - 0x200) % 0x2000 )) % 0x2000;
+static gboolean k12_dump_record(wtap_dumper *wdh, guint32 len,  guint8* buffer, int *err_p) {
+    k12_dump_t *k12 = (k12_dump_t *)wdh->priv;
+    guint32 junky_offset = (0x2000 - ( (k12->file_offset - 0x200) % 0x2000 )) % 0x2000;
 
     if (len > junky_offset) {
         if (junky_offset) {
-            if (! do_fwrite(buffer, 1, junky_offset, wdh->fh, err_p))
+            if (! wtap_dump_file_write(wdh, buffer, junky_offset, err_p))
                 return FALSE;
         }
-        if (! do_fwrite(dumpy_junk, 1, 0x10, wdh->fh, err_p))
+        if (! wtap_dump_file_write(wdh, dumpy_junk, 0x10, err_p))
             return FALSE;
 
-        if (! do_fwrite(buffer+junky_offset, 1, len - junky_offset, wdh->fh, err_p))
+        if (! wtap_dump_file_write(wdh, buffer+junky_offset, len - junky_offset, err_p))
             return FALSE;
 
-        wdh->dump.k12->file_offset += len + 0x10;
+        k12->file_offset += len + 0x10;
     } else {
-        if (! do_fwrite(buffer, 1, len, wdh->fh, err_p))
+        if (! wtap_dump_file_write(wdh, buffer, len, err_p))
             return FALSE;
-        wdh->dump.k12->file_offset += len;
+        k12->file_offset += len;
     }
 
-    wdh->dump.k12->num_of_records++;
+    k12->num_of_records++;
     return TRUE;
 }
 
@@ -878,8 +985,9 @@ static void k12_dump_src_setting(gpointer k _U_, gpointer v, gpointer p) {
 
 static gboolean k12_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
                          const union wtap_pseudo_header *pseudo_header,
-                         const guchar *pd, int *err) {
-    long len;
+                         const guint8 *pd, int *err) {
+    k12_dump_t *k12 = (k12_dump_t *)wdh->priv;
+    guint32 len;
     union {
         guint8 buffer[0x2000];
         struct {
@@ -896,7 +1004,7 @@ static gboolean k12_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
         } record;
     } obj;
 
-    if (wdh->dump.k12->num_of_records == 0) {
+    if (k12->num_of_records == 0) {
         k12_t* file_data = pseudo_header->k12.stuff;
         /* XXX: We'll assume that any fwrite errors in k12_dump_src_setting will    */
         /*      repeat during the final k12_dump_record at the end of k12_dump      */
@@ -926,12 +1034,13 @@ static gboolean k12_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
 static const guint8 k12_eof[] = {0xff,0xff};
 
 static gboolean k12_dump_close(wtap_dumper *wdh, int *err) {
+    k12_dump_t *k12 = (k12_dump_t *)wdh->priv;
     union {
         guint8 b[sizeof(guint32)];
         guint32 u;
     } d;
 
-    if (! do_fwrite(k12_eof, 1, 2, wdh->fh, err))
+    if (! wtap_dump_file_write(wdh, k12_eof, 2, err))
         return FALSE;
 
     if (fseek(wdh->fh, 8, SEEK_SET) == -1) {
@@ -939,28 +1048,24 @@ static gboolean k12_dump_close(wtap_dumper *wdh, int *err) {
         return FALSE;
     }
 
-    d.u = g_htonl(wdh->dump.k12->file_len);
+    d.u = g_htonl(k12->file_len);
 
-    if (! do_fwrite(d.b, 1, 4, wdh->fh, err))
+    if (! wtap_dump_file_write(wdh, d.b, 4, err))
         return FALSE;
 
-    d.u = g_htonl(wdh->dump.k12->num_of_records);
+    d.u = g_htonl(k12->num_of_records);
 
-    if (! do_fwrite(d.b, 1, 4, wdh->fh, err))
+    if (! wtap_dump_file_write(wdh, d.b, 4, err))
         return FALSE;
 
     return TRUE;
 }
 
 
-gboolean k12_dump_open(wtap_dumper *wdh, gboolean cant_seek, int *err) {
-
-    if (cant_seek) {
-        *err = WTAP_ERR_CANT_WRITE_TO_PIPE;
-        return FALSE;
-    }
+gboolean k12_dump_open(wtap_dumper *wdh, int *err) {
+    k12_dump_t *k12;
 
-    if ( ! do_fwrite(k12_file_magic, 1, 8, wdh->fh, err)) {
+    if ( ! wtap_dump_file_write(wdh, k12_file_magic, 8, err)) {
         return FALSE;
     }
 
@@ -972,10 +1077,11 @@ gboolean k12_dump_open(wtap_dumper *wdh, gboolean cant_seek, int *err) {
     wdh->subtype_write = k12_dump;
     wdh->subtype_close = k12_dump_close;
 
-    wdh->dump.k12 = g_malloc(sizeof(k12_dump_t));
-    wdh->dump.k12->file_len = 0x200;
-    wdh->dump.k12->num_of_records = 0;
-    wdh->dump.k12->file_offset  = 0x200;
+    k12 = (k12_dump_t *)g_malloc(sizeof(k12_dump_t));
+    wdh->priv = (void *)k12;
+    k12->file_len = 0x200;
+    k12->num_of_records = 0;
+    k12->file_offset  = 0x200;
 
     return TRUE;
 }