From Harald Welte:
[obnox/wireshark/wip.git] / wiretap / radcom.c
index 64ad916c0e4e57bcbac7eb47b97b3ba7476fc834..a4fe9b30e6a21cf0c241617903b323e2d996d07f 100644 (file)
@@ -1,6 +1,6 @@
 /* radcom.c
  *
- * $Id: radcom.c,v 1.42 2003/10/01 07:11:48 guy Exp $
+ * $Id$
  *
  * Wiretap Library
  * Copyright (c) 1998 by Gilbert Ramirez <gram@alumni.rice.edu>
@@ -24,7 +24,6 @@
 #include "config.h"
 #endif
 
-#include <stdlib.h>
 #include <errno.h>
 #include <string.h>
 #include "wtap-int.h"
@@ -50,15 +49,15 @@ struct unaligned_frame_date {
 
 /* Found at the beginning of the file. Bytes 2 and 3 (D2:00) seem to be
  * different in some captures */
-static guint8 radcom_magic[8] = {
+static const guint8 radcom_magic[8] = {
        0x42, 0xD2, 0x00, 0x34, 0x12, 0x66, 0x22, 0x88
 };
 
-static guint8 encap_magic[4] = {
-    0x00, 0x42, 0x43, 0x09
+static const guint8 encap_magic[4] = {
+       0x00, 0x42, 0x43, 0x09
 };
 
-static guint8 active_time_magic[11] = {
+static const guint8 active_time_magic[11] = {
        0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x54, 0x69, 0x6d, 0x65
 };
 
@@ -89,77 +88,80 @@ struct radcomrec_hdr {
        char    xxw[9];         /* unknown */
 };
 
-static gboolean radcom_read(wtap *wth, int *err, long *data_offset);
-static gboolean radcom_seek_read(wtap *wth, long seek_off,
-       union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
-       int *err);
+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, 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)
+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, 1, 8, wth->fh);
+       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, 1, 11, wth->fh);
+       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, 1, 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, 1, sizeof(struct frame_date),
-                               wth->fh);
+       bytes_read = file_read(&start_date, sizeof(struct frame_date),
+                              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;
@@ -171,7 +173,9 @@ int radcom_open(wtap *wth, int *err)
        wth->subtype_read = radcom_read;
        wth->subtype_seek_read = radcom_seek_read;
        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;
@@ -180,13 +184,13 @@ int radcom_open(wtap *wth, int *err)
        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);
 
        errno = WTAP_ERR_CANT_READ;
-       bytes_read = file_read(search_encap, 1, 4, wth->fh);
+       bytes_read = file_read(search_encap, 4, wth->fh);
        if (bytes_read != 4) {
                goto read_error;
        }
@@ -196,7 +200,7 @@ int radcom_open(wtap *wth, int *err)
                        return -1;
                wth->data_offset -= 3;
                errno = WTAP_ERR_CANT_READ;
-               bytes_read = file_read(search_encap, 1, 4, wth->fh);
+               bytes_read = file_read(search_encap, 4, wth->fh);
                if (bytes_read != 4) {
                        goto read_error;
                }
@@ -206,7 +210,7 @@ int radcom_open(wtap *wth, int *err)
                return -1;
        wth->data_offset += 12;
        errno = WTAP_ERR_CANT_READ;
-       bytes_read = file_read(search_encap, 1, 4, wth->fh);
+       bytes_read = file_read(search_encap, 4, wth->fh);
        if (bytes_read != 4) {
                goto read_error;
        }
@@ -218,12 +222,13 @@ int radcom_open(wtap *wth, int *err)
        else if (memcmp(search_encap, "ATM/", 4) == 0)
                wth->file_encap = WTAP_ENCAP_ATM_RFC1483;
        else {
-               g_message("pcap: network type \"%.4s\" unknown", search_encap);
                *err = WTAP_ERR_UNSUPPORTED_ENCAP;
+               *err_info = g_strdup_printf("radcom: network type \"%.4s\" unknown", search_encap);
                return -1;
        }
 
-       /*bytes_read = file_read(&next_date, 1, 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;
@@ -233,12 +238,13 @@ int radcom_open(wtap *wth, int *err)
                if (file_seek(wth->fh, 1-sizeof(struct frame_date), SEEK_CUR, err) == -1)
                        return -1;
                errno = WTAP_ERR_CANT_READ;
-               bytes_read = file_read(&next_date, 1, sizeof(struct frame_date),
+               bytes_read = file_read(&next_date, sizeof(struct frame_date),
                                   wth->fh);
                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)
@@ -257,14 +263,15 @@ int radcom_open(wtap *wth, int *err)
        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, long *data_offset)
+static gboolean radcom_read(wtap *wth, int *err, gchar **err_info,
+                           gint64 *data_offset)
 {
        int     ret;
        struct radcomrec_hdr hdr;
@@ -272,12 +279,12 @@ static gboolean radcom_read(wtap *wth, int *err, long *data_offset)
        guint32 sec;
        int     bytes_read;
        struct tm tm;
-       char    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;
@@ -290,6 +297,7 @@ static gboolean radcom_read(wtap *wth, int *err, long *data_offset)
                 * field, but non-zero values in other fields, so we
                 * check for that and treat it as an EOF indication.
                 */
+               *err = 0;
                return FALSE;
        }
        length = pletohs(&hdr.length);
@@ -311,8 +319,8 @@ static gboolean radcom_read(wtap *wth, int *err, long *data_offset)
        tm.tm_min = (sec%3600)/60;
        tm.tm_sec = sec%60;
        tm.tm_isdst = -1;
-       wth->phdr.ts.tv_sec = mktime(&tm);
-       wth->phdr.ts.tv_usec = pletohl(&hdr.date.usec);
+       wth->phdr.ts.secs = mktime(&tm);
+       wth->phdr.ts.nsecs = pletohl(&hdr.date.usec) * 1000;
 
        switch (wth->file_encap) {
 
@@ -331,7 +339,8 @@ static gboolean radcom_read(wtap *wth, int *err, long *data_offset)
                 * 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;
@@ -345,21 +354,19 @@ static gboolean radcom_read(wtap *wth, int *err, long *data_offset)
         */
        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;
 
-       wth->phdr.pkt_encap = wth->file_encap;
-
        if (wth->file_encap == WTAP_ENCAP_LAPB) {
                /* Read the FCS.
                   XXX - should we have some way of indicating the
                   presence and size of an FCS to our caller?
                   That'd let us handle other file types as well. */
                errno = WTAP_ERR_CANT_READ;
-               bytes_read = file_read(&fcs, 1, sizeof fcs, wth->fh);
+               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;
@@ -371,18 +378,19 @@ static gboolean radcom_read(wtap *wth, int *err, long *data_offset)
 }
 
 static gboolean
-radcom_seek_read(wtap *wth, long seek_off,
-    union wtap_pseudo_header *pseudo_header, guchar *pd, int length, int *err)
+radcom_seek_read(wtap *wth, gint64 seek_off,
+                union wtap_pseudo_header *pseudo_header, guint8 *pd, int length,
+                int *err, gchar **err_info)
 {
        int     ret;
        struct radcomrec_hdr hdr;
-       char    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) {
@@ -409,7 +417,7 @@ radcom_seek_read(wtap *wth, long 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;
        }
@@ -417,18 +425,19 @@ radcom_seek_read(wtap *wth, long 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, 1, sizeof *hdr, fh);
+       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) {
@@ -441,15 +450,16 @@ 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;
 
        errno = WTAP_ERR_CANT_READ;
-       bytes_read = file_read(pd, 1, length, fh);
+       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;