Use guint8 rather than guchar for raw octets and pointers to arrays of
authorGuy Harris <guy@alum.mit.edu>
Thu, 1 Sep 2011 09:43:10 +0000 (09:43 -0000)
committerGuy Harris <guy@alum.mit.edu>
Thu, 1 Sep 2011 09:43:10 +0000 (09:43 -0000)
same.

Add to wiretap/pcap-common.c a routine to fill in the pseudo-header for
ATM (by looking at the VPI, VCI, and packet data, and guessing) and
Ethernet (setting the FCS length appropriately).  Use it for both pcap
and pcap-ng files.

svn path=/trunk/; revision=38840

36 files changed:
wiretap/5views.c
wiretap/airopeek9.c
wiretap/btsnoop.c
wiretap/buffer.c
wiretap/buffer.h
wiretap/catapult_dct2000.c
wiretap/commview.c
wiretap/daintree-sna.c
wiretap/erf.c
wiretap/etherpeek.c
wiretap/eyesdn.c
wiretap/file_access.c
wiretap/i4btrace.c
wiretap/ipfix.c
wiretap/iptrace.c
wiretap/k12.c
wiretap/k12text.l
wiretap/lanalyzer.c
wiretap/libpcap.c
wiretap/mime_file.c
wiretap/mpeg.c
wiretap/netmon.c
wiretap/netscaler.c
wiretap/nettl.c
wiretap/network_instruments.c
wiretap/netxray.c
wiretap/ngsniffer.c
wiretap/packetlogger.c
wiretap/pcap-common.c
wiretap/pcap-common.h
wiretap/pcapng.c
wiretap/radcom.c
wiretap/snoop.c
wiretap/visual.c
wiretap/wtap-int.h
wiretap/wtap.h

index 729c478caf33dc188c3895aae7dfdb5bfe5775db..2e3011904d965b8b42783be4c8d4760deb8c2089 100644 (file)
@@ -105,17 +105,17 @@ typedef struct
 
 static gboolean _5views_read(wtap *wth, int *err, gchar **err_info,
     gint64 *data_offset);
-static gboolean _5views_read_rec_data(FILE_T fh, guchar *pd, int length,
+static gboolean _5views_read_rec_data(FILE_T fh, guint8 *pd, int length,
     int *err, gchar **err_info);
 static int _5views_read_header(wtap *wth, FILE_T fh,
     t_5VW_TimeStamped_Header  *hdr, int *err, gchar **err_info);
 static gboolean _5views_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info);
 
 
 static gboolean _5views_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
-                                                        const union wtap_pseudo_header *pseudo_header, const guchar *pd, int *err);
+                                                        const union wtap_pseudo_header *pseudo_header, const guint8 *pd, int *err);
 static gboolean _5views_dump_close(wtap_dumper *wdh, int *err);
 
 
@@ -271,7 +271,7 @@ _5views_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
 
 
 static gboolean
