Generalize wtap_pkthdr into a structure for packet and non-packet records.

Separate the stuff that any record could have from the stuff that only
particular record types have; put the latter into a union, and put all
that into a wtap_rec structure.

Add some record-type checks as necessary.

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

1 files changed, 31 insertions, 31 deletions

diff --git a/wiretap/k12.c b/wiretap/k12.c
index 784bb6734c..d84fec7646 100644
--- a/wiretap/k12.c
+++ b/wiretap/k12.c
@@ -562,7 +562,7 @@ memiszero(const void *ptr, size_t count)
 }
 
 static gboolean
-process_packet_data(struct wtap_pkthdr *phdr, Buffer *target, guint8 *buffer,
+process_packet_data(wtap_rec *rec, Buffer *target, guint8 *buffer,
                     guint record_len, k12_t *k12, int *err, gchar **err_info)
 {
     guint32 type;
@@ -590,15 +590,15 @@ process_packet_data(struct wtap_pkthdr *phdr, Buffer *target, guint8 *buffer,
         return FALSE;
     }
 
-    phdr->rec_type = REC_TYPE_PACKET;
-    phdr->presence_flags = WTAP_HAS_TS;
+    rec->rec_type = REC_TYPE_PACKET;
+    rec->presence_flags = WTAP_HAS_TS;
 
     ts = pntoh64(buffer + K12_PACKET_TIMESTAMP);
 
-    phdr->ts.secs = (guint32) ((ts / 2000000) + 631152000);
-    phdr->ts.nsecs = (guint32) ( (ts % 2000000) * 500 );
+    rec->ts.secs = (guint32) ((ts / 2000000) + 631152000);
+    rec->ts.nsecs = (guint32) ( (ts % 2000000) * 500 );
 
-    phdr->len = phdr->caplen = length;
+    rec->rec_header.packet_header.len = rec->rec_header.packet_header.caplen = length;
 
     ws_buffer_assure_space(target, length);
     memcpy(ws_buffer_start_ptr(target), buffer + buffer_offset, length);
@@ -608,12 +608,12 @@ process_packet_data(struct wtap_pkthdr *phdr, Buffer *target, guint8 *buffer,
     ws_buffer_assure_space(&(k12->extra_info), extra_len);
     memcpy(ws_buffer_start_ptr(&(k12->extra_info)),
            buffer + buffer_offset + length, extra_len);
-    phdr->pseudo_header.k12.extra_info = (guint8*)ws_buffer_start_ptr(&(k12->extra_info));
-    phdr->pseudo_header.k12.extra_length = extra_len;
+    rec->rec_header.packet_header.pseudo_header.k12.extra_info = (guint8*)ws_buffer_start_ptr(&(k12->extra_info));
+    rec->rec_header.packet_header.pseudo_header.k12.extra_length = extra_len;
 
     src_id = pntoh32(buffer + K12_RECORD_SRC_ID);
     K12_DBG(5,("process_packet_data: src_id=%.8x",src_id));
-    phdr->pseudo_header.k12.input = src_id;
+    rec->rec_header.packet_header.pseudo_header.k12.input = src_id;
 
     if ( ! (src_desc = (k12_src_desc_t*)g_hash_table_lookup(k12->src_by_id,GUINT_TO_POINTER(src_id))) ) {
         /*
@@ -628,33 +628,33 @@ process_packet_data(struct wtap_pkthdr *phdr, Buffer *target, guint8 *buffer,
 
     if (src_desc) {
         K12_DBG(5,("process_packet_data: input_name='%s' stack_file='%s' type=%x",src_desc->input_name,src_desc->stack_file,src_desc->input_type));
-        phdr->pseudo_header.k12.input_name = src_desc->input_name;
-        phdr->pseudo_header.k12.stack_file = src_desc->stack_file;
-        phdr->pseudo_header.k12.input_type = src_desc->input_type;
+        rec->rec_header.packet_header.pseudo_header.k12.input_name = src_desc->input_name;
+        rec->rec_header.packet_header.pseudo_header.k12.stack_file = src_desc->stack_file;
+        rec->rec_header.packet_header.pseudo_header.k12.input_type = src_desc->input_type;
 
         switch(src_desc->input_type) {
             case K12_PORT_ATMPVC:
                 if (buffer_offset + length + K12_PACKET_OFFSET_CID < record_len) {
-                    phdr->pseudo_header.k12.input_info.atm.vp =  pntoh16(buffer + buffer_offset + length + K12_PACKET_OFFSET_VP);
-                    phdr->pseudo_header.k12.input_info.atm.vc =  pntoh16(buffer + buffer_offset + length + K12_PACKET_OFFSET_VC);
-                    phdr->pseudo_header.k12.input_info.atm.cid =  *((unsigned char*)(buffer + buffer_offset + length + K12_PACKET_OFFSET_CID));
+                    rec->rec_header.packet_header.pseudo_header.k12.input_info.atm.vp =  pntoh16(buffer + buffer_offset + length + K12_PACKET_OFFSET_VP);
+                    rec->rec_header.packet_header.pseudo_header.k12.input_info.atm.vc =  pntoh16(buffer + buffer_offset + length + K12_PACKET_OFFSET_VC);
+                    rec->rec_header.packet_header.pseudo_header.k12.input_info.atm.cid =  *((unsigned char*)(buffer + buffer_offset + length + K12_PACKET_OFFSET_CID));
                     break;
                 }
                 /* Fall through */
             default:
-                memcpy(&(phdr->pseudo_header.k12.input_info),&(src_desc->input_info),sizeof(src_desc->input_info));
+                memcpy(&(rec->rec_header.packet_header.pseudo_header.k12.input_info),&(src_desc->input_info),sizeof(src_desc->input_info));
                 break;
         }
     } else {
         K12_DBG(5,("process_packet_data: NO SRC_RECORD FOUND"));
 
-        memset(&(phdr->pseudo_header.k12),0,sizeof(phdr->pseudo_header.k12));
-        phdr->pseudo_header.k12.input_name = "unknown port";
-        phdr->pseudo_header.k12.stack_file = "unknown stack file";
+        memset(&(rec->rec_header.packet_header.pseudo_header.k12),0,sizeof(rec->rec_header.packet_header.pseudo_header.k12));
+        rec->rec_header.packet_header.pseudo_header.k12.input_name = "unknown port";
+        rec->rec_header.packet_header.pseudo_header.k12.stack_file = "unknown stack file";
     }
 
-    phdr->pseudo_header.k12.input = src_id;
-    phdr->pseudo_header.k12.stuff = k12;
+    rec->rec_header.packet_header.pseudo_header.k12.input = src_id;
+    rec->rec_header.packet_header.pseudo_header.k12.stuff = k12;
     return TRUE;
 }
 
@@ -721,11 +721,11 @@ static gboolean k12_read(wtap *wth, int *err, gchar **err_info, gint64 *data_off
 
     } while ( ((type & K12_MASK_PACKET) != K12_REC_PACKET && (type & K12_MASK_PACKET) != K12_REC_D0020) || !src_id || !src_desc );
 
-    return process_packet_data(&wth->phdr, wth->frame_buffer, buffer, (guint)len, k12, err, err_info);
+    return process_packet_data(&wth->rec, wth->rec_data, buffer, (guint)len, k12, err, err_info);
 }
 
 
