From Harald Welte:
[obnox/wireshark/wip.git] / wiretap / radcom.c
index 6d197b00e3f074c32b4257c42971f2d8ec812918..a4fe9b30e6a21cf0c241617903b323e2d996d07f 100644 (file)
@@ -24,7 +24,6 @@
 #include "config.h"
 #endif
 
-#include <stdlib.h>
 #include <errno.h>
 #include <string.h>
 #include "wtap-int.h"
@@ -55,7 +54,7 @@ static const guint8 radcom_magic[8] = {
 };
 
 static const guint8 encap_magic[4] = {
-    0x00, 0x42, 0x43, 0x09
+       0x00, 0x42, 0x43, 0x09
 };
 
 static const guint8 active_time_magic[11] = {
@@ -92,75 +91,77 @@ 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);
-static gboolean radcom_read_rec_data(FILE_T fh, guchar *pd, int length,
-       int *err);
+       int *err, gchar **err_info);
+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)
 {
        int bytes_read;
        guint8 r_magic[8], t_magic[11], search_encap[7];
        struct frame_date start_date;
+#if 0
        guint32 sec;
        struct tm tm;
+#endif
 
        /* Read in the string that should be at the start of a RADCOM file */
        errno = WTAP_ERR_CANT_READ;
        bytes_read = file_read(r_magic, 8, wth->fh);
        if (bytes_read != 8) {
-               *err = file_error(wth->fh);
+               *err = file_error(wth->fh, err_info);
                if (*err != 0)
                        return -1;
                return 0;
        }
 
-        /* XXX: bytes 2 and 3 of the "magic" header seem to be different in some
-         * captures. We force them to our standard value so that the test
-         * succeeds (until we find if they have a special meaning, perhaps a
-         * version number ?) */
-        r_magic[1] = 0xD2;
-        r_magic[2] = 0x00;
+       /* XXX: bytes 2 and 3 of the "magic" header seem to be different in some
+        * captures. We force them to our standard value so that the test
+        * succeeds (until we find if they have a special meaning, perhaps a
+        * version number ?) */
+       r_magic[1] = 0xD2;
+       r_magic[2] = 0x00;
        if (memcmp(r_magic, radcom_magic, 8) != 0) {
                return 0;
        }
 
-        /* Look for the "Active Time" string. The "frame_date" structure should
-         * be located 32 bytes before the beginning of this string */
+       /* Look for the "Active Time" string. The "frame_date" structure should
+        * be located 32 bytes before the beginning of this string */
        wth->data_offset = 8;
        errno = WTAP_ERR_CANT_READ;
        bytes_read = file_read(t_magic, 11, wth->fh);
        if (bytes_read != 11) {
-               *err = file_error(wth->fh);
+               *err = file_error(wth->fh, err_info);
                if (*err != 0)
                        return -1;
                return 0;
        }
-        while (memcmp(t_magic, active_time_magic, 11) != 0)
-        {
-            if (file_seek(wth->fh, -10, SEEK_CUR, err) == -1)
-                return -1;
-            wth->data_offset += 1;
-            errno = WTAP_ERR_CANT_READ;
-            bytes_read = file_read(t_magic, 11, wth->fh);
-            if (bytes_read != 11) {
-                *err = file_error(wth->fh);
-                if (*err != 0)
-                    return -1;
-                return 0;
-            }
-        }
-        if (file_seek(wth->fh, -43, SEEK_CUR, err) == -1) return -1;
+       while (memcmp(t_magic, active_time_magic, 11) != 0)
+       {
+               if (file_seek(wth->fh, -10, SEEK_CUR, err) == -1)
+                       return -1;
+               wth->data_offset += 1;
+               errno = WTAP_ERR_CANT_READ;
+               bytes_read = file_read(t_magic, 11, wth->fh);
+               if (bytes_read != 11) {
+                       *err = file_error(wth->fh, err_info);
+                       if (*err != 0)
+                               return -1;
+                       return 0;
+               }
+       }
+       if (file_seek(wth->fh, -43, SEEK_CUR, err) == -1) return -1;
        wth->data_offset -= 32;
 
        /* Get capture start time */
        errno = WTAP_ERR_CANT_READ;
        bytes_read = file_read(&start_date, sizeof(struct frame_date),
-                               wth->fh);
+                              wth->fh);
        if (bytes_read != sizeof(struct frame_date)) {
-               *err = file_error(wth->fh);
+               *err = file_error(wth->fh, err_info);
                if (*err != 0)
                        return -1;
                return 0;
@@ -174,6 +175,7 @@ int radcom_open(wtap *wth, int *err, gchar **err_info)
        wth->snapshot_length = 0; /* not available in header, only in frame */
        wth->tsprecision = WTAP_FILE_TSPREC_USEC;
 
+#if 0
        tm.tm_year = pletohs(&start_date.year)-1900;
        tm.tm_mon = start_date.month-1;
        tm.tm_mday = start_date.day;
@@ -182,7 +184,7 @@ int radcom_open(wtap *wth, int *err, gchar **err_info)
        tm.tm_min = (sec%3600)/60;
        tm.tm_sec = sec%60;
        tm.tm_isdst = -1;
-
+#endif
        if (file_seek(wth->fh, sizeof(struct frame_date), SEEK_CUR, err) == -1)
                return -1;
        wth->data_offset += sizeof(struct frame_date);
@@ -225,7 +227,8 @@ int radcom_open(wtap *wth, int *err, gchar **err_info)
                return -1;
        }
 