-_5views_read_rec_data(FILE_T fh, guchar *pd, int length, int *err,
+_5views_read_rec_data(FILE_T fh, guint8 *pd, int length, int *err,
    gchar **err_info)
 {
        int     bytes_read;
@@ -316,7 +316,7 @@ _5views_read_header(wtap *wth _U_, FILE_T fh, t_5VW_TimeStamped_Header  *hdr,
 
 static gboolean
 _5views_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info)
 {
        if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
@@ -406,7 +406,7 @@ gboolean _5views_dump_open(wtap_dumper *wdh, int *err)
 static gboolean _5views_dump(wtap_dumper *wdh,
        const struct wtap_pkthdr *phdr,
        const union wtap_pseudo_header *pseudo_header _U_,
-       const guchar *pd, int *err)
+       const guint8 *pd, int *err)
 {
        _5views_dump_t *_5views = (_5views_dump_t *)wdh->priv;
        static t_5VW_TimeStamped_Header HeaderFrame;
index 687d14eccc0ab469b5bd9525980fe4ff6b5479a9..63130845edd05a06aa3cecf015903ef72fa7efd2 100644 (file)
@@ -91,7 +91,7 @@ typedef struct {
 static gboolean airopeekv9_read(wtap *wth, int *err, gchar **err_info,
     gint64 *data_offset);
 static gboolean airopeekv9_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info);
 
 static int wtap_file_read_pattern (wtap *wth, const char *pattern, int *err,
@@ -564,7 +564,7 @@ static gboolean airopeekv9_read(wtap *wth, int *err, gchar **err_info,
 
 static gboolean
 airopeekv9_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info)
 {
     airopeek9_t *airopeek9 = (airopeek9_t *)wth->priv;
index 52f232646f95f1535e03552ba16433bae5676932..374ea83db507ca5811e6320d131c2d706806f5c4 100644 (file)
@@ -76,9 +76,9 @@ const gint64 KUnixTimeBase = G_GINT64_CONSTANT(0x00dcddb30f2f8000); /* offset fr
 static gboolean btsnoop_read(wtap *wth, int *err, gchar **err_info,
     gint64 *data_offset);
 static gboolean btsnoop_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info);
-static gboolean snoop_read_rec_data(FILE_T fh, guchar *pd, int length, int *err,
+static gboolean snoop_read_rec_data(FILE_T fh, guint8 *pd, int length, int *err,
     gchar **err_info);
 
 int btsnoop_open(wtap *wth, int *err, gchar **err_info)
@@ -237,7 +237,7 @@ static gboolean btsnoop_read(wtap *wth, int *err, gchar **err_info,
 }
 
 static gboolean btsnoop_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info) {
        int     bytes_read;
        struct btsnooprec_hdr hdr;
@@ -289,7 +289,7 @@ static gboolean btsnoop_seek_read(wtap *wth, gint64 seek_off,
 }
 
 static gboolean
-snoop_read_rec_data(FILE_T fh, guchar *pd, int length, int *err,
+snoop_read_rec_data(FILE_T fh, guint8 *pd, int length, int *err,
     gchar **err_info)
 {
        int     bytes_read;
@@ -355,7 +355,7 @@ static guint8 btsnoop_lookup_flags(guint8 hci_type, gboolean sent, guint8 *flags
 static gboolean btsnoop_dump_partial_rec_hdr(wtap_dumper *wdh _U_,
     const struct wtap_pkthdr *phdr,
     const union wtap_pseudo_header *pseudo_header,
-    const guchar *pd, int *err,
+    const guint8 *pd, int *err,
     struct btsnooprec_hdr *rec_hdr)
 {
     gint64 ts_usec;
@@ -380,7 +380,7 @@ static gboolean btsnoop_dump_partial_rec_hdr(wtap_dumper *wdh _U_,
 static gboolean btsnoop_dump_h1(wtap_dumper *wdh,
     const struct wtap_pkthdr *phdr,
     const union wtap_pseudo_header *pseudo_header,
-    const guchar *pd, int *err)
+    const guint8 *pd, int *err)
 {
     struct btsnooprec_hdr rec_hdr;
 
@@ -409,7 +409,7 @@ static gboolean btsnoop_dump_h1(wtap_dumper *wdh,
 static gboolean btsnoop_dump_h4(wtap_dumper *wdh,
     const struct wtap_pkthdr *phdr,
     const union wtap_pseudo_header *pseudo_header,
-    const guchar *pd, int *err)
+    const guint8 *pd, int *err)
 {
     struct btsnooprec_hdr rec_hdr;
 
index eae751cbd7bbb3fc9eda942cc449362b900877e7..bd5a94e3a665e7d16328351967c7dc46bdcf9c4a 100644 (file)
@@ -34,7 +34,7 @@
 /* Initializes a buffer with a certain amount of allocated space */
 void buffer_init(Buffer* buffer, gsize space)
 {
-       buffer->data = (guchar*)g_malloc(space);
+       buffer->data = (guint8*)g_malloc(space);
        buffer->allocated = space;
        buffer->start = 0;
        buffer->first_free = 0;
@@ -84,10 +84,10 @@ void buffer_assure_space(Buffer* buffer, gsize space)
 
        /* We'll allocate more space */
        buffer->allocated += space + 1024;
-       buffer->data = (guchar*)g_realloc(buffer->data, buffer->allocated);
+       buffer->data = (guint8*)g_realloc(buffer->data, buffer->allocated);
 }
 
-void buffer_append(Buffer* buffer, guchar *from, gsize bytes)
+void buffer_append(Buffer* buffer, guint8 *from, gsize bytes)
 {
        buffer_assure_space(buffer, bytes);
        memcpy(buffer->data + buffer->first_free, from, bytes);
@@ -133,14 +133,14 @@ gsize buffer_length(Buffer* buffer)
 #endif
 
 #ifndef SOME_FUNCTIONS_ARE_DEFINES
-guchar* buffer_start_ptr(Buffer* buffer)
+guint8* buffer_start_ptr(Buffer* buffer)
 {
        return buffer->data + buffer->start;
 }
 #endif
 
 #ifndef SOME_FUNCTIONS_ARE_DEFINES
-guchar* buffer_end_ptr(Buffer* buffer)
+guint8* buffer_end_ptr(Buffer* buffer)
 {
        return buffer->data + buffer->first_free;
 }
index 77c4f836ad20726809d0a40a1964fb8abb05d4db..c077a228c494a8fc1d6f3f54eeec27e44ea13947 100644 (file)
@@ -28,7 +28,7 @@
 #define SOME_FUNCTIONS_ARE_DEFINES
 
 typedef struct Buffer {
-       guchar  *data;
+       guint8  *data;
        gsize   allocated;
        gsize   start;
        gsize   first_free;
@@ -37,7 +37,7 @@ typedef struct Buffer {
 void buffer_init(Buffer* buffer, gsize space);
 void buffer_free(Buffer* buffer);
 void buffer_assure_space(Buffer* buffer, gsize space);
-void buffer_append(Buffer* buffer, guchar *from, gsize bytes);
+void buffer_append(Buffer* buffer, guint8 *from, gsize bytes);
 void buffer_remove_start(Buffer* buffer, gsize bytes);
 
 #ifdef SOME_FUNCTIONS_ARE_DEFINES
@@ -51,8 +51,8 @@ void buffer_remove_start(Buffer* buffer, gsize bytes);
  void buffer_clean(Buffer* buffer);
  void buffer_increase_length(Buffer* buffer, unsigned int bytes);
  unsigned int buffer_length(Buffer* buffer);
- guchar* buffer_start_ptr(Buffer* buffer);
- guchar* buffer_end_ptr(Buffer* buffer);
+ guint8* buffer_start_ptr(Buffer* buffer);
+ guint8* buffer_end_ptr(Buffer* buffer);
  void buffer_append_buffer(Buffer* buffer, Buffer* src_buffer);
 #endif
 
index bf3010c9b01508b25e36d9f800ec9651d19f2db6..1cdfbb3d95556a4846096ed5e8ef1589337850db 100644 (file)
@@ -111,13 +111,13 @@ static gboolean catapult_dct2000_read(wtap *wth, int *err, gchar **err_info,
                                       gint64 *data_offset);
 static gboolean catapult_dct2000_seek_read(wtap *wth, gint64 seek_off,
                                            union wtap_pseudo_header *pseudo_header,
-                                           guchar *pd, int length,
+                                           guint8 *pd, int length,
                                            int *err, gchar **err_info);
 static void catapult_dct2000_close(wtap *wth);
 
 static gboolean catapult_dct2000_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
                                       const union wtap_pseudo_header *pseudo_header,
-                                      const guchar *pd, int *err);
+                                      const guint8 *pd, int *err);
 
 
 /************************************************************/
@@ -135,14 +135,14 @@ static gboolean parse_line(char *linebuff, gint line_length,
                            gchar *context_name, guint8 *context_portp,
                            gchar *protocol_name, gchar *variant_name,
                            gchar *outhdr_name);
-static int write_stub_header(guchar *frame_buffer, char *timestamp_string,
+static int write_stub_header(guint8 *frame_buffer, char *timestamp_string,
                              packet_direction_t direction, int encap,
                              gchar *context_name, guint8 context_port,
                              gchar *protocol_name, gchar *variant_name,
                              gchar *outhdr_name);
-static guchar hex_from_char(gchar c);
-static guchar hex_byte_from_chars(gchar *c);
-static gchar char_from_hex(guchar hex);
+static guint8 hex_from_char(gchar c);
+static guint8 hex_byte_from_chars(gchar *c);
+static gchar char_from_hex(guint8 hex);
 
 static void set_pseudo_header_info(wtap *wth,
                                    int pkt_encap,
@@ -323,7 +323,7 @@ gboolean catapult_dct2000_read(wtap *wth, int *err, gchar **err_info _U_,
                        aal_header_chars,
                        context_name, &context_port,
                        protocol_name, variant_name, outhdr_name)) {
-            guchar *frame_buffer;
+            guint8 *frame_buffer;
             int n;
             int stub_offset = 0;
             line_prefix_info_t *line_prefix_info;
@@ -444,7 +444,7 @@ gboolean catapult_dct2000_read(wtap *wth, int *err, gchar **err_info _U_,
 /**************************************************/
 static gboolean
 catapult_dct2000_seek_read(wtap *wth, gint64 seek_off,
-                           union wtap_pseudo_header *pseudo_header, guchar *pd,
+                           union wtap_pseudo_header *pseudo_header, guint8 *pd,
                            int length, int *err, gchar **err_info)
 {
     gint64 offset = wth->data_offset;
@@ -602,7 +602,7 @@ int catapult_dct2000_dump_can_write_encap(int encap)
 
 gboolean catapult_dct2000_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
                                const union wtap_pseudo_header *pseudo_header,
-                               const guchar *pd, int *err)
+                               const guint8 *pd, int *err)
 {
     guint32 n;
     line_prefix_info_t *prefix = NULL;
@@ -740,8 +740,8 @@ gboolean catapult_dct2000_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
         /* Each binary byte is written out as 2 hex string chars */ 
         for (; n < phdr->len; n++) {
             gchar c[2];
-            c[0] = char_from_hex((guchar)(pd[n] >> 4));
-            c[1] = char_from_hex((guchar)(pd[n] & 0x0f));
+            c[0] = char_from_hex((guint8)(pd[n] >> 4));
+            c[1] = char_from_hex((guint8)(pd[n] & 0x0f));
 
             /* Write both hex chars of byte together */
             if (!wtap_dump_file_write(wdh, c, 2, err)) {
@@ -1221,7 +1221,7 @@ static gboolean parse_line(gchar *linebuff, gint line_length,
 /*****************************************************************/
 /* Write the stub info to the data buffer while reading a packet */
 /*****************************************************************/
-static int write_stub_header(guchar *frame_buffer, char *timestamp_string,
+static int write_stub_header(guint8 *frame_buffer, char *timestamp_string,
                              packet_direction_t direction, int encap,
                              gchar *context_name, guint8 context_port,
                              gchar *protocol_name, gchar *variant_name,
@@ -1383,7 +1383,7 @@ static void set_ppp_info(union wtap_pseudo_header *pseudo_header,
 /********************************************************/
 /* Return hex nibble equivalent of hex string character */
 /********************************************************/
-guchar hex_from_char(gchar c)
+guint8 hex_from_char(gchar c)
 {
     if ((c >= '0') && (c <= '9')) {
         return c - '0';
@@ -1398,13 +1398,13 @@ guchar hex_from_char(gchar c)
 }
 
 /* Extract and return a byte value from 2 ascii hex chars, starting from the given pointer */
-static guchar hex_byte_from_chars(gchar *c)
+static guint8 hex_byte_from_chars(gchar *c)
 {
     static guchar hex_char_array[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                                          'a', 'b', 'c', 'd', 'e', 'f' };
 
     /* Populate lookup table first time */
-    static guchar tableValues[255][255];
+    static guint8 tableValues[255][255];
     static gint tableSet = FALSE;
     if (!tableSet) {
         gint i, j;
@@ -1426,7 +1426,7 @@ static guchar hex_byte_from_chars(gchar *c)
 /********************************************************/
 /* Return character corresponding to hex nibble value   */
 /********************************************************/
-gchar char_from_hex(guchar hex)
+gchar char_from_hex(guint8 hex)
 {
     static char hex_lookup[16] =
     { '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
index b45ba336f119addde44be1e5c69ad8e587d884ef..befa2399bfba8e2d1d77beac1ac28ad93da7dfb2 100644 (file)
@@ -86,13 +86,13 @@ static gboolean commview_read(wtap *wth, int *err, gchar **err_info,
                              gint64 *data_offset);
 static gboolean commview_seek_read(wtap *wth, gint64 seek_off,
                                   union wtap_pseudo_header *pseudo_header,
-                                  guchar *pd, int length, int *err,
+                                  guint8 *pd, int length, int *err,
                                   gchar **err_info);
 static gboolean commview_read_header(commview_header_t *cv_hdr, FILE_T fh,
                                     int *err, gchar **err_info);
 static gboolean commview_dump(wtap_dumper *wdh,        const struct wtap_pkthdr *phdr,
                              const union wtap_pseudo_header *pseudo_header,
-                             const guchar *pd, int *err);
+                             const guint8 *pd, int *err);
 
 int commview_open(wtap *wth, int *err, gchar **err_info)
 {
@@ -223,7 +223,7 @@ commview_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
 
 static gboolean
 commview_seek_read(wtap *wth, gint64 seek_off, union wtap_pseudo_header
-                  *pseudo_header, guchar *pd, int length, int *err,
+                  *pseudo_header, guint8 *pd, int length, int *err,
                   gchar **err_info)
 {
        commview_header_t cv_hdr;
@@ -327,7 +327,7 @@ gboolean commview_dump_open(wtap_dumper *wdh, int *err _U_)
 static gboolean commview_dump(wtap_dumper *wdh,
                              const struct wtap_pkthdr *phdr,
                              const union wtap_pseudo_header *pseudo_header,
-                             const guchar *pd, int *err)
+                             const guint8 *pd, int *err)
 {
        commview_header_t cv_hdr;
        struct tm *tm;
index 4c39b1524c19dd9ef60ee46e25a343af555abd80..113ed4a78fe208dc19e111dfef2a32aff4806091 100644 (file)
@@ -94,7 +94,7 @@ static gboolean daintree_sna_read(wtap *wth, int *err, gchar **err_info,
 
 static gboolean daintree_sna_seek_read(wtap *wth, gint64 seek_off,
        union wtap_pseudo_header *pseudo_header _U_,
-       guchar *pd, int len, int *err,
+       guint8 *pd, int len, int *err,
        gchar **err_info);
 
 static guint daintree_sna_hex_char(guchar *str, int *err);
@@ -199,7 +199,7 @@ daintree_sna_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
  * Wireshark opens the capture file for random access when displaying user-selected packets */
 static gboolean
 daintree_sna_seek_read(wtap *wth, gint64 seek_off, union wtap_pseudo_header
-       *pseudo_header _U_, guchar *pd, int len, int *err,
+       *pseudo_header _U_, guint8 *pd, int len, int *err,
        gchar **err_info)
 {
        guint pkt_len;
@@ -244,15 +244,15 @@ daintree_sna_seek_read(wtap *wth, gint64 seek_off, union wtap_pseudo_header
        return TRUE;
 }
 
-/* Convert an ASCII hex string to guchar */
+/* Convert an ASCII hex string to guint8 */
 static guint
 daintree_sna_hex_char(guchar *str, int *err _U_) {
        guint bytes;
-       guchar *p;
+       guint8 *p;
 
        p = str; /* overlay source buffer */
        bytes = 0;
-       /* convert hex string to guchar */
+       /* convert hex string to guint8 */
        while(*str) {
                if (!isxdigit((guchar)*str)) return 0;
                /* most significant nibble */
index c0ee8e357c49aec2e9ac40c0997761c75f7150c3..0c4e4130af5f5a7af230ec115f049e9f28d9fa10 100644 (file)
@@ -68,7 +68,7 @@ static int erf_read_header(FILE_T fh,
 static gboolean erf_read(wtap *wth, int *err, gchar **err_info,
                         gint64 *data_offset);
 static gboolean erf_seek_read(wtap *wth, gint64 seek_off,
-                             union wtap_pseudo_header *pseudo_header, guchar *pd,
+                             union wtap_pseudo_header *pseudo_header, guint8 *pd,
                              int length, int *err, gchar **err_info);
 
 static const struct {
@@ -307,7 +307,7 @@ static gboolean erf_read(wtap *wth, int *err, gchar **err_info,
 }
 
 static gboolean erf_seek_read(wtap *wth, gint64 seek_off,
-                             union wtap_pseudo_header *pseudo_header, guchar *pd,
+                             union wtap_pseudo_header *pseudo_header, guint8 *pd,
                              int length _U_, int *err, gchar **err_info)
 {
   erf_header_t erf_header;
@@ -553,7 +553,7 @@ static gboolean erf_dump(
     wtap_dumper *wdh,
     const struct wtap_pkthdr *phdr,
     const union wtap_pseudo_header *pseudo_header,
-    const guchar *pd,
+    const guint8 *pd,
     int *err)
 {
   union wtap_pseudo_header other_phdr;
index 0f9544c202b29710d28ec928864e35eb8e67534f..bf4674c896c55d5e3d3e7bdcabb6341068e2653c 100644 (file)
@@ -149,14 +149,14 @@ typedef struct {
 static gboolean etherpeek_read_v7(wtap *wth, int *err, gchar **err_info,
     gint64 *data_offset);
 static gboolean etherpeek_seek_read_v7(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info);
 static void etherpeek_fill_pseudo_header_v7(
     union wtap_pseudo_header *pseudo_header, airopeek_radio_hdr_t *radio_hdr);
 static gboolean etherpeek_read_v56(wtap *wth, int *err, gchar **err_info,
     gint64 *data_offset);
 static gboolean etherpeek_seek_read_v56(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info);
 
 int etherpeek_open(wtap *wth, int *err, gchar **err_info)
@@ -364,7 +364,7 @@ int etherpeek_open(wtap *wth, int *err, gchar **err_info)
 static gboolean etherpeek_read_v7(wtap *wth, int *err, gchar **err_info,
     gint64 *data_offset)
 {
-       guchar ep_pkt[ETHERPEEK_V7_PKT_SIZE];
+       guint8 ep_pkt[ETHERPEEK_V7_PKT_SIZE];
 #if 0
        guint16 protoNum;
 #endif
@@ -478,10 +478,10 @@ static gboolean etherpeek_read_v7(wtap *wth, int *err, gchar **err_info,
 
 static gboolean
 etherpeek_seek_read_v7(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info)
 {
-       guchar ep_pkt[ETHERPEEK_V7_PKT_SIZE];
+       guint8 ep_pkt[ETHERPEEK_V7_PKT_SIZE];
        guint8  status;
        airopeek_radio_hdr_t radio_hdr;
 
@@ -546,7 +546,7 @@ static gboolean etherpeek_read_v56(wtap *wth, int *err, gchar **err_info,
     gint64 *data_offset)
 {
        etherpeek_t *etherpeek = (etherpeek_t *)wth->priv;
-       guchar ep_pkt[ETHERPEEK_V56_PKT_SIZE];
+       guint8 ep_pkt[ETHERPEEK_V56_PKT_SIZE];
        guint16 length;
        guint16 sliceLength;
 #if 0
@@ -637,10 +637,10 @@ static gboolean etherpeek_read_v56(wtap *wth, int *err, gchar **err_info,
 
 static gboolean
 etherpeek_seek_read_v56(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info)
 {
-       guchar ep_pkt[ETHERPEEK_V56_PKT_SIZE];
+       guint8 ep_pkt[ETHERPEEK_V56_PKT_SIZE];
        int pkt_encap;
        guint16 protoNum;
        unsigned int i;
index 27a2753385787992d545b4a1d8267e11cb85b949..8ca55bf9ee4d23a4ba97f1f78b465a31e4556e0d 100644 (file)
@@ -427,7 +427,7 @@ esc_write(wtap_dumper *wdh, const guint8 *buf, int len, int *err)
 static gboolean eyesdn_dump(wtap_dumper *wdh,
                            const struct wtap_pkthdr *phdr,
                            const union wtap_pseudo_header *pseudo_header _U_,
-                           const guchar *pd, int *err);
+                           const guint8 *pd, int *err);
 
 gboolean eyesdn_dump_open(wtap_dumper *wdh, int *err)
 {
@@ -465,7 +465,7 @@ int eyesdn_dump_can_write_encap(int encap)
 static gboolean eyesdn_dump(wtap_dumper *wdh,
                            const struct wtap_pkthdr *phdr,
                            const union wtap_pseudo_header *pseudo_header _U_,
-                           const guchar *pd, int *err)
+                           const guint8 *pd, int *err)
 {
        static const guint8 start_flag = 0xff;
        guint8 buf[EYESDN_HDR_LENGTH];
index e5f9090bb02cea83e6c9d5b57c05587bcd40de43..1560e3ab0fe66bf7b27250ec6e2d2641ae7c8ba4 100644 (file)
@@ -981,7 +981,7 @@ static gboolean wtap_dump_open_finish(wtap_dumper *wdh, int filetype, gboolean c
 }
 
 gboolean wtap_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
-                  const union wtap_pseudo_header *pseudo_header, const guchar *pd, int *err)
+                  const union wtap_pseudo_header *pseudo_header, const guint8 *pd, int *err)
 {
        return (wdh->subtype_write)(wdh, phdr, pseudo_header, pd, err);
 }
index 6c39798683576f625a880950a7c8233aeb4c485e..e4155b5e6b33e9c5b76bd603d2934602ae8f8f66 100644 (file)
@@ -40,12 +40,12 @@ typedef struct {
 static gboolean i4btrace_read(wtap *wth, int *err, gchar **err_info,
     gint64 *data_offset);
 static gboolean i4btrace_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info);
 static int i4b_read_rec_header(FILE_T fh, i4b_trace_hdr_t *hdr, int *err,
     gchar **err_info);
 static void i4b_byte_swap_header(wtap *wth, i4b_trace_hdr_t *hdr);
-static gboolean i4b_read_rec_data(FILE_T fh, guchar *pd, int length, int *err,
+static gboolean i4b_read_rec_data(FILE_T fh, guint8 *pd, int length, int *err,
     gchar **err_info);
 static void i4b_set_pseudo_header(i4b_trace_hdr_t *hdr,
     union wtap_pseudo_header *pseudo_header);
@@ -189,7 +189,7 @@ static gboolean i4btrace_read(wtap *wth, int *err, gchar **err_info,
 
 static gboolean
 i4btrace_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info)
 {
        int     ret;
@@ -259,7 +259,7 @@ i4b_byte_swap_header(wtap *wth, i4b_trace_hdr_t *hdr)
 }
 
 static gboolean
-i4b_read_rec_data(FILE_T fh, guchar *pd, int length, int *err, gchar **err_info)
+i4b_read_rec_data(FILE_T fh, guint8 *pd, int length, int *err, gchar **err_info)
 {
        int     bytes_read;
 
index b7009de4b515ae4018a01a4ac0360e3a9604fe4b..5bd08f58b2099abc9677d093f1129721a82fe34e 100644 (file)
@@ -94,7 +94,7 @@ ipfix_read(wtap *wth, int *err, gchar **err_info,
     gint64 *data_offset);
 static gboolean
 ipfix_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info);
 static void
 ipfix_close(wtap *wth);
@@ -291,7 +291,7 @@ ipfix_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
 /* classic wtap: seek to file position and read packet */
 static gboolean
 ipfix_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length _U_,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length _U_,
     int *err, gchar **err_info)
 {
     ipfix_message_header_t msg_hdr;
index e4e0500195ed60e9e58fb745863a8cbf7d22b5a6..e1f1858bdf5e836a00498bb3f7ea1194075c9c82 100644 (file)
 static gboolean iptrace_read_1_0(wtap *wth, int *err, gchar **err_info,
     gint64 *data_offset);
 static gboolean iptrace_seek_read_1_0(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int packet_size,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int packet_size,
     int *err, gchar **err_info);
 
 static gboolean iptrace_read_2_0(wtap *wth, int *err, gchar **err_info,
     gint64 *data_offset);
 static gboolean iptrace_seek_read_2_0(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int packet_size,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int packet_size,
     int *err, gchar **err_info);
 
 static int iptrace_read_rec_header(FILE_T fh, guint8 *header, int header_len,
@@ -131,7 +131,7 @@ static gboolean iptrace_read_1_0(wtap *wth, int *err, gchar **err_info,
        guint8                  header[IPTRACE_1_0_PHDR_SIZE];
        guint8                  *data_ptr;
        iptrace_1_0_phdr        pkt_hdr;
-       guchar                  fddi_padding[3];
+       guint8                  fddi_padding[3];
 
        /* Read the descriptor data */
        *data_offset = wth->data_offset;
@@ -214,13 +214,13 @@ static gboolean iptrace_read_1_0(wtap *wth, int *err, gchar **err_info,
 }
 
 static gboolean iptrace_seek_read_1_0(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int packet_size,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int packet_size,
     int *err, gchar **err_info)
 {
        int                     ret;
        guint8                  header[IPTRACE_1_0_PHDR_SIZE];
        int                     pkt_encap;
-       guchar                  fddi_padding[3];
+       guint8                  fddi_padding[3];
 
        if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
                return FALSE;
@@ -314,7 +314,7 @@ static gboolean iptrace_read_2_0(wtap *wth, int *err, gchar **err_info,
        guint8                  header[IPTRACE_2_0_PHDR_SIZE];
        guint8                  *data_ptr;
        iptrace_2_0_phdr        pkt_hdr;
-       guchar                  fddi_padding[3];
+       guint8                  fddi_padding[3];
 
        /* Read the descriptor data */
        *data_offset = wth->data_offset;
@@ -397,13 +397,13 @@ static gboolean iptrace_read_2_0(wtap *wth, int *err, gchar **err_info,
 }
 
 static gboolean iptrace_seek_read_2_0(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int packet_size,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int packet_size,
     int *err, gchar **err_info)
 {
        int                     ret;
        guint8                  header[IPTRACE_2_0_PHDR_SIZE];
        int                     pkt_encap;
-       guchar                  fddi_padding[3];
+       guint8                  fddi_padding[3];
 
        if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
                return FALSE;
index 1064a04ac06b1679c03a6091f399b0896b323c96..d41ccac06e423879162e900330b5bd3e02e2e7b5 100644 (file)
@@ -501,7 +501,7 @@ static gboolean k12_read(wtap *wth, int *err, gchar **err_info, gint64 *data_off
 }
 
 
-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) {
+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;
@@ -985,7 +985,7 @@ 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) {
+                         const guint8 *pd, int *err) {
     k12_dump_t *k12 = (k12_dump_t *)wdh->priv;
     guint32 len;
     union {
index 4b6642038e5a6f5ea594ef753682aaef6a324365..095652a7529efed15a5e52f422ea1e482fedc739 100644 (file)
@@ -344,7 +344,7 @@ static const struct { int e; const char* s; } encaps[] = {
 static gboolean
 k12text_dump(wtap_dumper *wdh _U_, const struct wtap_pkthdr *phdr,
             const union wtap_pseudo_header *pseudo_header _U_,
-            const guchar *pd, int *err) {
+            const guint8 *pd, int *err) {
 #define K12BUF_SIZE 196808
        char *buf;
        size_t left = K12BUF_SIZE;
index 13264d971cfbee7ad32c3ddf10be686cd1689dc6..a77c10e8b95814ce143e9336a2a710dbb5ff4377 100644 (file)
@@ -270,7 +270,7 @@ typedef struct {
 static gboolean lanalyzer_read(wtap *wth, int *err, gchar **err_info,
     gint64 *data_offset);
 static gboolean lanalyzer_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info);
 static gboolean lanalyzer_dump_close(wtap_dumper *wdh, int *err);
 
@@ -546,7 +546,7 @@ static gboolean lanalyzer_read(wtap *wth, int *err, gchar **err_info,
 }
 
 static gboolean lanalyzer_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info)
 {
        int bytes_read;
@@ -643,7 +643,7 @@ static void my_timersub(const struct timeval *a,
 static gboolean lanalyzer_dump(wtap_dumper *wdh,
        const struct wtap_pkthdr *phdr,
        const union wtap_pseudo_header *pseudo_header _U_,
-       const guchar *pd, int *err)
+       const guint8 *pd, int *err)
 {
       double x;
       int    i;
index bb232b5fd2eb1e4116f9256c112b677644f629d9..424f4324c17d5067a90e4a3842cdefbfc5e5a4e3 100644 (file)
@@ -30,7 +30,6 @@
 #include "wtap-int.h"
 #include "file_wrappers.h"
 #include "buffer.h"
-#include "atm.h"
 #include "pcap-common.h"
 #include "pcap-encap.h"
 #include "libpcap.h"
@@ -70,15 +69,15 @@ static libpcap_try_t libpcap_try(wtap *wth, int *err);
 static gboolean libpcap_read(wtap *wth, int *err, gchar **err_info,
     gint64 *data_offset);
 static gboolean libpcap_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info);
 static int libpcap_read_header(wtap *wth, int *err, gchar **err_info,
     struct pcaprec_ss990915_hdr *hdr);
 static void adjust_header(wtap *wth, struct pcaprec_hdr *hdr);
-static gboolean libpcap_read_rec_data(FILE_T fh, guchar *pd, int length,
+static gboolean libpcap_read_rec_data(FILE_T fh, guint8 *pd, int length,
     int *err, gchar **err_info);
 static gboolean libpcap_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
-    const union wtap_pseudo_header *pseudo_header, const guchar *pd, int *err);
+    const union wtap_pseudo_header *pseudo_header, const guint8 *pd, int *err);
 
 int libpcap_open(wtap *wth, int *err, gchar **err_info)
 {
@@ -601,7 +600,7 @@ static gboolean libpcap_read(wtap *wth, int *err, gchar **err_info,
        guint packet_size;
        guint orig_size;
        int bytes_read;
-       guchar fddi_padding[3];
+       guint8 fddi_padding[3];
        int phdr_len;
        libpcap_t *libpcap;
 
@@ -674,30 +673,9 @@ static gboolean libpcap_read(wtap *wth, int *err, gchar **err_info,
        wth->phdr.caplen = packet_size;
        wth->phdr.len = orig_size;
 
-       if (wth->file_encap == WTAP_ENCAP_ATM_PDUS) {
-               if (wth->file_type == WTAP_FILE_PCAP_NOKIA) {
-                       /*
-                        * Nokia IPSO ATM.
-                        *
-                        * Guess the traffic type based on the packet
-                        * contents.
-                        */
-                       atm_guess_traffic_type(buffer_start_ptr(wth->frame_buffer),
-                           wth->phdr.caplen, &wth->pseudo_header);
-               } else {
-                       /*
-                        * SunATM.
-                        *
-                        * If this is ATM LANE traffic, try to guess what
-                        * type of LANE traffic it is based on the packet
-                        * contents.
-                        */
-                       if (wth->pseudo_header.atm.type == TRAF_LANE) {
-                               atm_guess_lane_type(buffer_start_ptr(wth->frame_buffer),
-                                   wth->phdr.caplen, &wth->pseudo_header);
-                       }
-               }
-       }
+       pcap_fill_in_pseudo_header(wth->file_type, wth->file_encap,
+           buffer_start_ptr(wth->frame_buffer), wth->phdr.caplen,
+           &wth->pseudo_header, -1);
 
        pcap_read_post_process(wth->file_encap, wth->phdr.caplen,
            libpcap->byte_swapped, buffer_start_ptr(wth->frame_buffer));
@@ -706,7 +684,7 @@ static gboolean libpcap_read(wtap *wth, int *err, gchar **err_info,
 
 static gboolean
 libpcap_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info)
 {
        int phdr_len;
@@ -727,27 +705,9 @@ libpcap_seek_read(wtap *wth, gint64 seek_off,
        if (!libpcap_read_rec_data(wth->random_fh, pd, length, err, err_info))
                return FALSE;   /* failed */
 
-       if (wth->file_encap == WTAP_ENCAP_ATM_PDUS) {
-               if (wth->file_type == WTAP_FILE_PCAP_NOKIA) {
-                       /*
-                        * Nokia IPSO ATM.
-                        *
-                        * Guess the traffic type based on the packet
-                        * contents.
-                        */
-                       atm_guess_traffic_type(pd, length, pseudo_header);
-               } else {
-                       /*
-                        * SunATM.
-                        *
-                        * If this is ATM LANE traffic, try to guess what
-                        * type of LANE traffic it is based on the packet
-                        * contents.
-                        */
-                       if (pseudo_header->atm.type == TRAF_LANE)
-                               atm_guess_lane_type(pd, length, pseudo_header);
-               }
-       }
+       pcap_fill_in_pseudo_header(wth->file_type, wth->file_encap, pd,
+           length, pseudo_header, -1);
+
        pcap_read_post_process(wth->file_encap, length,
            libpcap->byte_swapped, pd);
        return TRUE;
@@ -876,7 +836,7 @@ adjust_header(wtap *wth, struct pcaprec_hdr *hdr)
 }
 
 static gboolean
-libpcap_read_rec_data(FILE_T fh, guchar *pd, int length, int *err,
+libpcap_read_rec_data(FILE_T fh, guint8 *pd, int length, int *err,
     gchar **err_info)
 {
        int     bytes_read;
@@ -981,7 +941,7 @@ gboolean libpcap_dump_open(wtap_dumper *wdh, int *err)
 static gboolean libpcap_dump(wtap_dumper *wdh,
        const struct wtap_pkthdr *phdr,
        const union wtap_pseudo_header *pseudo_header,
-       const guchar *pd, int *err)
+       const guint8 *pd, int *err)
 {
        struct pcaprec_ss990915_hdr rec_hdr;
        size_t hdr_size;
index e6d937647f79a1ad4fd8b103fe27ebb58454a5a2..2cb1ebdb36bef484d38fbc8d893979ebdd1a3db1 100644 (file)
@@ -57,7 +57,7 @@ typedef struct {
 } mime_file_private_t;
 
 typedef struct {
-       const guchar *magic;
+       const guint8 *magic;
        guint magic_len;
 } mime_files_t;
 
@@ -69,7 +69,7 @@ typedef struct {
  * http://www.jpeg.org/public/jfif.pdf
  * http://www.w3.org/Graphics/JPEG/itu-t81.pdf
  */
-static const guchar jpeg_jfif_magic[] = { 0xFF, 0xD8, /* SOF */
+static const guint8 jpeg_jfif_magic[] = { 0xFF, 0xD8, /* SOF */
                                          0xFF        /* start of the next marker */
                                        };
 
@@ -124,7 +124,7 @@ mime_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
 }
 
 static gboolean
-mime_seek_read(wtap *wth, gint64 seek_off, union wtap_pseudo_header *pseudo_header _U_, guchar *pd, int length, int *err, gchar **err_info)
+mime_seek_read(wtap *wth, gint64 seek_off, union wtap_pseudo_header *pseudo_header _U_, guint8 *pd, int length, int *err, gchar **err_info)
 {
        if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1) {
                *err_info = NULL;
index 713aafa02767320be2183cc9e6c9ed94e37a7737..cf60fe2375a8ce60d56f1dc570f61705749bc036 100644 (file)
@@ -94,7 +94,7 @@ mpeg_read_header(wtap *wth, int *err, gchar **err_info, guint32 *n)
 }
 
 static gboolean
-mpeg_read_rec_data(FILE_T fh, guchar *pd, int length, int *err,
+mpeg_read_rec_data(FILE_T fh, guint8 *pd, int length, int *err,
                gchar **err_info)
 {
        int     bytes_read;
@@ -240,7 +240,7 @@ mpeg_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
 
 static gboolean
 mpeg_seek_read(wtap *wth, gint64 seek_off,
-               union wtap_pseudo_header *pseudo_header _U_, guchar *pd, int length,
+               union wtap_pseudo_header *pseudo_header _U_, guint8 *pd, int length,
                int *err, gchar **err_info)
 {
        if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
index cb3ed981f656943bb3741fdfc117155e05c4a571..d6e68a885cf1297e3493e53d1403fbeeae446afa 100644 (file)
@@ -176,17 +176,17 @@ static const int netmon_encap[] = {
 static gboolean netmon_read(wtap *wth, int *err, gchar **err_info,
     gint64 *data_offset);
 static gboolean netmon_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info);
 static gboolean netmon_read_atm_pseudoheader(FILE_T fh,
     union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info);
-static gboolean netmon_read_rec_data(FILE_T fh, guchar *pd, int length,
+static gboolean netmon_read_rec_data(FILE_T fh, guint8 *pd, int length,
     int *err, gchar **err_info);
 static int netmon_read_rec_trailer(FILE_T fh, int trlr_size, int *err,
     gchar **err_info);
 static void netmon_sequential_close(wtap *wth);
 static gboolean netmon_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
-    const union wtap_pseudo_header *pseudo_header, const guchar *pd, int *err);
+    const union wtap_pseudo_header *pseudo_header, const guint8 *pd, int *err);
 static gboolean netmon_dump_close(wtap_dumper *wdh, int *err);
 
 int netmon_open(wtap *wth, int *err, gchar **err_info)
@@ -397,7 +397,7 @@ netmon_trailer_size(netmon_t *netmon)
 
 static void
 netmon_set_pseudo_header_info(int pkt_encap,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length)
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length)
 {
        switch (pkt_encap) {
 
@@ -627,7 +627,7 @@ again:
 
 static gboolean
 netmon_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info)
 {
        netmon_t *netmon = (netmon_t *)wth->priv;
@@ -720,7 +720,7 @@ netmon_read_atm_pseudoheader(FILE_T fh, union wtap_pseudo_header *pseudo_header,
 }
 
 static gboolean
-netmon_read_rec_data(FILE_T fh, guchar *pd, int length, int *err,
+netmon_read_rec_data(FILE_T fh, guint8 *pd, int length, int *err,
     gchar **err_info)
 {
        int     bytes_read;
@@ -907,7 +907,7 @@ gboolean netmon_dump_open(wtap_dumper *wdh, int *err)
 /* Write a record for a packet to a dump file.
    Returns TRUE on success, FALSE on failure. */
 static gboolean netmon_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
-    const union wtap_pseudo_header *pseudo_header, const guchar *pd, int *err)
+    const union wtap_pseudo_header *pseudo_header, const guint8 *pd, int *err)
 {
        netmon_dump_t *netmon = (netmon_dump_t *)wdh->priv;
        struct netmonrec_1_x_hdr rec_1_x_hdr;
index 61c1151be659565bb07dd13fe48c842003f36d6f..da8ba13dce4348611096076035a40fcab2d6930e 100644 (file)
@@ -412,7 +412,7 @@ gboolean nstrace_read_v20(wtap *wth, int *err, gchar **err_info,
                 gint64 *data_offset);
 gboolean nstrace_seek_read(wtap *wth, gint64 seek_off,
                      union wtap_pseudo_header *pseudo_header,
-                     guchar *pd, int length,
+                     guint8 *pd, int length,
                      int *err, gchar **err_info);
 void nstrace_close(wtap *wth);
 void nstrace_sequential_close(wtap *wth);
@@ -423,7 +423,7 @@ gboolean nstrace_set_start_time(wtap *wth);
 guint64        ns_hrtime2nsec(guint32 tm);
 
 static gboolean nstrace_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
-       const union wtap_pseudo_header *pseudo_header, const guchar *pd, int *err);
+       const union wtap_pseudo_header *pseudo_header, const guint8 *pd, int *err);
 
 
 #define GET_READ_PAGE_SIZE(remaining_file_size) ((gint32)((remaining_file_size>NSPR_PAGESIZE)?NSPR_PAGESIZE:remaining_file_size))
@@ -950,7 +950,7 @@ gboolean nstrace_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset
 
 
 gboolean nstrace_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info)
 {
        int bytes_read;
@@ -1131,7 +1131,7 @@ static gboolean nstrace_add_signature(wtap_dumper *wdh, int *err)
 
 static gboolean
 nstrace_add_abstime(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
-     const guchar *pd, int *err)
+     const guint8 *pd, int *err)
 {
        nstrace_dump_t *nstrace = (nstrace_dump_t *)wdh->priv;
        guint64 nsg_creltime;
@@ -1199,7 +1199,7 @@ nstrace_add_abstime(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
 /* Write a record for a packet to a dump file.
    Returns TRUE on success, FALSE on failure. */
 static gboolean nstrace_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
-    const union wtap_pseudo_header *pseudo_header, const guchar *pd, int *err)
+    const union wtap_pseudo_header *pseudo_header, const guint8 *pd, int *err)
 {
        nstrace_dump_t *nstrace = (nstrace_dump_t *)wdh->priv;
 
index e719e7aad78faa7819f6696d42cf4bee70a96031..fe6217915e11820efc85196a3e071a439e17ced7 100644 (file)
@@ -58,7 +58,7 @@ struct nettl_file_hdr {
     gchar      tz[20];
     gchar      host_name[9];
     gchar      os_vers[9];
-    guchar     os_v;
+    guint8     os_v;
     guint8     xxa[8];
     gchar      model[11];
     guint16    unknown;        /* just padding to 128 bytes? */
@@ -182,15 +182,15 @@ typedef struct {
 static gboolean nettl_read(wtap *wth, int *err, gchar **err_info,
                gint64 *data_offset);
 static gboolean nettl_seek_read(wtap *wth, gint64 seek_off,
-               union wtap_pseudo_header *pseudo_header, guchar *pd,
+               union wtap_pseudo_header *pseudo_header, guint8 *pd,
                int length, int *err, gchar **err_info);
 static int nettl_read_rec_header(wtap *wth, FILE_T fh,
                struct wtap_pkthdr *phdr, union wtap_pseudo_header *pseudo_header,
                int *err, gchar **err_info, gboolean *fddihack);
-static gboolean nettl_read_rec_data(FILE_T fh, guchar *pd, int length,
+static gboolean nettl_read_rec_data(FILE_T fh, guint8 *pd, int length,
                int *err, gchar **err_info, gboolean fddihack);
 static gboolean nettl_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
-    const union wtap_pseudo_header *pseudo_header, const guchar *pd, int *err);
+    const union wtap_pseudo_header *pseudo_header, const guint8 *pd, int *err);
 
 int nettl_open(wtap *wth, int *err, gchar **err_info)
 {
@@ -346,7 +346,7 @@ static gboolean nettl_read(wtap *wth, int *err, gchar **err_info,
 
 static gboolean
 nettl_seek_read(wtap *wth, gint64 seek_off,
-               union wtap_pseudo_header *pseudo_header, guchar *pd,
+               union wtap_pseudo_header *pseudo_header, guint8 *pd,
                int length, int *err, gchar **err_info)
 {
     int ret;
@@ -650,7 +650,7 @@ nettl_read_rec_header(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
 }
 
 static gboolean
-nettl_read_rec_data(FILE_T fh, guchar *pd, int length, int *err,
+nettl_read_rec_data(FILE_T fh, guint8 *pd, int length, int *err,
        gchar **err_info, gboolean fddihack)
 {
     int bytes_to_read, bytes_read;
@@ -767,7 +767,7 @@ gboolean nettl_dump_open(wtap_dumper *wdh, int *err)
 static gboolean nettl_dump(wtap_dumper *wdh,
        const struct wtap_pkthdr *phdr,
        const union wtap_pseudo_header *pseudo_header _U_,
-       const guchar *pd, int *err)
+       const guint8 *pd, int *err)
 {
        struct nettlrec_hdr rec_hdr;
        guint8 dummyc[24];
index 729c199f60239f2067a539d7c12ab101e46ae40c..263ba597e8f47338a7c4c6e486c8d7650ee88d30 100644 (file)
@@ -103,7 +103,7 @@ static void init_gmt_to_localtime_offset(void)
 static gboolean observer_read(wtap *wth, int *err, gchar **err_info,
     gint64 *data_offset);
 static gboolean observer_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info);
 static int read_packet_header(FILE_T fh, packet_entry_header *packet_header,
     int *err, gchar **err_info);
@@ -112,7 +112,7 @@ static int read_packet_data(FILE_T fh, int offset_to_frame, int current_offset_f
 static gboolean skip_to_next_packet(wtap *wth, int offset_to_next_packet, 
     int current_offset_from_packet_header, int *err, char **err_info);
 static gboolean observer_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
-    const union wtap_pseudo_header *pseudo_header, const guchar *pd, int *err);
+    const union wtap_pseudo_header *pseudo_header, const guint8 *pd, int *err);
 static gint observer_to_wtap_encap(int observer_encap);
 static gint wtap_to_observer_encap(int wtap_encap);
 
@@ -371,7 +371,7 @@ static gboolean observer_read(wtap *wth, int *err, gchar **err_info,
 
 /* Reads a packet at an offset. */
 static gboolean observer_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info)
 {
     packet_entry_header packet_header;
@@ -648,7 +648,7 @@ gboolean network_instruments_dump_open(wtap_dumper *wdh, int *err)
 /* Write a record for a packet to a dump file.
    Returns TRUE on success, FALSE on failure. */
 static gboolean observer_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
-    const union wtap_pseudo_header *pseudo_header _U_, const guchar *pd,
+    const union wtap_pseudo_header *pseudo_header _U_, const guint8 *pd,
     int *err)
 {
     observer_dump_private_state * private_state = NULL;
index 5bfa9e49b1ed0f85abb04663b5ab45d42399d693..f7285fd7ca501ae9aedb4070a651120fcab3d442 100644 (file)
@@ -321,7 +321,7 @@ typedef struct {
 static gboolean netxray_read(wtap *wth, int *err, gchar **err_info,
     gint64 *data_offset);
 static gboolean netxray_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info);
 static int netxray_read_rec_header(wtap *wth, FILE_T fh,
     union netxrayrec_hdr *hdr, int *err, gchar **err_info);
@@ -331,11 +331,11 @@ static gboolean netxray_read_rec_data(FILE_T fh, guint8 *data_ptr,
     guint32 packet_size, int *err, gchar **err_info);
 static gboolean netxray_dump_1_1(wtap_dumper *wdh,
     const struct wtap_pkthdr *phdr,
-    const union wtap_pseudo_header *pseudo_header, const guchar *pd, int *err);
+    const union wtap_pseudo_header *pseudo_header, const guint8 *pd, int *err);
 static gboolean netxray_dump_close_1_1(wtap_dumper *wdh, int *err);
 static gboolean netxray_dump_2_0(wtap_dumper *wdh,
     const struct wtap_pkthdr *phdr,
-    const union wtap_pseudo_header *pseudo_header, const guchar *pd, int *err);
+    const union wtap_pseudo_header *pseudo_header, const guint8 *pd, int *err);
 static gboolean netxray_dump_close_2_0(wtap_dumper *wdh, int *err);
 
 int netxray_open(wtap *wth, int *err, gchar **err_info)
@@ -1042,7 +1042,7 @@ reread:
 
 static gboolean
 netxray_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info)
 {
        union netxrayrec_hdr hdr;
@@ -1540,7 +1540,7 @@ gboolean netxray_dump_open_1_1(wtap_dumper *wdh, int *err)
 static gboolean netxray_dump_1_1(wtap_dumper *wdh,
                                 const struct wtap_pkthdr *phdr,
                                 const union wtap_pseudo_header *pseudo_header _U_,
-                                const guchar *pd, int *err)
+                                const guint8 *pd, int *err)
 {
        netxray_dump_t *netxray = (netxray_dump_t *)wdh->priv;
        guint64 timestamp;
@@ -1700,7 +1700,7 @@ gboolean netxray_dump_open_2_0(wtap_dumper *wdh, int *err)
 static gboolean netxray_dump_2_0(wtap_dumper *wdh,
                                 const struct wtap_pkthdr *phdr,
                                 const union wtap_pseudo_header *pseudo_header _U_,
-                                const guchar *pd, int *err)
+                                const guint8 *pd, int *err)
 {
        netxray_dump_t *netxray = (netxray_dump_t *)wdh->priv;
        guint64 timestamp;
index 995de9b7df9079ec5db51a89158de6b64c165ce6..1a2322d319afaeec51391954464cac5dda51f1e4 100644 (file)
@@ -489,7 +489,7 @@ static int process_rec_header2_v145(wtap *wth, unsigned char *buffer,
 static gboolean ngsniffer_read(wtap *wth, int *err, gchar **err_info,
     gint64 *data_offset);
 static gboolean ngsniffer_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int packet_size,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int packet_size,
     int *err, gchar **err_info);
 static int ngsniffer_read_rec_header(wtap *wth, gboolean is_random,
     guint16 *typep, guint16 *lengthp, int *err, gchar **err_info);
@@ -506,14 +506,14 @@ static gboolean ngsniffer_read_frame6(wtap *wth, gboolean is_random,
 static void set_pseudo_header_frame6(wtap *wth,
     union wtap_pseudo_header *pseudo_header, struct frame6_rec *frame6);
 static gboolean ngsniffer_read_rec_data(wtap *wth, gboolean is_random,
-    guchar *pd, unsigned int length, int *err, gchar **err_info);
+    guint8 *pd, unsigned int length, int *err, gchar **err_info);
 static int infer_pkt_encap(const guint8 *pd, int len);
 static int fix_pseudo_header(int encap, const guint8 *pd, int len,
     union wtap_pseudo_header *pseudo_header);
 static void ngsniffer_sequential_close(wtap *wth);
 static void ngsniffer_close(wtap *wth);
 static gboolean ngsniffer_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
-    const union wtap_pseudo_header *pseudo_header, const guchar *pd, int *err);
+    const union wtap_pseudo_header *pseudo_header, const guint8 *pd, int *err);
 static gboolean ngsniffer_dump_close(wtap_dumper *wdh, int *err);
 static int SnifferDecompress( unsigned char * inbuf, size_t inlen,
     unsigned char * outbuf, size_t outlen, int *err );
@@ -1050,7 +1050,7 @@ ngsniffer_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
        guint16 time_low, time_med, true_size, size;
        guint8  time_high, time_day;
        guint64 t, tsecs, tpsecs;
-       guchar  *pd;
+       guint8  *pd;
 
        ngsniffer = (ngsniffer_t *)wth->priv;
        for (;;) {
@@ -1248,7 +1248,7 @@ found:
 
 static gboolean
 ngsniffer_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int packet_size,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int packet_size,
     int *err, gchar **err_info)
 {
        int     ret;
@@ -1777,7 +1777,7 @@ set_pseudo_header_frame6(wtap *wth, union wtap_pseudo_header *pseudo_header,
 }
 
 static gboolean
-ngsniffer_read_rec_data(wtap *wth, gboolean is_random, guchar *pd,
+ngsniffer_read_rec_data(wtap *wth, gboolean is_random, guint8 *pd,
     unsigned int length, int *err, gchar **err_info)
 {
        gint64  bytes_read;
@@ -2084,7 +2084,7 @@ ngsniffer_dump_open(wtap_dumper *wdh, int *err)
    Returns TRUE on success, FALSE on failure. */
 static gboolean
 ngsniffer_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
-              const union wtap_pseudo_header *pseudo_header, const guchar *pd, int *err)
+              const union wtap_pseudo_header *pseudo_header, const guint8 *pd, int *err)
 {
        ngsniffer_dump_t *ngsniffer = (ngsniffer_dump_t *)wdh->priv;
        struct frame2_rec rec_hdr;
index 5d00d492d7bbc8c3d9ecda8cf9b8442a0dbdda6b..79e67cfaf1527a689ffe9ddc584102549dbc415a 100644 (file)
@@ -52,7 +52,7 @@ static gboolean packetlogger_read(wtap *wth, int *err, gchar **err_info,
                                  gint64 *data_offset);
 static gboolean packetlogger_seek_read(wtap *wth, gint64 seek_off,
                                       union wtap_pseudo_header *pseudo_header _U_,
-                                      guchar *pd, int length, int *err,
+                                      guint8 *pd, int length, int *err,
                                       gchar **err_info);
 static gboolean packetlogger_read_header(packetlogger_header_t *pl_hdr,
                                         FILE_T fh, int *err, gchar **err_info);
@@ -132,7 +132,7 @@ packetlogger_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
 
 static gboolean
 packetlogger_seek_read(wtap *wth, gint64 seek_off, union wtap_pseudo_header
-                      *pseudo_header _U_, guchar *pd, int length, int *err,
+                      *pseudo_header _U_, guint8 *pd, int length, int *err,
                       gchar **err_info)
 {
        packetlogger_header_t pl_hdr;
index afc1fa71184466ca1285be7e9e9111fbd2b7a29c..c9b9ba27dc139011f0c3d457d55681092171ebb6 100644 (file)
@@ -33,6 +33,7 @@
 #include <errno.h>
 #include "wtap-int.h"
 #include "file_wrappers.h"
+#include "atm.h"
 #include "erf.h"
 #include "pcap-encap.h"
 #include "pcap-common.h"
@@ -1621,9 +1622,46 @@ pcap_process_pseudo_header(FILE_T fh, int file_type, int wtap_encap,
        return phdr_len;
 }
 
+void
+pcap_fill_in_pseudo_header(int file_type, int wtap_encap, guint8 *pd, int length,
+    union wtap_pseudo_header *pseudo_header, int fcs_len)
+{
+       switch (wtap_encap) {
+
+       case WTAP_ENCAP_ATM_PDUS:
+               if (file_type == WTAP_FILE_PCAP_NOKIA) {
+                       /*
+                        * Nokia IPSO ATM.
+                        *
+                        * Guess the traffic type based on the packet
+                        * contents.
+                        */
+                       atm_guess_traffic_type(pd, length, pseudo_header);
+               } else {
+                       /*
+                        * SunATM.
+                        *
+                        * If this is ATM LANE traffic, try to guess what
+                        * type of LANE traffic it is based on the packet
+                        * contents.
+                        */
+                       if (pseudo_header->atm.type == TRAF_LANE)
+                               atm_guess_lane_type(pd, length, pseudo_header);
+               }
+               break;
+
+       case WTAP_ENCAP_ETHERNET:
+               pseudo_header->eth.fcs_len = fcs_len;
+               break;
+
+       default:
+               break;
+       }
+}
+
 void
 pcap_read_post_process(int wtap_encap, guint packet_size,
-    gboolean bytes_swapped, guchar *pd)
+    gboolean bytes_swapped, guint8 *pd)
 {
        switch (wtap_encap) {
 
index c3102ee3f0f614d22ea43f7f73497b57c73e585b..587fdfb8379952c0ca6f54f51a049e3d3f6d759c 100644 (file)
@@ -34,8 +34,12 @@ extern int pcap_process_pseudo_header(FILE_T fh, int file_type, int wtap_encap,
     guint packet_size, gboolean check_packet_size, struct wtap_pkthdr *phdr,
     union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info);
 
+extern void pcap_fill_in_pseudo_header(int file_type, int wtap_encap,
+    guint8 *pd, int length, union wtap_pseudo_header *pseudo_header,
+    int fcs_len);
+
 extern void pcap_read_post_process(int wtap_encap, guint packet_size,
-       gboolean bytes_swapped, guchar *pd);
+       gboolean bytes_swapped, guint8 *pd);
 
 extern int pcap_get_phdr_size(int encap,
     const union wtap_pseudo_header *pseudo_header);
index 698bb9b49a394853dfcb99348c912e0808da44d3..c7aec3035fde7c755958a37a3863fb5471f22df9 100644 (file)
@@ -87,7 +87,7 @@ pcapng_read(wtap *wth, int *err, gchar **err_info,
     gint64 *data_offset);
 static gboolean
 pcapng_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info);
 static void
 pcapng_close(wtap *wth);
@@ -297,7 +297,7 @@ typedef struct wtapng_block_s {
         */
        const union wtap_pseudo_header *pseudo_header;
        struct wtap_pkthdr *packet_header;
-       const guchar *frame_buffer;
+       const guint8 *frame_buffer;
        int *file_encap;
 } wtapng_block_t;
 
@@ -782,7 +782,7 @@ pcapng_read_packet_block(FILE_T fh, pcapng_block_header_t *bh, pcapng_t *pn, wta
        gint wtap_encap;
        int pseudo_header_len;
        char option_content[100]; /* XXX - size might need to be increased, if we see longer options */
-
+       int fcslen;
 
        /* "(Enhanced) Packet Block" read fixed part */
        errno = WTAP_ERR_CANT_READ;
@@ -887,7 +887,7 @@ pcapng_read_packet_block(FILE_T fh, pcapng_block_header_t *bh, pcapng_t *pn, wta
 
        /* "(Enhanced) Packet Block" read capture data */
        errno = WTAP_ERR_CANT_READ;
-       bytes_read = file_read((guchar *) (wblock->frame_buffer), wblock->data.packet.cap_len - pseudo_header_len, fh);
+       bytes_read = file_read((guint8 *) (wblock->frame_buffer), wblock->data.packet.cap_len - pseudo_header_len, fh);
        if (bytes_read != (int) (wblock->data.packet.cap_len - pseudo_header_len)) {
                *err = file_error(fh, err_info);
                pcapng_debug1("pcapng_read_packet_block: couldn't read %u bytes of captured data",
@@ -922,6 +922,9 @@ pcapng_read_packet_block(FILE_T fh, pcapng_block_header_t *bh, pcapng_t *pn, wta
        wblock->data.packet.drop_count  = -1;
        wblock->data.packet.pack_flags  = 0;    /* XXX - is 0 ok to signal "not used"? */
 
+       /* FCS length default */
+       fcslen = pn->if_fcslen;
+
        /* Options */
        errno = WTAP_ERR_CANT_READ;
        to_read = block_total_length
@@ -963,6 +966,10 @@ pcapng_read_packet_block(FILE_T fh, pcapng_block_header_t *bh, pcapng_t *pn, wta
                                memcpy(&wblock->data.packet.pack_flags, option_content, sizeof(guint32));
                                if(pn->byte_swapped)
                                        wblock->data.packet.pack_flags = BSWAP32(wblock->data.packet.pack_flags);
+                               if (wblock->data.packet.pack_flags & 0x000001E0) {
+                                       /* The FCS length is present */
+                                       fcslen = (wblock->data.packet.pack_flags & 0x000001E0) >> 5;
+                               }
                                pcapng_debug1("pcapng_read_if_descr_block: pack_flags %u (ignored)", wblock->data.packet.pack_flags);
                        } else {
                                pcapng_debug1("pcapng_read_if_descr_block: pack_flags length %u not 4 as expected", oh.option_length);
@@ -974,9 +981,14 @@ pcapng_read_packet_block(FILE_T fh, pcapng_block_header_t *bh, pcapng_t *pn, wta
                }
        }
 
+       pcap_fill_in_pseudo_header(WTAP_FILE_PCAPNG, wtap_encap,
+           (guint8 *) (wblock->frame_buffer),
+           (int) (wblock->data.packet.cap_len - pseudo_header_len),
+           (union wtap_pseudo_header *)wblock->pseudo_header, fcslen);
+
        pcap_read_post_process(wtap_encap,
            (int) (wblock->data.packet.cap_len - pseudo_header_len),
-           pn->byte_swapped, (guchar *) (wblock->frame_buffer));
+           pn->byte_swapped, (guint8 *) (wblock->frame_buffer));
        return block_read;
 }
 
@@ -1051,16 +1063,11 @@ pcapng_read_simple_packet_block(FILE_T fh, pcapng_block_header_t *bh, pcapng_t *
                              pseudo_header_len);
        }
 
-       /* XXX - implement other linktypes then Ethernet */
-       /* (or even better share the code with libpcap.c) */
-
-       /* Ethernet FCS length, might be overwritten by "per packet" options */
        memset((void *)wblock->pseudo_header, 0, sizeof(union wtap_pseudo_header));
-       ((union wtap_pseudo_header *) wblock->pseudo_header)->eth.fcs_len = pn->if_fcslen;
 
        /* "Simple Packet Block" read capture data */
        errno = WTAP_ERR_CANT_READ;
-       bytes_read = file_read((guchar *) (wblock->frame_buffer), wblock->data.simple_packet.cap_len, fh);
+       bytes_read = file_read((guint8 *) (wblock->frame_buffer), wblock->data.simple_packet.cap_len, fh);
        if (bytes_read != (int) wblock->data.simple_packet.cap_len) {
                *err = file_error(fh, err_info);
                pcapng_debug1("pcapng_read_simple_packet_block: couldn't read %u bytes of captured data",
@@ -1082,8 +1089,14 @@ pcapng_read_simple_packet_block(FILE_T fh, pcapng_block_header_t *bh, pcapng_t *
                block_read += 4 - (wblock->data.simple_packet.cap_len % 4);
        }
 
+       pcap_fill_in_pseudo_header(WTAP_FILE_PCAPNG, encap,
+           (guint8 *) (wblock->frame_buffer),
+           (int) wblock->data.simple_packet.cap_len,
+           (union wtap_pseudo_header *)wblock->pseudo_header,
+           pn->if_fcslen);
+
        pcap_read_post_process(encap, (int) wblock->data.simple_packet.cap_len,
-           pn->byte_swapped, (guchar *) (wblock->frame_buffer));
+           pn->byte_swapped, (guint8 *) (wblock->frame_buffer));
        return block_read;
 }
 
@@ -1101,7 +1114,7 @@ pcapng_read_name_resolution_block(FILE_T fh, pcapng_block_header_t *bh, pcapng_t
        int to_read;
        guint64 file_offset64;
        pcapng_name_resolution_block_t nrb;
-       guchar nrb_rec[MAX_NRB_REC_SIZE];
+       guint8 nrb_rec[MAX_NRB_REC_SIZE];
        guint32 v4_addr;
 
        errno = WTAP_ERR_CANT_READ;
@@ -1584,7 +1597,7 @@ pcapng_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
 /* classic wtap: seek to file position and read packet */
 static gboolean
 pcapng_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length _U_,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length _U_,
     int *err, gchar **err_info)
 {
        pcapng_t *pcapng = (pcapng_t *)wth->priv;
@@ -1804,7 +1817,7 @@ pcapng_write_name_resolution_block(wtap_dumper *wdh, pcapng_dump_t *pcapng, int
        struct addrinfo *ai;
        struct sockaddr_in *sa4;
        struct sockaddr_in6 *sa6;
-       guchar *rec_data;
+       guint8 *rec_data;
        gint rec_off, namelen, tot_rec_len;
 
        if (! pcapng->addrinfo_list_last || ! pcapng->addrinfo_list_last->ai_next) {
@@ -1934,7 +1947,7 @@ pcapng_lookup_interface_id_by_encap(int wtap_encap, wtap_dumper *wdh)
 static gboolean pcapng_dump(wtap_dumper *wdh,
        const struct wtap_pkthdr *phdr,
        const union wtap_pseudo_header *pseudo_header,
-       const guchar *pd, int *err)
+       const guint8 *pd, int *err)
 {
        wtapng_block_t wblock;
        interface_data_t int_data;
index 3f0094b56756be99ba05ed95d03d8cbff7692603..a4fe9b30e6a21cf0c241617903b323e2d996d07f 100644 (file)
@@ -91,11 +91,11 @@ struct radcomrec_hdr {
 static gboolean radcom_read(wtap *wth, int *err, gchar **err_info,
        gint64 *data_offset);
 static gboolean radcom_seek_read(wtap *wth, gint64 seek_off,
-       union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+       union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
        int *err, gchar **err_info);
 static int radcom_read_rec_header(FILE_T fh, struct radcomrec_hdr *hdr,
        int *err, gchar **err_info);
-static gboolean radcom_read_rec_data(FILE_T fh, guchar *pd, int length,
+static gboolean radcom_read_rec_data(FILE_T fh, guint8 *pd, int length,
        int *err, gchar **err_info);
 
 int radcom_open(wtap *wth, int *err, gchar **err_info)
@@ -279,7 +279,7 @@ static gboolean radcom_read(wtap *wth, int *err, gchar **err_info,
        guint32 sec;
        int     bytes_read;
        struct tm tm;
-       guchar  phdr[8];
+       guint8  phdr[8];
        char    fcs[2];
 
        /* Read record header. */
@@ -379,12 +379,12 @@ static gboolean radcom_read(wtap *wth, int *err, gchar **err_info,
 
 static gboolean
 radcom_seek_read(wtap *wth, gint64 seek_off,
-                union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+                union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
                 int *err, gchar **err_info)
 {
        int     ret;
        struct radcomrec_hdr hdr;
-       guchar  phdr[8];
+       guint8  phdr[8];
 
        if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
                return FALSE;
@@ -450,7 +450,7 @@ radcom_read_rec_header(FILE_T fh, struct radcomrec_hdr *hdr, int *err,
 }
 
 static gboolean
-radcom_read_rec_data(FILE_T fh, guchar *pd, int length, int *err,
+radcom_read_rec_data(FILE_T fh, guint8 *pd, int length, int *err,
                     gchar **err_info)
 {
        int     bytes_read;
index b5446e442e247409caa0f69ef984b309383287e1..477cf3dffcd5ae855e194a5f72b17b7e2b87a49d 100644 (file)
@@ -91,17 +91,17 @@ struct shomiti_trailer {
 static gboolean snoop_read(wtap *wth, int *err, gchar **err_info,
     gint64 *data_offset);
 static gboolean snoop_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info);
 static gboolean snoop_read_atm_pseudoheader(FILE_T fh,
     union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info);
 static gboolean snoop_read_shomiti_wireless_pseudoheader(FILE_T fh,
     union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info,
     int *header_size);
-static gboolean snoop_read_rec_data(FILE_T fh, guchar *pd, int length,
+static gboolean snoop_read_rec_data(FILE_T fh, guint8 *pd, int length,
     int *err, gchar **err_info);
 static gboolean snoop_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
-    const union wtap_pseudo_header *pseudo_header, const guchar *pd, int *err);
+    const union wtap_pseudo_header *pseudo_header, const guint8 *pd, int *err);
 
 /*
  * See
@@ -634,7 +634,7 @@ static gboolean snoop_read(wtap *wth, int *err, gchar **err_info,
 
 static gboolean
 snoop_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
     int *err, gchar **err_info)
 {
        if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
@@ -836,7 +836,7 @@ snoop_read_shomiti_wireless_pseudoheader(FILE_T fh,
 }
 
 static gboolean
-snoop_read_rec_data(FILE_T fh, guchar *pd, int length, int *err,
+snoop_read_rec_data(FILE_T fh, guint8 *pd, int length, int *err,
     gchar **err_info)
 {
        int     bytes_read;
@@ -913,7 +913,7 @@ gboolean snoop_dump_open(wtap_dumper *wdh, int *err)
 static gboolean snoop_dump(wtap_dumper *wdh,
        const struct wtap_pkthdr *phdr,
        const union wtap_pseudo_header *pseudo_header _U_,
-       const guchar *pd, int *err)
+       const guint8 *pd, int *err)
 {
        struct snooprec_hdr rec_hdr;
        int reclen;
index 9c48fe22be2e05f0d3029f9f4c863b6a211fe7d5..e6998ce3d477d44882fa1c147abe58f86f5e0ed4 100644 (file)
@@ -165,12 +165,12 @@ struct visual_write_info
 static gboolean visual_read(wtap *wth, int *err, gchar **err_info,
     gint64 *data_offset);
 static gboolean visual_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int packet_size,
+    union wtap_pseudo_header *pseudo_header, guint8 *pd, int packet_size,
     int *err, gchar **err_info);
 static void visual_set_pseudo_header(int encap, struct visual_pkt_hdr *vpkt_hdr,
     struct visual_atm_hdr *vatm_hdr, union wtap_pseudo_header *pseudo_header);
 static gboolean visual_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
-    const union wtap_pseudo_header *pseudo_header, const guchar *pd, int *err);
+    const union wtap_pseudo_header *pseudo_header, const guint8 *pd, int *err);
 static gboolean visual_dump_close(wtap_dumper *wdh, int *err);
 static void visual_dump_free(wtap_dumper *wdh);
 
@@ -702,7 +702,7 @@ gboolean visual_dump_open(wtap_dumper *wdh, int *err)
 /* Write a packet to a Visual dump file.
    Returns TRUE on success, FALSE on failure. */
 static gboolean visual_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
-    const union wtap_pseudo_header *pseudo_header, const guchar *pd, int *err)
+    const union wtap_pseudo_header *pseudo_header, const guint8 *pd, int *err)
 {
     struct visual_write_info * visual = wdh->priv;
     struct visual_pkt_hdr vpkt_hdr;
index 75923da9e1489eb0eca3a5a85e84ed39ab3355ac..313c6b768e236c8a22749599ef21244d235d7958 100644 (file)
@@ -81,7 +81,7 @@ typedef void *WFILE_T;
 
 typedef gboolean (*subtype_write_func)(struct wtap_dumper*,
                const struct wtap_pkthdr*, const union wtap_pseudo_header*,
-               const guchar*, int*);
+               const guint8*, int*);
 typedef gboolean (*subtype_close_func)(struct wtap_dumper*, int*);
 
 struct wtap_dumper {
index 73f10e83216ca33d60572fb7a9cfbb8e1342ec8e..968b68a6ba4030ae1f992a55526f4b4cbff8ed9a 100644 (file)
@@ -597,7 +597,7 @@ struct k12_phdr {
        const gchar* stack_file;
        guint32 input_type;
        k12_input_info_t input_info;
-       guchar* extra_info;
+       guint8* extra_info;
        guint32 extra_length;
        void* stuff;
 };
@@ -938,7 +938,7 @@ wtap_dumper* wtap_dump_open(const char *filename, int filetype, int encap,
 wtap_dumper* wtap_dump_fdopen(int fd, int filetype, int encap, int snaplen,
        gboolean compressed, int *err);
 gboolean wtap_dump(wtap_dumper *, const struct wtap_pkthdr *,
-       const union wtap_pseudo_header *pseudo_header, const guchar *, int *err);
+       const union wtap_pseudo_header *pseudo_header, const guint8 *, int *err);
 void wtap_dump_flush(wtap_dumper *);
 gint64 wtap_get_bytes_dumped(wtap_dumper *);
 void wtap_set_bytes_dumped(wtap_dumper *wdh, gint64 bytes_dumped);