-static gboolean k12_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info) {
+static gboolean k12_seek_read(wtap *wth, gint64 seek_off, wtap_rec *rec, Buffer *buf, int *err, gchar **err_info) {
     k12_t *k12 = (k12_t *)wth->priv;
     guint8* buffer;
     gint len;
@@ -751,7 +751,7 @@ static gboolean k12_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *ph
 
     buffer = k12->rand_read_buff;
 
-    status = process_packet_data(phdr, buf, buffer, (guint)len, k12, err, err_info);
+    status = process_packet_data(rec, buf, buffer, (guint)len, k12, err, err_info);
 
     K12_DBG(5,("k12_seek_read: DONE OK"));
 
@@ -1247,9 +1247,9 @@ static void k12_dump_src_setting(gpointer k _U_, gpointer v, gpointer p) {
     k12_dump_record(wdh,len,obj.buffer, &errxxx); /* fwrite errs ignored: see k12_dump below */
 }
 
-static gboolean k12_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
+static gboolean k12_dump(wtap_dumper *wdh, const wtap_rec *rec,
                          const guint8 *pd, int *err, gchar **err_info _U_) {
-    const union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header;
+    const union wtap_pseudo_header *pseudo_header = &rec->rec_header.packet_header.pseudo_header;
     k12_dump_t *k12 = (k12_dump_t *)wdh->priv;
     guint32 len;
     union {
@@ -1269,7 +1269,7 @@ static gboolean k12_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
     } obj;
 
     /* We can only write packet records. */
-    if (phdr->rec_type != REC_TYPE_PACKET) {
+    if (rec->rec_type != REC_TYPE_PACKET) {
         *err = WTAP_ERR_UNWRITABLE_REC_TYPE;
         return FALSE;
     }
@@ -1283,7 +1283,7 @@ static gboolean k12_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
         /*       encountered in k12_dump_src_setting).                              */
         g_hash_table_foreach(file_data->src_by_id,k12_dump_src_setting,wdh);
     }
-    obj.record.len = 0x20 + phdr->caplen;
+    obj.record.len = 0x20 + rec->rec_header.packet_header.caplen;
     obj.record.len += (obj.record.len % 4) ? 4 - obj.record.len % 4 : 0;
 
     len = obj.record.len;
@@ -1291,12 +1291,12 @@ static gboolean k12_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
     obj.record.len = g_htonl(obj.record.len);
 
     obj.record.type = g_htonl(K12_REC_PACKET);
-    obj.record.frame_len = g_htonl(phdr->caplen);
+    obj.record.frame_len = g_htonl(rec->rec_header.packet_header.caplen);
     obj.record.input = g_htonl(pseudo_header->k12.input);
 
-    obj.record.ts = GUINT64_TO_BE((((guint64)phdr->ts.secs - 631152000) * 2000000) + (phdr->ts.nsecs / 1000 * 2));
+    obj.record.ts = GUINT64_TO_BE((((guint64)rec->ts.secs - 631152000) * 2000000) + (rec->ts.nsecs / 1000 * 2));
 
-    memcpy(obj.record.frame,pd,phdr->caplen);
+    memcpy(obj.record.frame,pd,rec->rec_header.packet_header.caplen);
 
     return k12_dump_record(wdh,len,obj.buffer, err);
 }