-       /*bytes_read = file_read(&next_date, sizeof(struct frame_date), wth->fh);
+#if 0
+       bytes_read = file_read(&next_date, sizeof(struct frame_date), wth->fh);
        errno = WTAP_ERR_CANT_READ;
        if (bytes_read != sizeof(struct frame_date)) {
                goto read_error;
@@ -240,7 +243,8 @@ int radcom_open(wtap *wth, int *err, gchar **err_info)
                if (bytes_read != sizeof(struct frame_date)) {
                        goto read_error;
                }
-       }*/
+       }
+#endif
 
        if (wth->file_encap == WTAP_ENCAP_ETHERNET) {
                if (file_seek(wth->fh, 294, SEEK_CUR, err) == -1)
@@ -259,15 +263,15 @@ int radcom_open(wtap *wth, int *err, gchar **err_info)
        return 1;
 
 read_error:
-       *err = file_error(wth->fh);
+       *err = file_error(wth->fh, err_info);
        if (*err != 0)
                return -1;
        return 0;
 }
 
 /* Read the next packet */
-static gboolean radcom_read(wtap *wth, int *err, gchar **err_info _U_,
-    gint64 *data_offset)
+static gboolean radcom_read(wtap *wth, int *err, gchar **err_info,
+                           gint64 *data_offset)
 {
        int     ret;
        struct radcomrec_hdr hdr;
@@ -275,12 +279,12 @@ static gboolean radcom_read(wtap *wth, int *err, gchar **err_info _U_,
        guint32 sec;
        int     bytes_read;
        struct tm tm;
-       guchar  phdr[8];
+       guint8  phdr[8];
        char    fcs[2];
 
        /* Read record header. */
        *data_offset = wth->data_offset;
-       ret = radcom_read_rec_header(wth->fh, &hdr, err);
+       ret = radcom_read_rec_header(wth->fh, &hdr, err, err_info);
        if (ret <= 0) {
                /* Read error or EOF */
                return FALSE;
@@ -335,7 +339,8 @@ static gboolean radcom_read(wtap *wth, int *err, gchar **err_info _U_,
                 * XXX - is this stuff a pseudo-header?
                 * The direction appears to be in the "hdr.dce" field.
                 */
-               if (!radcom_read_rec_data(wth->fh, phdr, sizeof phdr, err))
+               if (!radcom_read_rec_data(wth->fh, phdr, sizeof phdr, err,
+                   err_info))
                        return FALSE;   /* Read error */
                wth->data_offset += 8;
                length -= 8;
@@ -349,7 +354,7 @@ static gboolean radcom_read(wtap *wth, int *err, gchar **err_info _U_,
         */
        buffer_assure_space(wth->frame_buffer, length);
        if (!radcom_read_rec_data(wth->fh,
-           buffer_start_ptr(wth->frame_buffer), length, err))
+           buffer_start_ptr(wth->frame_buffer), length, err, err_info))
                return FALSE;   /* Read error */
        wth->data_offset += length;
 
@@ -361,7 +366,7 @@ static gboolean radcom_read(wtap *wth, int *err, gchar **err_info _U_,
                errno = WTAP_ERR_CANT_READ;
                bytes_read = file_read(&fcs, sizeof fcs, wth->fh);
                if (bytes_read != sizeof fcs) {
-                       *err = file_error(wth->fh);
+                       *err = file_error(wth->fh, err_info);
                        if (*err == 0)
                                *err = WTAP_ERR_SHORT_READ;
                        return FALSE;
@@ -374,18 +379,18 @@ static gboolean radcom_read(wtap *wth, int *err, gchar **err_info _U_,
 
 static gboolean
 radcom_seek_read(wtap *wth, gint64 seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
-    int *err, gchar **err_info _U_)
+                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;
 
        /* Read record header. */
-       ret = radcom_read_rec_header(wth->random_fh, &hdr, err);
+       ret = radcom_read_rec_header(wth->random_fh, &hdr, err, err_info);
        if (ret <= 0) {
                /* Read error or EOF */
                if (ret == 0) {
@@ -412,7 +417,7 @@ radcom_seek_read(wtap *wth, gint64 seek_off,
                 * The direction appears to be in the "hdr.dce" field.
                 */
                if (!radcom_read_rec_data(wth->random_fh, phdr, sizeof phdr,
-                   err))
+                   err, err_info))
                        return FALSE;   /* Read error */
                break;
        }
@@ -420,18 +425,19 @@ radcom_seek_read(wtap *wth, gint64 seek_off,
        /*
         * Read the packet data.
         */
-       return radcom_read_rec_data(wth->random_fh, pd, length, err);
+       return radcom_read_rec_data(wth->random_fh, pd, length, err, err_info);
 }
 
 static int
-radcom_read_rec_header(FILE_T fh, struct radcomrec_hdr *hdr, int *err)
+radcom_read_rec_header(FILE_T fh, struct radcomrec_hdr *hdr, int *err,
+                      gchar **err_info)
 {
        int     bytes_read;
 
        errno = WTAP_ERR_CANT_READ;
        bytes_read = file_read(hdr, sizeof *hdr, fh);
        if (bytes_read != sizeof *hdr) {
-               *err = file_error(fh);
+               *err = file_error(fh, err_info);
                if (*err != 0)
                        return -1;
                if (bytes_read != 0) {
@@ -444,7 +450,8 @@ 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;
 
@@ -452,7 +459,7 @@ radcom_read_rec_data(FILE_T fh, guchar *pd, int length, int *err)
        bytes_read = file_read(pd, length, fh);
 
        if (bytes_read != length) {
-               *err = file_error(fh);
+               *err = file_error(fh, err_info);
                if (*err == 0)
                        *err = WTAP_ERR_SHORT_READ;
                return FALSE;