From Harald Welte:
[obnox/wireshark/wip.git] / wiretap / nettl.c
index 8991731c47f68e74b99f205a3e3acf6f289085f2..735fe9edf7867f5c50cb318725d8e1714cb8d5b8 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,17 +182,17 @@ 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,
-               int *err, gboolean fddihack);
+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 _U_)
+int nettl_open(wtap *wth, int *err, gchar **err_info)
 {
     struct nettl_file_hdr file_hdr;
     guint16 dummy[2];
@@ -200,11 +200,13 @@ int nettl_open(wtap *wth, int *err, gchar **err_info _U_)
     int bytes_read;
     nettl_t *nettl;
 
+    memset(&file_hdr, 0, sizeof(file_hdr));
+
     /* Read in the string that should be at the start of a HP file */
     errno = WTAP_ERR_CANT_READ;
-    bytes_read = file_read(file_hdr.magic, 1, MAGIC_SIZE, wth->fh);
+    bytes_read = file_read(file_hdr.magic, MAGIC_SIZE, wth->fh);
     if (bytes_read != MAGIC_SIZE) {
-       *err = file_error(wth->fh);
+       *err = file_error(wth->fh, err_info);
        if (*err != 0)
            return -1;
        return 0;
@@ -216,10 +218,10 @@ int nettl_open(wtap *wth, int *err, gchar **err_info _U_)
     }
 
     /* Read the rest of the file header */
-    bytes_read = file_read(file_hdr.file_name, 1, FILE_HDR_SIZE - MAGIC_SIZE,
+    bytes_read = file_read(file_hdr.file_name, FILE_HDR_SIZE - MAGIC_SIZE,
                           wth->fh);
     if (bytes_read != FILE_HDR_SIZE - MAGIC_SIZE) {
-       *err = file_error(wth->fh);
+       *err = file_error(wth->fh, err_info);
        if (*err != 0)
            return -1;
        return 0;
@@ -238,7 +240,7 @@ int nettl_open(wtap *wth, int *err, gchar **err_info _U_)
     wth->snapshot_length = 0;  /* not available */
 
     /* read the first header to take a guess at the file encap */
-    bytes_read = file_read(dummy, 1, 4, wth->fh);
+    bytes_read = file_read(dummy, 4, wth->fh);
     if (bytes_read != 4) {
         if (*err != 0) {
             wth->priv = NULL;
@@ -316,6 +318,17 @@ static gboolean nettl_read(wtap *wth, int *err, gchar **err_info,
     }
     wth->data_offset += ret;
 
+    if (wth->phdr.caplen > WTAP_MAX_PACKET_SIZE) {
+       /*
+        * Probably a corrupt capture file; don't blow up trying
+        * to allocate space for an immensely-large packet.
+        */
+       *err = WTAP_ERR_BAD_FILE;
+       *err_info = g_strdup_printf("nettl: File has %u-byte packet, bigger than maximum of %u",
+           wth->phdr.caplen, WTAP_MAX_PACKET_SIZE);
+       return FALSE;
+    }
+
     /*
      * If the per-file encapsulation isn't known, set it to this
      * packet's encapsulation.
@@ -336,7 +349,7 @@ static gboolean nettl_read(wtap *wth, int *err, gchar **err_info,
      */
     buffer_assure_space(wth->frame_buffer, wth->phdr.caplen);
     if (!nettl_read_rec_data(wth->fh, buffer_start_ptr(wth->frame_buffer),
-               wth->phdr.caplen, err, fddihack))
+               wth->phdr.caplen, err, err_info, fddihack))
        return FALSE;   /* Read error */
     wth->data_offset += wth->phdr.caplen;
     return TRUE;
@@ -344,7 +357,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;
@@ -369,7 +382,8 @@ nettl_seek_read(wtap *wth, gint64 seek_off,
     /*
      * Read the packet data.
      */
-    return nettl_read_rec_data(wth->random_fh, pd, length, err, fddihack);
+    return nettl_read_rec_data(wth->random_fh, pd, length, err, err_info,
+        fddihack);
 }
 
 static int
@@ -389,9 +403,9 @@ nettl_read_rec_header(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
     guint8 dummyc[16];
 
     errno = WTAP_ERR_CANT_READ;
-    bytes_read = file_read(&rec_hdr.hdr_len, 1, sizeof rec_hdr.hdr_len, fh);
+    bytes_read = file_read(&rec_hdr.hdr_len, sizeof rec_hdr.hdr_len, fh);
     if (bytes_read != sizeof rec_hdr.hdr_len) {
-       *err = file_error(fh);
+       *err = file_error(fh, err_info);
        if (*err != 0)
            return -1;
        if (bytes_read != 0) {
@@ -403,14 +417,14 @@ nettl_read_rec_header(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
     offset += 2;
     hdr_len = g_ntohs(rec_hdr.hdr_len);
     if (hdr_len < NETTL_REC_HDR_LEN) {
-       *err = WTAP_ERR_BAD_RECORD;
+       *err = WTAP_ERR_BAD_FILE;
        *err_info = g_strdup_printf("nettl: record header length %u too short",
            hdr_len);
        return -1;
     }
-    bytes_read = file_read(&rec_hdr.subsys, 1, NETTL_REC_HDR_LEN - 2, fh);
+    bytes_read = file_read(&rec_hdr.subsys, NETTL_REC_HDR_LEN - 2, fh);
     if (bytes_read != NETTL_REC_HDR_LEN - 2) {
-       *err = file_error(fh);
+       *err = file_error(fh, err_info);
        if (*err == 0)
            *err = WTAP_ERR_SHORT_READ;
        return -1;
@@ -502,9 +516,9 @@ nettl_read_rec_header(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
                     padlen = 0;
                 } else {
                    /* outbound appears to have variable padding */
-                   bytes_read = file_read(dummyc, 1, 9, fh);
+                   bytes_read = file_read(dummyc, 9, fh);
                    if (bytes_read != 9) {
-                       *err = file_error(fh);
+                       *err = file_error(fh, err_info);
                        if (*err == 0)
                            *err = WTAP_ERR_SHORT_READ;
                        return -1;
@@ -555,9 +569,9 @@ nettl_read_rec_header(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
               we assumes everything is. We will crash and burn for anything else */
            /* for encapsulated 100baseT we do this */
            phdr->pkt_encap = WTAP_ENCAP_NETTL_ETHERNET;
-           bytes_read = file_read(&drv_eth_hdr, 1, NS_LS_DRV_ETH_HDR_LEN, fh);
+           bytes_read = file_read(&drv_eth_hdr, NS_LS_DRV_ETH_HDR_LEN, fh);
            if (bytes_read != NS_LS_DRV_ETH_HDR_LEN) {
-               *err = file_error(fh);
+               *err = file_error(fh, err_info);
                if (*err == 0)
                    *err = WTAP_ERR_SHORT_READ;
                return -1;
@@ -621,14 +635,14 @@ nettl_read_rec_header(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
     }
 
     if (length < padlen) {
-       *err = WTAP_ERR_BAD_RECORD;
+       *err = WTAP_ERR_BAD_FILE;
        *err_info = g_strdup_printf("nettl: packet length %u in record header too short, less than %u",
            length, padlen);
        return -1;
     }
     phdr->len = length - padlen;
     if (caplen < padlen) {
-       *err = WTAP_ERR_BAD_RECORD;
+       *err = WTAP_ERR_BAD_FILE;
        *err_info = g_strdup_printf("nettl: captured length %u in record header too short, less than %u",
            caplen, padlen);
        return -1;
@@ -647,37 +661,51 @@ 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, gboolean fddihack)
+nettl_read_rec_data(FILE_T fh, guint8 *pd, int length, int *err,
+       gchar **err_info, gboolean fddihack)
 {
-    int bytes_read;
-    guchar *p=NULL;
+    int bytes_to_read, bytes_read;
     guint8 dummy[3];
 
-    if (fddihack == TRUE) {
-       /* read in FC, dest, src, DSAP and SSAP */
-       if (file_read(pd, 1, 15, fh) == 15) {
-          if (pd[13] == 0xAA) {
-             /* it's SNAP, have to eat 3 bytes??? */
-             if (file_read(dummy, 1, 3, fh) == 3) {
-                p=pd+15;
-                bytes_read = file_read(p, 1, length-18, fh);
-                bytes_read += 18;
-             } else {
-                bytes_read = -1;
-             }
-          } else {
-             /* not SNAP */
-             p=pd+15;
-             bytes_read = file_read(p, 1, length-15, fh);
-             bytes_read += 15;
-          }
-       } else
-          bytes_read = -1;
+    if (fddihack) {
+        /* read in FC, dest, src, DSAP and SSAP */
+        bytes_to_read = 15;
+        if (bytes_to_read > length)
+            bytes_to_read = length;
+        bytes_read = file_read(pd, bytes_to_read, fh);
+        if (bytes_read != bytes_to_read) {
+            if (*err == 0)
+                *err = WTAP_ERR_SHORT_READ;
+            return FALSE;
+        }
+        length -= bytes_read;
+        if (length == 0) {
+               /* There's nothing past the FC, dest, src, DSAP and SSAP */
+               return TRUE;
+        }
+        if (pd[13] == 0xAA) {
+            /* it's SNAP, have to eat 3 bytes??? */
+            bytes_to_read = 3;
+            if (bytes_to_read > length)
+                bytes_to_read = length;
+            bytes_read = file_read(dummy, bytes_to_read, fh);
+            if (bytes_read != bytes_to_read) {
+                if (*err == 0)
+                    *err = WTAP_ERR_SHORT_READ;
+                return FALSE;
+            }
+            length -= bytes_read;
+            if (length == 0) {
+                /* There's nothing past the FC, dest, src, DSAP, SSAP, and 3 bytes to eat */
+               return TRUE;
+           }
+        }
+        bytes_read = file_read(pd + 15, length, fh);
     } else
-       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;
@@ -720,7 +748,7 @@ int nettl_dump_can_write_encap(int encap)
 
 /* Returns TRUE on success, FALSE on failure;
    sets "*err" to an error code on failure */
-gboolean nettl_dump_open(wtap_dumper *wdh, gboolean cant_seek _U_, int *err)
+gboolean nettl_dump_open(wtap_dumper *wdh, int *err)
 {
        struct nettl_file_hdr file_hdr;
 
@@ -750,7 +778,7 @@ gboolean nettl_dump_open(wtap_dumper *wdh, gboolean cant_seek _U_, 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];